handler for uploading and downloading

Author: sqs

download_test.go

@@ -0,0 +1,78 @@
+package httpfstream
+
+import (
+	"net/http"
+	"os"
+	"strings"
+	"testing"
+)
+
+type downloadTest struct {
+	path string
+	body string
+
+	writeFiles map[string]string
+
+	// error responses
+	statusCode int
+	msg        string
+}
+
+func TestDownload(t *testing.T) {
+	tests := []downloadTest{
+		{path: "/foo", body: "bar", writeFiles: map[string]string{"/foo": "bar"}, statusCode: http.StatusOK},
+
+		{path: "/doesntexist", statusCode: http.StatusNotFound, msg: "404 page not found"},
+	}
+	for _, test := range tests {
+		testDownload(t, test)
+	}
+}
+
+func testDownload(t *testing.T, test downloadTest) {
+	label := test.path
+
+	server := newTestServer()
+	defer server.close()
+
+	for path, data := range test.writeFiles {
+		w, err := server.fs.OpenFile(path, os.O_WRONLY|os.O_CREATE|os.O_TRUNC|os.O_EXCL)
+		if err != nil {
+			t.Fatalf("%s: fs.WriterOpen: %s", label, err)
+		}
+		_, err = w.Write([]byte(data))
+		if err != nil {
+			t.Fatalf("%s: Write: %s", label, err)
+		}
+		err = w.Close()
+		if err != nil {
+			t.Fatalf("%s: Close: %s", label, err)
+		}
+	}
+
+	req, err := http.NewRequest("GET", server.URL+test.path, nil)
+	if err != nil {
+		t.Fatalf("%s: NewRequest: %s", label, err)
+	}
+
+	resp, err := http.DefaultClient.Do(req)
+	if err != nil {
+		t.Fatalf("%s: Do: %s", label, err)
+	}
+
+	if test.statusCode != resp.StatusCode {
+		t.Errorf("%s: want StatusCode == %d, got %d", label, test.statusCode, resp.StatusCode)
+	}
+
+	body := string(readAll(t, resp.Body))
+	if test.statusCode >= 200 && test.statusCode <= 299 {
+		if test.body != body {
+			t.Errorf("%s: want data == %q, got %q", label, test.body, body)
+		}
+	} else {
+		msg := strings.TrimSpace(body)
+		if test.msg != msg {
+			t.Errorf("%s: want error message %q, got %q", label, test.msg, msg)
+		}
+	}
+}

http_test.go

@@ -0,0 +1,51 @@
+package httpfstream
+
+import (
+	"github.com/sourcegraph/rwvfs"
+	"io"
+	"io/ioutil"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"testing"
+)
+
+type testServer struct {
+	*httptest.Server
+	dir string
+	fs  rwvfs.FileSystem
+}
+
+func newTestServer() testServer {
+	dir, err := ioutil.TempDir("", "httpfstream")
+	if err != nil {
+		panic("TempDir: " + err.Error())
+	}
+	err = os.MkdirAll(dir, 0700)
+	if err != nil {
+		panic("MkdirAll: " + err.Error())
+	}
+
+	rootMux := http.NewServeMux()
+	fs := rwvfs.OS(dir)
+	rootMux.Handle("/", New(fs))
+	return testServer{
+		Server: httptest.NewServer(rootMux),
+		dir:    dir,
+		fs:     fs,
+	}
+}
+
+func (s testServer) close() {
+	s.Server.Close()
+	os.RemoveAll(s.dir)
+}
+
+func readAll(t *testing.T, rdr io.ReadCloser) []byte {
+	defer rdr.Close()
+	data, err := ioutil.ReadAll(rdr)
+	if err != nil {
+		t.Fatal("ReadAll", err)
+	}
+	return data
+}

httpfstream.go

