Merge lp:~mattyw/sharinfoo/list-all into lp:sharinfoo

[Matthew Williams]

Add support for admins to do a shfoo -list command to get a list of all files in the server.

Returned as a json list of path names

Add support for admins to do a shfoo -list command to get a list of all files in the server.

Returned as a json list of path names

[Casey Marshall (cmars)]

review: Approve

=== modified file 'client/client.go'
--- client/client.go	2014-01-13 14:34:27 +0000
+++ client/client.go	2014-01-15 15:03:39 +0000
@@ -228,3 +228,33 @@
 	sha := resp.Header.Get("Content-sha256")
 	return sha, nil
 }
+
+func List(addr string) ([]byte, error) {
+	authString, err := loadAuth()
+	if err != nil {
+		return nil, err
+	}
+
+	query := url.Values{}
+	query.Add("listall", "1")
+
+	u := url.URL{
+		Scheme:   "http",
+		Host:     addr,
+		Path:     "/",
+		RawQuery: query.Encode(),
+	}
+	req, err := http.NewRequest("GET", u.String(), nil)
+	if err != nil {
+		return nil, err
+	}
+	req.Header.Add("Authorization", authString)
+	resp, err := http.DefaultClient.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	if resp.StatusCode != 200 {
+		return nil, fmt.Errorf(resp.Status)
+	}
+	return ioutil.ReadAll(resp.Body)
+}

=== modified file 'client/client_test.go'
--- client/client_test.go	2014-01-13 11:00:26 +0000
+++ client/client_test.go	2014-01-15 15:03:39 +0000
@@ -4,11 +4,11 @@
 	"crypto/sha256"
 	"encoding/base64"
 	"encoding/json"
-	. "launchpad.net/gocheck"
+	gc "launchpad.net/gocheck"
 	"testing"
 )
 
