sort.Strings(names)
for _, name := range names {
- node := dn.inodes[name]
- switch node := node.(type) {
+ switch node := dn.inodes[name].(type) {
case *dirnode:
subdir, err := node.marshalManifest(prefix + "/" + name)
if err != nil {
}
func (dn *dirnode) loadManifest(txt string) error {
- // FIXME: faster
var dirname string
streams := strings.Split(txt, "\n")
if streams[len(streams)-1] != "" {
return fmt.Errorf("line %d: no trailing newline", len(streams))
}
- var extents []storedExtent
- for i, stream := range streams[:len(streams)-1] {
+ streams = streams[:len(streams)-1]
+ extents := []storedExtent{}
+ for i, stream := range streams {
lineno := i + 1
var anyFileTokens bool
var pos int64
// situation might be rare anyway)
extIdx, pos = 0, 0
}
- for next := int64(0); extIdx < len(extents); extIdx, pos = extIdx+1, next {
+ for next := int64(0); extIdx < len(extents); extIdx++ {
e := extents[extIdx]
next = pos + int64(e.Len())
if next <= offset || e.Len() == 0 {
})
if next > offset+length {
break
+ } else {
+ pos = next
}
}
if extIdx == len(extents) && pos < offset+length {
// only safe to call from loadManifest -- no locking
func (dn *dirnode) createFileAndParents(path string) (fn *filenode, err error) {
names := strings.Split(path, "/")
- if basename := names[len(names)-1]; basename == "" || basename == "." || basename == ".." {
+ basename := names[len(names)-1]
+ if basename == "" || basename == "." || basename == ".." {
err = fmt.Errorf("invalid filename")
return
}
- var node inode = dn
- for i, name := range names {
- dn, ok := node.(*dirnode)
- if !ok {
- err = ErrFileExists
- return
- }
- if name == "" || name == "." {
- continue
- }
- if name == ".." {
- node = dn.parent
- continue
- }
- node, ok = dn.inodes[name]
- if !ok {
- if i == len(names)-1 {
- fn = dn.newFilenode(name, 0755)
+ for _, name := range names[:len(names)-1] {
+ switch name {
+ case "", ".":
+ case "..":
+ dn = dn.parent
+ default:
+ switch node := dn.inodes[name].(type) {
+ case nil:
+ dn = dn.newDirnode(name, 0755)
+ case *dirnode:
+ dn = node
+ case *filenode:
+ err = ErrFileExists
return
}
- node = dn.newDirnode(name, 0755)
}
}
- var ok bool
- if fn, ok = node.(*filenode); !ok {
- err = ErrInvalidArgument
+ switch node := dn.inodes[basename].(type) {
+ case nil:
+ fn = dn.newFilenode(basename, 0755)
+ case *filenode:
+ fn = node
+ case *dirnode:
+ err = ErrIsDirectory
}
return
}
}
func (dn *dirnode) Remove(name string) error {
- return dn.remove(name, false)
+ return dn.remove(strings.TrimRight(name, "/"), false)
}
func (dn *dirnode) RemoveAll(name string) error {
- return dn.remove(name, true)
+ err := dn.remove(strings.TrimRight(name, "/"), true)
+ if os.IsNotExist(err) {
+ // "If the path does not exist, RemoveAll returns
+ // nil." (see "os" pkg)
+ err = nil
+ }
+ return err
}
func (dn *dirnode) remove(name string, recursive bool) error {
}
}
} else {
+ if newdn.inodes == nil {
+ newdn.inodes = make(map[string]inode)
+ }
newdn.fileinfo.size++
}
newdn.inodes[newname] = oldinode
+ switch n := oldinode.(type) {
+ case *dirnode:
+ n.parent = newdn
+ case *filenode:
+ n.parent = newdn
+ default:
+ panic(fmt.Sprintf("bad inode type %T", n))
+ }
delete(olddn.inodes, oldname)
olddn.fileinfo.size--
return nil
c.Assert(err, check.IsNil)
err = fs.Mkdir("dir1/dir2", 0755)
c.Assert(err, check.IsNil)
+ err = fs.Mkdir("dir1/dir3", 0755)
+ c.Assert(err, check.IsNil)
err = fs.Remove("dir0")
c.Check(err, check.IsNil)
err = fs.Remove("dir0")
c.Check(err, check.Equals, os.ErrNotExist)
- err = fs.Remove("dir1/dir2/")
- c.Check(err, check.Equals, ErrInvalidArgument)
err = fs.Remove("dir1/dir2/.")
c.Check(err, check.Equals, ErrInvalidArgument)
err = fs.Remove("dir1/dir2/..")
c.Check(err, check.Equals, ErrDirectoryNotEmpty)
err = fs.Remove("dir1/dir2/../../../dir1")
c.Check(err, check.Equals, ErrDirectoryNotEmpty)
+ err = fs.Remove("dir1/dir3/")
+ c.Check(err, check.IsNil)
err = fs.RemoveAll("dir1")
c.Check(err, check.IsNil)
err = fs.RemoveAll("dir1")
- c.Check(err, check.Equals, os.ErrNotExist)
+ c.Check(err, check.IsNil)
}
func (s *CollectionFSSuite) TestRename(c *check.C) {
// oldname does not exist
err := fs.Rename(
fmt.Sprintf("dir%d/dir%d/missing", i, j),
- fmt.Sprintf("dir%d/irelevant", outer-i-1))
+ fmt.Sprintf("dir%d/dir%d/file%d", outer-i-1, j, j))
c.Check(err, check.ErrorMatches, `.*does not exist`)
// newname parent dir does not exist
match: `(?ms).*succeeded.*`,
data: testdata,
},
+ {
+ path: writePath,
+ cmd: "move testfile newdir0\n",
+ match: `(?ms).*Moving .* succeeded.*`,
+ },
+ {
+ // Strangely, webdav deletes dst if you do
+ // "move nonexistent dst" -- otherwise we
+ // would repeat the above "move testfile
+ // newdir0" here.
+ path: writePath,
+ cmd: "move testfile nonexistentdir\n",
+ match: `(?ms).*Moving .* failed.*`,
+ },
+ {
+ path: writePath,
+ cmd: "ls\n",
+ match: `(?ms).*newdir0.* 0 .*`,
+ },
+ {
+ path: writePath,
+ cmd: "move newdir0/testfile emptyfile/bogus/\n",
+ match: `(?ms).*Moving .* failed.*`,
+ },
+ {
+ path: writePath,
+ cmd: "mkcol newdir1\n",
+ match: `(?ms).*Creating .* succeeded.*`,
+ },
+ {
+ path: writePath,
+ cmd: "move newdir0/testfile newdir1\n",
+ match: `(?ms).*Moving .* succeeded.*`,
+ },
+ {
+ path: writePath,
+ cmd: "put '" + localfile.Name() + "' newdir1/testfile1\n",
+ match: `(?ms).*Uploading .* succeeded.*`,
+ },
+ {
+ path: writePath,
+ cmd: "mkcol newdir2\n",
+ match: `(?ms).*Creating .* succeeded.*`,
+ },
+ {
+ path: writePath,
+ cmd: "put '" + localfile.Name() + "' newdir2/testfile2\n",
+ match: `(?ms).*Uploading .* succeeded.*`,
+ },
+ {
+ path: writePath,
+ cmd: "get newdir2/testfile2 '" + checkfile.Name() + "'\n",
+ match: `(?ms).*succeeded.*`,
+ data: testdata,
+ },
+ {
+ path: writePath,
+ cmd: "rmcol newdir2\n",
+ match: `(?ms).*Deleting collection .* succeeded.*`,
+ },
+ {
+ path: writePath,
+ cmd: "get newdir2/testfile2 '" + checkfile.Name() + "'\n",
+ match: `(?ms).*Downloading .* failed.*`,
+ },
} {
c.Logf("%s %+v", "http://"+s.testServer.Addr, trial)
var (
webdavMethod = map[string]bool{
+ "DELETE": true,
+ "MKCOL": true,
"MOVE": true,
"OPTIONS": true,
"PROPFIND": true,
"PUT": true,
+ "RMCOL": true,
}
browserMethod = map[string]bool{
"GET": true,
return
}
w.Header().Set("Access-Control-Allow-Headers", "Authorization, Content-Type, Range")
- w.Header().Set("Access-Control-Allow-Methods", "GET, MOVE, OPTIONS, POST, PROPFIND, PUT")
+ w.Header().Set("Access-Control-Allow-Methods", "DELETE, GET, MKCOL, MOVE, OPTIONS, POST, PROPFIND, PUT, RMCOL")
w.Header().Set("Access-Control-Allow-Origin", "*")
w.Header().Set("Access-Control-Max-Age", "86400")
statusCode = http.StatusOK
c.Check(resp.Code, check.Equals, http.StatusOK)
c.Check(resp.Body.String(), check.Equals, "")
c.Check(resp.Header().Get("Access-Control-Allow-Origin"), check.Equals, "*")
- c.Check(resp.Header().Get("Access-Control-Allow-Methods"), check.Equals, "GET, MOVE, OPTIONS, POST, PROPFIND, PUT")
+ c.Check(resp.Header().Get("Access-Control-Allow-Methods"), check.Equals, "DELETE, GET, MKCOL, MOVE, OPTIONS, POST, PROPFIND, PUT, RMCOL")
c.Check(resp.Header().Get("Access-Control-Allow-Headers"), check.Equals, "Authorization, Content-Type, Range")
// Check preflight for a disallowed request
resp = httptest.NewRecorder()
- req.Header.Set("Access-Control-Request-Method", "DELETE")
+ req.Header.Set("Access-Control-Request-Method", "MAKE-COFFEE")
h.ServeHTTP(resp, req)
c.Check(resp.Body.String(), check.Equals, "")
c.Check(resp.Code, check.Equals, http.StatusMethodNotAllowed)
"fmt"
prand "math/rand"
"os"
+ "path"
+ "strings"
"sync/atomic"
"time"
// webdavFS implements a webdav.FileSystem by wrapping an
// arvados.CollectionFilesystem.
+//
+// Collections don't preserve empty directories, so Mkdir is
+// effectively a no-op, and we need to make parent dirs spring into
+// existence automatically so sequences like "mkcol foo; put foo/bar"
+// work as expected.
type webdavFS struct {
collfs arvados.CollectionFileSystem
update func() error
}
+func (fs *webdavFS) makeparents(name string) {
+ dir, name := path.Split(name)
+ if dir == "" || dir == "/" {
+ return
+ }
+ dir = dir[:len(dir)-1]
+ fs.makeparents(dir)
+ fs.collfs.Mkdir(dir, 0755)
+}
+
func (fs *webdavFS) Mkdir(ctx context.Context, name string, perm os.FileMode) error {
- return fs.collfs.Mkdir(name, 0755)
+ if fs.update == nil {
+ return errReadOnly
+ }
+ name = strings.TrimRight(name, "/")
+ fs.makeparents(name)
+ if err := fs.collfs.Mkdir(name, 0755); err != nil {
+ return err
+ }
+ return fs.update()
}
func (fs *webdavFS) OpenFile(ctx context.Context, name string, flag int, perm os.FileMode) (f webdav.File, err error) {
writing := flag&(os.O_WRONLY|os.O_RDWR) != 0
- if writing && fs.update == nil {
- return nil, errReadOnly
+ if writing {
+ if fs.update == nil {
+ return nil, errReadOnly
+ }
+ fs.makeparents(name)
}
f, err = fs.collfs.OpenFile(name, flag, perm)
if writing && err == nil {
}
func (fs *webdavFS) RemoveAll(ctx context.Context, name string) error {
- return fs.collfs.RemoveAll(name)
+ if err := fs.collfs.RemoveAll(name); err != nil {
+ return err
+ }
+ return fs.update()
}
func (fs *webdavFS) Rename(ctx context.Context, oldName, newName string) error {
if fs.update == nil {
return errReadOnly
}
- return fs.collfs.Rename(oldName, newName)
+ fs.makeparents(newName)
+ if err := fs.collfs.Rename(oldName, newName); err != nil {
+ return err
+ }
+ return fs.update()
}
func (fs *webdavFS) Stat(ctx context.Context, name string) (os.FileInfo, error) {
+ if fs.update != nil {
+ fs.makeparents(name)
+ }
return fs.collfs.Stat(name)
}
projects / arvados.git / commitdiff