@@ -0,0 +1,33 @@
+package httpfstream
+
+import (
+	"code.google.com/p/go.tools/godoc/vfs/httpfs"
+	"github.com/sourcegraph/rwvfs"
+	"log"
+	"net/http"
+)
+
+func New(root rwvfs.FileSystem) handler {
+	return handler{
+		Root:   root,
+		httpFS: httpfs.New(root),
+	}
+}
+
+type handler struct {
+	Root rwvfs.FileSystem
+	Log  *log.Logger
+
+	httpFS http.FileSystem
+}
+
+func (h handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	switch r.Method {
+	case "GET":
+		http.FileServer(h.httpFS).ServeHTTP(w, r)
+	case "PUT":
+		h.Upload(w, r)
+	default:
+		http.Error(w, "only GET or PUT methods are supported", http.StatusBadRequest)
+	}
+}

upload.go

@@ -0,0 +1,45 @@
+package httpfstream
+
+import (
+	"io"
+	"net/http"
+	"os"
+)
+
+func (h handler) Upload(w http.ResponseWriter, r *http.Request) {
+	if h.Log != nil {
+		h.Log.Printf("PUT %s", r.URL.Path)
+	}
+
+	defer r.Body.Close()
+
+	if r.URL.Path[len(r.URL.Path)-1] == '/' {
+		http.Error(w, "path must not end with '/'", http.StatusBadRequest)
+		return
+	}
+
+	f, err := h.Root.OpenFile(r.URL.Path, os.O_WRONLY|os.O_CREATE|os.O_TRUNC|os.O_EXCL)
+	if err != nil {
+		http.Error(w, "failed to open destination file for writing: "+err.Error(), http.StatusInternalServerError)
+		return
+	}
+	defer f.Close()
+
+	_, err = io.Copy(f, r.Body)
+	if err != nil {
+		http.Error(w, "failed to copy upload stream to file: "+err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	err = r.Body.Close()
+	if err != nil {
+		http.Error(w, "failed to close upload stream: "+err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	err = f.Close()
+	if err != nil {
+		http.Error(w, "failed to close destination file: "+err.Error(), http.StatusInternalServerError)
+		return
+	}
+}

upload_test.go

@@ -0,0 +1,65 @@
+package httpfstream
+
+import (
+	"bytes"
+	"io"
+	"net/http"
+	"strings"
+	"testing"
+)
+
+type uploadTest struct {
+	path string
+	data io.Reader
+
+	// error responses
+	statusCode int
+	msg        string
+}
+
+func TestUpload(t *testing.T) {
+	tests := []uploadTest{
+		{path: "/foo", data: bytes.NewReader([]byte("bar")), statusCode: http.StatusOK},
+		{path: "/foo", statusCode: http.StatusOK},
+
+		{path: "/", statusCode: http.StatusBadRequest, msg: "path must not end with '/'"},
+		{path: "/..", statusCode: http.StatusMovedPermanently},
+		{path: "/../foo", statusCode: http.StatusMovedPermanently},
+	}
+	for _, test := range tests {
+		testUpload(t, test)
+	}
+}
+
+func testUpload(t *testing.T, test uploadTest) {
+	label := test.path
+
+	server := newTestServer()
+	defer server.close()
+
+	req, err := http.NewRequest("PUT", server.URL+test.path, nil)
+	if err != nil {
+		t.Fatalf("%s: NewRequest: %s", label, err)
+	}
+
+	resp, err := http.DefaultClient.Do(req)
+	if err != nil {
+		t.Fatalf("%s: Do: %s", label, err)
+	}
+
+	if test.statusCode != resp.StatusCode {
+		t.Errorf("%s: want StatusCode == %d, got %d", label, test.statusCode, resp.StatusCode)
+	}
+
+	if test.statusCode >= 200 && test.statusCode <= 299 {
+		_, err = server.fs.Stat(test.path)
+		if err != nil {
+			t.Errorf("%s: Stat: %s", label, err)
+		}
+	} else {
+		msg := strings.TrimSpace(string(readAll(t, resp.Body)))
+		if test.msg != msg {
+			t.Errorf("%s: want error message %q, got %q", label, test.msg, msg)
+		}
+	}
+}