-func Test(t *testing.T) { TestingT(t) }
+func Test(t *testing.T) { gc.TestingT(t) }
 
 var (
 	addr   = "localhost:8080"
@@ -17,47 +17,73 @@
 
 type ClientSuite struct{}
 
-var _ = Suite(&ClientSuite{})
+var _ = gc.Suite(&ClientSuite{})
 
-func (s *ClientSuite) TestPutGet(c *C) {
+func (s *ClientSuite) TestPutGet(c *gc.C) {
 	data := []byte("hello there")
 	path := "/test-data"
 	err := Put(addr, path, data)
-	c.Assert(err, IsNil)
+	c.Assert(err, gc.IsNil)
 	result, err := Get(addr, path)
-	c.Assert(err, IsNil)
-	c.Assert(result, DeepEquals, data)
+	c.Assert(err, gc.IsNil)
+	c.Assert(result, gc.DeepEquals, data)
 	err = Delete(addr, path)
-	c.Assert(err, IsNil)
+	c.Assert(err, gc.IsNil)
 }
 
-func (s *ClientSuite) TestShareAndAccess(c *C) {
+func (s *ClientSuite) TestShareAndAccess(c *gc.C) {
 	output := []map[string]bool{}
 	shareWith := "[e-mail]"
 	data := []byte("hello there")
 	path := "/test-share"
 	err := Put(addr, path, data)
-	c.Assert(err, IsNil)
+	c.Assert(err, gc.IsNil)
 	err = Share(addr, path, shareWith)
-	c.Assert(err, IsNil)
+	c.Assert(err, gc.IsNil)
 	owners, err := Access(addr, path)
 	err = json.Unmarshal(owners, &output)
-	c.Assert(err, IsNil)
-	c.Assert(output[1], DeepEquals, map[string]bool{shareWith: true})
+	c.Assert(err, gc.IsNil)
+	c.Assert(output[1], gc.DeepEquals, map[string]bool{shareWith: true})
 
 	err = Delete(addr, path)
-	c.Assert(err, IsNil)
+	c.Assert(err, gc.IsNil)
 }
 
-func (s *ClientSuite) TestHead(c *C) {
+func (s *ClientSuite) TestHead(c *gc.C) {
 	data := []byte("hello there")
 	path := "/test-data"
 	err := Put(addr, path, data)
-	c.Assert(err, IsNil)
+	c.Assert(err, gc.IsNil)
 	hasher.Write(data)
 	expected := base64.URLEncoding.EncodeToString(hasher.Sum(nil))
 
 	sha, err := Sha(addr, path)
-	c.Assert(err, IsNil)
-	c.Assert(sha, Equals, expected)
+	c.Assert(err, gc.IsNil)
+	c.Assert(sha, gc.Equals, expected)
+}
+
+func (s *ClientSuite) putFile(data []byte, path string, c *gc.C) {
+	err := Put(addr, path, data)
+	c.Assert(err, gc.IsNil)
+}
+
+func (s *ClientSuite) deleteFile(path string, c *gc.C) {
+	err := Delete(addr, path)
+	c.Assert(err, gc.IsNil)
+}
+
+func (s *ClientSuite) TestListAll(c *gc.C) {
+	s.putFile([]byte("hello there"), "/test-data", c)
+	s.putFile([]byte("hello again"), "/test-data-2", c)
+
+	expected := []string{"/test-data-2", "/test-data"}
+	result := []string{}
+
+	list, err := List(addr)
+	c.Assert(err, gc.IsNil)
+	s.deleteFile("/test-data", c)
+	s.deleteFile("/test-data-2", c)
+	err = json.Unmarshal(list, &result)
+	c.Assert(err, gc.IsNil)
+	c.Assert(result, gc.DeepEquals, expected)
 }

=== modified file 'cmd/shfoo/main.go'
--- cmd/shfoo/main.go	2014-01-13 14:34:27 +0000
+++ cmd/shfoo/main.go	2014-01-15 15:03:39 +0000
@@ -35,6 +35,7 @@
 var addr *string = flag.String("http", "localhost:8080", "Remote sharinfoo address")
 var access *string = flag.String("access", "", "Get list of users with access to this path")
 var sha *string = flag.String("sha", "", "Get the sha256 of the file")
+var list *bool = flag.Bool("list", false, "List all files")
 
 func die(err error) {
 	log.Println(err)
@@ -75,6 +76,13 @@
 			die(err)
 		}
 		fmt.Println(output)
+	case *list:
+		output, err := client.List(*addr)
+		if err != nil {
+			die(err)
+		}
+		os.Stdout.Write(output)
+		fmt.Println("")
 	default:
 		err = fmt.Errorf("No action specified")
 	}

=== modified file 'server.go'
--- server.go	2014-01-13 14:34:27 +0000
+++ server.go	2014-01-15 15:03:39 +0000
@@ -60,11 +60,12 @@
 		respError(w, err)
 		return
 	}
+	_, meta := query["meta"]
 	req.ParseForm()
-	if req.Form.Get("meta") == "1" || len(query) == 1 && query["meta"][0] == "1" {
+	if req.Form.Get("meta") == "1" || meta {
 		fs.handleMetadata(w, req)
 	} else {
-		fs.handleContent(w, req)
+		fs.handleContent(w, req, query)
 	}
 }
 
@@ -81,7 +82,38 @@
 	return true
 }
 
-func (fs *FileServer) handleContent(w http.ResponseWriter, req *http.Request) {
+func (fs *FileServer) getFile(w http.ResponseWriter, userId, path string) {
+	access, err := fs.store.Access(userId, path)
+	if err != nil {
+		respError(w, err)
+		return
+	}
+	if !access.CanRead() {
+		respForbidden(w)
+		return
+	}
+	content, err := fs.store.Get(path)
+	if err != nil {
+		respError(w, err)
+		return
+	}
+	_, err = io.Copy(w, content)
+	if err != nil {
+		log.Println(err)
+	}
+}
+
+func (fs *FileServer) getListAll(w http.ResponseWriter) {
+	list, err := fs.store.List()
+	if err != nil {
+		respError(w, err)
+		return
+	}
+	w.WriteHeader(http.StatusOK)
+	w.Write(list)
+}
+
+func (fs *FileServer) handleContent(w http.ResponseWriter, req *http.Request, query url.Values) {
 	userId, err := ValidateAuthorization(req)
 	if err != nil {
 		respError(w, err)
@@ -98,24 +130,17 @@
 
 	switch req.Method {
 	case "GET":
-		access, err := fs.store.Access(userId, path)
-		if err != nil {
-			respError(w, err)
-			return
-		}
-		if !access.CanRead() {
+		_, listall := query["listall"]
+		if listall {
+			if fs.AllowAdmin(userId) {
+				fs.getListAll(w)
+				return
+			}
 			respForbidden(w)
 			return
 		}
-		content, err := fs.store.Get(path)
-		if err != nil {
-			respError(w, err)
-			return
-		}
-		_, err = io.Copy(w, content)
-		if err != nil {
-			log.Println(err)
-		}
+		fs.getFile(w, userId, path)
+		return
 	case "HEAD":
 		hasher := sha256.New()
 		access, err := fs.store.Access(userId, path)

=== modified file 'simplestore.go'
--- simplestore.go	2014-01-07 21:43:46 +0000
+++ simplestore.go	2014-01-15 15:03:39 +0000
@@ -26,19 +26,24 @@
 	"os"
 	"path"
 	"path/filepath"
+	"regexp"
 )
 
+var metaRegex = regexp.MustCompile(".meta$")
+
 type SimpleStore struct {
 	Path string
 }
 
 type SimpleMetadata struct {
+	Path    string
 	Owners  map[string]bool
 	Readers map[string]bool
 }
 
-func NewSimpleMetadata() *SimpleMetadata {
+func NewSimpleMetadata(path string) *SimpleMetadata {
 	return &SimpleMetadata{
+		Path:    path,
 		Owners:  make(map[string]bool),
 		Readers: make(map[string]bool),
 	}
@@ -93,7 +98,7 @@
 	meta, err := ss.metadata(p)
 	if err != nil {
 		if os.IsNotExist(err) {
-			meta = NewSimpleMetadata()
+			meta = NewSimpleMetadata(p)
 		} else {
 			return err
 		}
@@ -131,6 +136,10 @@
 	if err != nil {
 		return nil, err
 	}
+	return ss.openMetaData(mdPath)
+}
+
+func (ss *SimpleStore) openMetaData(mdPath string) (*SimpleMetadata, error) {
 	f, err := os.Open(mdPath)
 	if err != nil {
 		return nil, err
@@ -166,3 +175,24 @@
 	_, err = f.Write(buf)
 	return err
 }
+
+func (ss *SimpleStore) List() ([]byte, error) {
+	pathList := []string{}
+	walkerF := func(path string, info os.FileInfo, err error) error {
+		if metaRegex.Match([]byte(info.Name())) {
+			md, err := ss.openMetaData(path)
+			if err != nil {
+				return err
+			}
+			if md.Path != "" { //For now, if the path is empty - ignore it
+				pathList = append(pathList, md.Path)
+			}
+		}
+		return nil
+	}
+	err := filepath.Walk(ss.Path, walkerF)
+	if err != nil {
+		return nil, err
+	}
+	return json.Marshal(pathList)
+}

=== modified file 'store.go'
--- store.go	2014-01-07 21:43:46 +0000
+++ store.go	2014-01-15 15:03:39 +0000
@@ -53,4 +53,5 @@
 	Get(path string) (io.ReadCloser, error)
 	Put(path, owner string, content io.ReadCloser) error
 	Delete(path string) error
+	List() (string, error)
 }

=== modified file 'tests/client_test.py'
--- tests/client_test.py	2014-01-13 14:34:27 +0000
+++ tests/client_test.py	2014-01-15 15:03:39 +0000
@@ -26,6 +26,11 @@
             f.write(line)
 
 
+def list_command():
+    out = subprocess.Popen(["shfoo", "-list"], stdout=subprocess.PIPE)
+    return out.stdout.read().strip()
+
+
 def share_command(path, share):
     subprocess.check_call(["shfoo", "-share", "/%s" % path, "-with", share])
 
@@ -81,5 +86,10 @@
         out = sha_command(test_data)
         self.assertEquals(out, expected)
 
+    def test_list(self):
+        ls = list_command()
+        expected = '["/%s"]' % test_data
+        self.assertEquals(ls, expected)
+
 if __name__ == '__main__':
     unittest.main()