seaweedfs/weed/server/webdav_server.go

package weed_server

import (
	"context"
	"errors"
	"fmt"
	"io"
	"net/http"
	"net/url"
	"os"
	"path"
	"strings"
	"time"

	"github.com/seaweedfs/seaweedfs/weed/util/version"

	"github.com/seaweedfs/seaweedfs/weed/util/buffered_writer"
	"golang.org/x/net/webdav"
	"google.golang.org/grpc"

	"github.com/seaweedfs/seaweedfs/weed/pb"
	"github.com/seaweedfs/seaweedfs/weed/pb/filer_pb"
	"github.com/seaweedfs/seaweedfs/weed/util"
	"github.com/seaweedfs/seaweedfs/weed/util/chunk_cache"
	"github.com/seaweedfs/seaweedfs/weed/wdclient"

	"github.com/seaweedfs/seaweedfs/weed/filer"
	"github.com/seaweedfs/seaweedfs/weed/glog"
	"github.com/seaweedfs/seaweedfs/weed/security"
)

type WebDavOption struct {
	Filer          pb.ServerAddress
	FilerRootPath  string
	DomainName     string
	BucketsPath    string
	GrpcDialOption grpc.DialOption
	Collection     string
	Replication    string
	DiskType       string
	Uid            uint32
	Gid            uint32
	Cipher         bool
	CacheDir       string
	CacheSizeMB    int64
	MaxMB          int
}

type WebDavServer struct {
	option         *WebDavOption
	grpcDialOption grpc.DialOption
	Handler        http.Handler
}

func max(x, y int64) int64 {
	if x <= y {
		return y
	}
	return x
}

func NewWebDavServer(option *WebDavOption) (ws *WebDavServer, err error) {

	fs, _ := NewWebDavFileSystem(option)

	// Fix no set filer.path , accessing "/" returns "//"
	if option.FilerRootPath == "/" {
		option.FilerRootPath = ""
	}
	// filer.path non "/" option means we are accessing filer's sub-folders
	if option.FilerRootPath != "" {
		fs = NewWrappedFs(fs, path.Clean(option.FilerRootPath))
	}

	ws = &WebDavServer{
		option:         option,
		grpcDialOption: security.LoadClientTLS(util.GetViper(), "grpc.filer"),
		Handler: listedEntriesHandler{
			next: copyMoveGuardHandler{
				fs: fs,
				next: &webdav.Handler{
					FileSystem: fs,
					LockSystem: webdav.NewMemLS(),
				},
			},
		},
	}

	return ws, nil
}

// putOutcomeKey carries the flag WebDavFileSystem.OpenFile sets when a PUT
// replaced an existing entry, so the PUT can answer 204 instead of 201
type putOutcomeKey struct{}

// putOutcomeWriter turns the 201 of a PUT that replaced a file into 204
// and swallows the status text webdav.Handler writes after it
type putOutcomeWriter struct {
	http.ResponseWriter
	replaced  *bool
	noContent bool
}

func (w *putOutcomeWriter) WriteHeader(code int) {
	if code == http.StatusCreated && *w.replaced {
		code = http.StatusNoContent
		w.noContent = true
	}
	w.ResponseWriter.WriteHeader(code)
}

func (w *putOutcomeWriter) Write(b []byte) (int, error) {
	if w.noContent {
		return len(b), nil
	}
	return w.ResponseWriter.Write(b)
}

// an overwriting MOVE or COPY removes the destination before reading the
// source, so a destination that contains the source removes it too; a
// destination under the source copies itself unless the copy is shallow
type copyMoveGuardHandler struct {
	fs   webdav.FileSystem
	next http.Handler
}

// deferredDeleteFS defers a destination's delete to the rename that follows
// it: x/net removes an existing MOVE destination before Rename, leaving it
// lost when the rename cannot complete. The filer's rename replaces the
// target in one transaction, so the delete is skipped here; a file vs.
// collection clash cannot merge in place and moves the target aside, which
// the refused rename then restores.
type deferredDeleteFS struct {
	webdav.FileSystem
	dst string
}

func (f deferredDeleteFS) RemoveAll(ctx context.Context, name string) error {
	if strings.TrimRight(name, "/") == strings.TrimRight(f.dst, "/") {
		return nil
	}
	return f.FileSystem.RemoveAll(ctx, name)
}

func (f deferredDeleteFS) Rename(ctx context.Context, oldName, newName string) error {
	// a file vs. collection clash cannot merge in place, and a collection
	// only replaces an empty one — those targets are moved aside rather
	// than deleted outright, as moveFiles would have done, so a refused
	// rename leaves the destination's contents to restore
	src, srcErr := f.FileSystem.Stat(ctx, oldName)
	dst, dstErr := f.FileSystem.Stat(ctx, newName)
	if srcErr == nil && dstErr == nil {
		clashing := src.IsDir() != dst.IsDir()
		if !clashing && dst.IsDir() {
			nonEmpty, err := nonEmptyDir(ctx, f.FileSystem, newName)
			if err != nil {
				return err
			}
			clashing = nonEmpty
		}
		if clashing {
			return renameOverTarget(ctx, f.FileSystem, oldName, newName)
		}
	}
	return f.FileSystem.Rename(ctx, oldName, newName)
}

// renameOverTarget parks a clashing rename target under a hidden sibling
// name so a refused rename can put it back; the parked entry is only
// removed once the move has landed.
func renameOverTarget(ctx context.Context, fs webdav.FileSystem, oldName, newName string) error {
	dir, base := path.Split(strings.TrimRight(newName, "/"))
	spare := fmt.Sprintf("%s.%s.webdav-moved-%x", dir, base, uint32(util.RandomInt32()))
	if err := fs.Rename(ctx, newName, spare); err != nil {
		return err
	}
	if err := fs.Rename(ctx, oldName, newName); err != nil {
		// a client disconnect cancels ctx mid-move; restoration gets its
		// own deadline, started after the move so its duration is not eaten
		restoreCtx, cancel := context.WithTimeout(context.WithoutCancel(ctx), 10*time.Minute)
		defer cancel()
		// newName may have been claimed while the target was parked; the
		// restore must refuse to replace it rather than clobber new data
		var backErr error
		if nrf, ok := fs.(interface {
			rename(context.Context, string, string, bool) error
		}); ok {
			backErr = nrf.rename(restoreCtx, spare, newName, true)
		} else {
			backErr = fs.Rename(restoreCtx, spare, newName)
		}
		if backErr != nil {
			glog.WarningfCtx(restoreCtx, "restore moved-aside %s to %s: %v", spare, newName, backErr)
		}
		return err
	}
	cleanupCtx, cancel := context.WithTimeout(context.WithoutCancel(ctx), 10*time.Minute)
	defer cancel()
	var removeErr error
	for attempt := 0; attempt < 3; attempt++ {
		if attempt > 0 {
			time.Sleep(2 * time.Second)
		}
		if removeErr = fs.RemoveAll(cleanupCtx, spare); removeErr == nil {
			return nil
		}
	}
	// the move is done, so it still reports success; the warning names the
	// parked sibling for recovery instead of leaving it hidden
	glog.WarningfCtx(cleanupCtx, "moved-aside %s remains parked after failed removes: %v", spare, removeErr)
	return nil
}

// nonEmptyDir reports whether a collection holds entries: the rename below
// replaces the target's own entry, which a non-empty collection refuses.
func nonEmptyDir(ctx context.Context, fs webdav.FileSystem, name string) (bool, error) {
	dir, err := fs.OpenFile(ctx, name, os.O_RDONLY, 0)
	if err != nil {
		return false, err
	}
	defer dir.Close()
	entries, err := dir.Readdir(1)
	if err == io.EOF {
		return false, nil
	}
	return len(entries) > 0, err
}

// moveHandler runs an overwriting MOVE onto an existing destination against
// deferredDeleteFS, so the target survives a refused or failed rename.
func (h copyMoveGuardHandler) moveHandler(r *http.Request) http.Handler {
	next, ok := h.next.(*webdav.Handler)
	if !ok || r.Header.Get("Overwrite") == "F" {
		return h.next
	}
	u, err := url.Parse(r.Header.Get("Destination"))
	if err != nil || u.Host != "" && u.Host != r.Host {
		return h.next
	}
	if _, err := h.fs.Stat(r.Context(), u.Path); err != nil {
		return h.next
	}
	inner := *next
	inner.FileSystem = deferredDeleteFS{FileSystem: inner.FileSystem, dst: u.Path}
	return &inner
}

func (h copyMoveGuardHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	// a PUT that replaces a file answers 204 (RFC 9110 9.3.4); webdav.Handler
	// always answers 201, so OpenFile reports a replace on the request
	// context and the writer rewrites the status it sends
	if r.Method == "PUT" {
		replaced := new(bool)
		w = &putOutcomeWriter{ResponseWriter: w, replaced: replaced}
		r = r.WithContext(context.WithValue(r.Context(), putOutcomeKey{}, replaced))
	}
	// RFC 4918 10.6: a missing Overwrite header means T, but webdav.Handler
	// only overwrites on MOVE when it is set (golang/go#66059)
	if r.Method == "MOVE" && len(r.Header.Values("Overwrite")) == 0 {
		r.Header.Set("Overwrite", "T")
	}
	next := h.next
	if r.Method == "MOVE" {
		next = h.moveHandler(r)
	}
	if r.Method == "MOVE" || r.Method == "COPY" {
		// a foreign-host Destination is another server's problem: the webdav
		// handler answers 502, so the local checks below do not apply
		if u, err := url.Parse(r.Header.Get("Destination")); err == nil && u.Host != "" && u.Host != r.Host {
			next.ServeHTTP(w, r)
			return
		}
		if u, err := url.Parse(r.Header.Get("Destination")); err == nil {
			src := strings.Trim(path.Clean(r.URL.Path), "/")
			dst := strings.Trim(path.Clean(u.Path), "/")
			above := dst == "" || src == dst || strings.HasPrefix(src, dst+"/")
			below := src == "" || strings.HasPrefix(dst, src+"/")
			if above || below && (r.Method == "MOVE" || r.Header.Get("Depth") != "0") {
				w.WriteHeader(http.StatusForbidden)
				return
			}
		}
		// a source that cannot be read makes the operation fail after the
		// destination is already gone — reject it before that
		fi, err := h.fs.Stat(r.Context(), r.URL.Path)
		if err != nil {
			if os.IsNotExist(err) {
				w.WriteHeader(http.StatusNotFound)
			} else {
				w.WriteHeader(http.StatusInternalServerError)
			}
			return
		}
		// a file copied onto a collection URL ("dir/") is created without the
		// slash; OpenFile refuses a file name ending in "/" only after the
		// overwritten collection has been removed
		if u, err := url.Parse(r.Header.Get("Destination")); err == nil && !fi.IsDir() && strings.HasSuffix(u.Path, "/") {
			if p := strings.TrimRight(u.Path, "/"); p != "" {
				u.Path = p
				u.RawPath = ""
				r.Header.Set("Destination", u.String())
			}
		}
		// the destination's parent collection must exist; Mkdir and Rename
		// errors surface as 403 below, not the 409 a missing parent requires
		if u, err := url.Parse(r.Header.Get("Destination")); err == nil {
			if dst := path.Clean(u.Path); strings.HasPrefix(dst, "/") && dst != "/" {
				if parent := path.Dir(dst); parent != "/" {
					if pfi, err := h.fs.Stat(r.Context(), parent); err != nil {
						if os.IsNotExist(err) {
							w.WriteHeader(http.StatusConflict)
						} else {
							w.WriteHeader(http.StatusInternalServerError)
						}
						return
					} else if !pfi.IsDir() {
						w.WriteHeader(http.StatusConflict)
						return
					}
				}
			}
		}
	}
	next.ServeHTTP(w, r)
}

// adapted from https://github.com/mattn/davfs/blob/master/plugin/mysql/mysql.go

type WebDavFileSystem struct {
	option      *WebDavOption
	chunkCache  *chunk_cache.TieredChunkCache
	readerCache *filer.ReaderCache
	filerClient *wdclient.FilerClient
	signature   int32
}

type FileInfo struct {
	name         string
	size         int64
	mode         os.FileMode
	modifiedTime time.Time
	etag         string
	isDirectory  bool
}

func (fi *FileInfo) Name() string       { return fi.name }
func (fi *FileInfo) Size() int64        { return fi.size }
func (fi *FileInfo) Mode() os.FileMode  { return fi.mode }
func (fi *FileInfo) ModTime() time.Time { return fi.modifiedTime }
func (fi *FileInfo) IsDir() bool        { return fi.isDirectory }
func (fi *FileInfo) Sys() interface{}   { return nil }

func (fi *FileInfo) ETag(ctx context.Context) (string, error) {
	if fi.etag == "" {
		// an empty DAV:getetag is not a valid entity-tag; let webdav derive one
		return "", webdav.ErrNotImplemented
	}
	return fi.etag, nil
}

type WebDavFile struct {
	fs               *WebDavFileSystem
	name             string
	isDirectory      bool
	off              int64
	entry            *filer_pb.Entry
	visibleIntervals *filer.IntervalList[*filer.VisibleInterval]
	reader           *filer.ChunkReadAt
	bufWriter        *buffered_writer.BufferedWriteCloser
	ctx              context.Context
}

func NewWebDavFileSystem(option *WebDavOption) (webdav.FileSystem, error) {

	cacheUniqueId := util.Md5String([]byte("webdav" + string(option.Filer) + version.Version()))[0:8]
	cacheDir := path.Join(option.CacheDir, cacheUniqueId)

	os.MkdirAll(cacheDir, os.FileMode(0755))
	chunkCache := chunk_cache.NewTieredChunkCache(256, cacheDir, option.CacheSizeMB, 1024*1024)
	t := &WebDavFileSystem{
		option:     option,
		chunkCache: chunkCache,
		signature:  util.RandomInt32(),
	}
	// FilerClient rather than filer.LookupFn: its cache is bounded, which the
	// LookupFn doc asks long-running processes to prefer, and it can invalidate
	// a volume's locations, so a read that failed against every cached location
	// looks the volume up again instead of retrying a server that has moved or
	// died.
	t.filerClient = wdclient.NewFilerClient([]pb.ServerAddress{option.Filer}, option.GrpcDialOption, "")
	t.readerCache = filer.NewReaderCache(32, chunkCache, t.filerClient.GetLookupFileIdFunction(), t.filerClient)
	return t, nil
}

var _ = filer_pb.FilerClient(&WebDavFileSystem{})

func (fs *WebDavFileSystem) WithFilerClient(streamingMode bool, fn func(filer_pb.SeaweedFilerClient) error) error {

	return pb.WithGrpcClient(context.Background(), streamingMode, fs.signature, func(grpcConnection *grpc.ClientConn) error {
		client := filer_pb.NewSeaweedFilerClient(grpcConnection)
		return fn(client)
	}, fs.option.Filer.ToGrpcAddress(), false, fs.option.GrpcDialOption)

}
func (fs *WebDavFileSystem) AdjustedUrl(location *filer_pb.Location) string {
	return location.Url
}
func (fs *WebDavFileSystem) GetDataCenter() string {
	return ""
}

func clearName(name string) (string, error) {
	slashed := strings.HasSuffix(name, "/")
	name = path.Clean(name)
	if !strings.HasSuffix(name, "/") && slashed {
		name += "/"
	}
	if !strings.HasPrefix(name, "/") {
		return "", os.ErrInvalid
	}
	return name, nil
}

func (fs *WebDavFileSystem) Mkdir(ctx context.Context, fullDirPath string, perm os.FileMode) error {

	glog.V(2).Infof("WebDavFileSystem.Mkdir %v", fullDirPath)

	if !strings.HasSuffix(fullDirPath, "/") {
		fullDirPath += "/"
	}

	var err error
	if fullDirPath, err = clearName(fullDirPath); err != nil {
		return err
	}

	_, err = fs.stat(ctx, fullDirPath)
	if err == nil {
		return os.ErrExist
	}
	if err != os.ErrNotExist {
		return err
	}

	dir, name := util.NormalizePath(fullDirPath).DirAndName()
	if err := fs.checkParentDir(ctx, dir); err != nil {
		return err
	}

	return fs.WithFilerClient(false, func(client filer_pb.SeaweedFilerClient) error {
		request := &filer_pb.CreateEntryRequest{
			Directory: dir,
			Entry: &filer_pb.Entry{
				Name:        name,
				IsDirectory: true,
				Attributes: &filer_pb.FuseAttributes{
					Mtime:    time.Now().Unix(),
					Crtime:   time.Now().Unix(),
					FileMode: uint32(perm | os.ModeDir),
					Uid:      fs.option.Uid,
					Gid:      fs.option.Gid,
				},
			},
			Signatures: []int32{fs.signature},
		}

		glog.V(1).Infof("mkdir: %v", request)
		if err := filer_pb.CreateEntry(context.Background(), client, request); err != nil {
			return fmt.Errorf("mkdir %s/%s: %v", dir, name, err)
		}

		return nil
	})
}

// checkParentDir returns os.ErrNotExist, which x/net/webdav answers with 409
// Conflict, when dir is missing or is not a folder: RFC 4918 9.3 and 9.7.1
// forbid creating the intermediate collections of a MKCOL or PUT.
func (fs *WebDavFileSystem) checkParentDir(ctx context.Context, dir string) error {
	if dir == "/" {
		return nil
	}
	fi, err := fs.stat(ctx, dir)
	if err != nil {
		return err
	}
	if !fi.IsDir() {
		return os.ErrNotExist
	}
	return nil
}

func (fs *WebDavFileSystem) OpenFile(ctx context.Context, fullFilePath string, flag int, perm os.FileMode) (webdav.File, error) {
	glog.V(2).Infof("WebDavFileSystem.OpenFile %v %x", fullFilePath, flag)

	var err error
	if fullFilePath, err = clearName(fullFilePath); err != nil {
		return nil, err
	}

	if flag&os.O_CREATE != 0 {
		// file should not have / suffix.
		if strings.HasSuffix(fullFilePath, "/") {
			return nil, os.ErrInvalid
		}
		dir, name := util.FullPath(fullFilePath).DirAndName()
		if err := fs.checkParentDir(ctx, dir); err != nil {
			return nil, err
		}

		var resp *filer_pb.CreateEntryResponse
		err = fs.WithFilerClient(false, func(client filer_pb.SeaweedFilerClient) error {
			var err error
			resp, err = filer_pb.CreateEntryWithResponse(context.Background(), client, &filer_pb.CreateEntryRequest{
				Directory: dir,
				Entry: &filer_pb.Entry{
					Name:        name,
					IsDirectory: perm&os.ModeDir > 0,
					Attributes: &filer_pb.FuseAttributes{
						Mtime:    0,
						Crtime:   time.Now().Unix(),
						FileMode: uint32(perm),
						Uid:      fs.option.Uid,
						Gid:      fs.option.Gid,
						TtlSec:   0,
					},
				},
				OExcl:      flag&os.O_EXCL != 0,
				Signatures: []int32{fs.signature},
			})
			return err
		})
		if err != nil {
			// a taken name — an exclusive create, or a file landing on a
			// directory — is the os.ErrExist x/net/webdav answers 405 for
			if errors.Is(err, filer_pb.ErrEntryAlreadyExists) || errors.Is(err, filer_pb.ErrExistingIsDirectory) {
				return nil, os.ErrExist
			}
			return nil, fmt.Errorf("create %s: %w", fullFilePath, err)
		}
		// the filer fills OldEntry under its path lock while writing, so the
		// outcome matches what the write did even against racing writers: a
		// PUT that landed on an entry answers 204, a fresh create answers 201
		if resp.GetMetadataEvent().GetEventNotification().GetOldEntry() != nil {
			if replaced, ok := ctx.Value(putOutcomeKey{}).(*bool); ok {
				*replaced = true
			}
		}
		return &WebDavFile{
			fs:          fs,
			name:        fullFilePath,
			isDirectory: false,
			bufWriter:   buffered_writer.NewBufferedWriteCloser(fs.option.MaxMB * 1024 * 1024),
			ctx:         ctx,
		}, nil
	}

	fi, err := fs.stat(ctx, fullFilePath)
	if err != nil {
		if err == os.ErrNotExist {
			return nil, err
		}
		return &WebDavFile{fs: fs, ctx: ctx}, nil
	}
	if !strings.HasSuffix(fullFilePath, "/") && fi.IsDir() {
		fullFilePath += "/"
	}

	return &WebDavFile{
		fs:          fs,
		name:        fullFilePath,
		isDirectory: false,
		bufWriter:   buffered_writer.NewBufferedWriteCloser(fs.option.MaxMB * 1024 * 1024),
		ctx:         ctx,
	}, nil

}

func (fs *WebDavFileSystem) removeAll(ctx context.Context, fullFilePath string, recursive bool) error {
	var err error
	if fullFilePath, err = clearName(fullFilePath); err != nil {
		return err
	}

	fullpath := util.NormalizePath(fullFilePath)
	if fullpath == "/" {
		return os.ErrInvalid
	}
	dir, name := fullpath.DirAndName()

	return filer_pb.Remove(ctx, fs, dir, name, true, recursive, false, false, []int32{fs.signature})

}

func (fs *WebDavFileSystem) RemoveAll(ctx context.Context, name string) error {

	glog.V(2).Infof("WebDavFileSystem.RemoveAll %v", name)

	return fs.removeAll(ctx, name, true)
}

func (fs *WebDavFileSystem) Rename(ctx context.Context, oldName, newName string) error {
	return fs.rename(ctx, oldName, newName, false)
}

func (fs *WebDavFileSystem) rename(ctx context.Context, oldName, newName string, failIfExists bool) error {

	glog.V(2).Infof("WebDavFileSystem.Rename %v to %v", oldName, newName)

	var err error
	if oldName, err = clearName(oldName); err != nil {
		return err
	}
	if newName, err = clearName(newName); err != nil {
		return err
	}

	if _, err = fs.stat(ctx, oldName); err != nil {
		return err
	}
	oldName = string(util.NormalizePath(oldName))
	newName = string(util.NormalizePath(newName))
	if oldName == "/" || newName == "/" {
		return os.ErrInvalid
	}

	// an existing target is replaced inside the rename's transaction; a
	// failed lookup aborts the move here
	if _, err = fs.stat(ctx, newName); err != nil && err != os.ErrNotExist {
		return err
	}

	oldDir, oldBaseName := util.FullPath(oldName).DirAndName()
	newDir, newBaseName := util.FullPath(newName).DirAndName()

	if err := fs.checkParentDir(ctx, newDir); err != nil {
		return err
	}

	return fs.WithFilerClient(false, func(client filer_pb.SeaweedFilerClient) error {

		request := &filer_pb.AtomicRenameEntryRequest{
			OldDirectory:       oldDir,
			OldName:            oldBaseName,
			NewDirectory:       newDir,
			NewName:            newBaseName,
			FailIfTargetExists: failIfExists,
		}

		_, err := client.AtomicRenameEntry(ctx, request)
		if err != nil {
			return fmt.Errorf("renaming %s/%s => %s/%s: %v", oldDir, oldBaseName, newDir, newBaseName, err)
		}

		return nil

	})
}

func (fs *WebDavFileSystem) stat(ctx context.Context, fullFilePath string) (os.FileInfo, error) {
	var err error
	if fullFilePath, err = clearName(fullFilePath); err != nil {
		return nil, err
	}

	fullpath := util.FullPath(fullFilePath)

	if listedFi := listedEntriesFrom(ctx).get(string(fullpath)); listedFi != nil {
		return listedFi, nil
	}

	entry, _, _, err := filer_pb.GetEntry(ctx, fs, fullpath)
	if err != nil {
		if err == filer_pb.ErrNotFound {
			return nil, os.ErrNotExist
		}
		return nil, err
	}
	if entry == nil {
		return nil, os.ErrNotExist
	}

	return toFileInfo(fullpath, entry), nil
}

func toFileInfo(fullpath util.FullPath, entry *filer_pb.Entry) *FileInfo {
	// Name is what WebDAV publishes as DAV:displayname; clients that build a
	// child URL from it reach nothing when it carries the whole path.
	fp := util.FullPath(listedEntryKey(string(fullpath)))
	fi := &FileInfo{
		size:         int64(filer.FileSize(entry)),
		name:         fp.Name(),
		mode:         os.FileMode(entry.Attributes.FileMode),
		modifiedTime: time.Unix(entry.Attributes.Mtime, 0),
		etag:         filer.ETag(entry),
		isDirectory:  entry.IsDirectory,
	}

	if fp == "/" {
		fi.modifiedTime = time.Now()
		fi.isDirectory = true
	}
	return fi
}

func (fs *WebDavFileSystem) Stat(ctx context.Context, name string) (os.FileInfo, error) {
	glog.V(2).Infof("WebDavFileSystem.Stat %v", name)

	return fs.stat(ctx, name)
}

func (f *WebDavFile) saveDataAsChunk(reader io.Reader, name string, offset int64, tsNs int64, _ uint64) (chunk *filer_pb.FileChunk, err error) {
	// Delegate to the shared filer-gateway helper so WebDAV, NFS, and
	// any future filer-backed protocols go through one implementation of
	// AssignVolume + volume-server upload.
	chunk, err = filer.SaveGatewayDataAsChunk(filer.GatewayChunkUploadRequest{
		FilerClient: f.fs,
		Reader:      reader,
		FullPath:    name,
		Filename:    f.name,
		Offset:      offset,
		TsNs:        tsNs,
		Collection:  f.fs.option.Collection,
		Replication: f.fs.option.Replication,
		DiskType:    f.fs.option.DiskType,
		Cipher:      f.fs.option.Cipher,
	})
	if err != nil {
		glog.V(0).Infof("upload data %v: %v", f.name, err)
		return nil, err
	}
	return chunk, nil
}

func (f *WebDavFile) Write(buf []byte) (int, error) {

	glog.V(2).Infof("WebDavFileSystem.Write %v", f.name)

	fullPath := util.FullPath(f.name)
	dir, _ := fullPath.DirAndName()

	var getErr error
	ctx := context.Background()
	if f.entry == nil {
		f.entry, _, _, getErr = filer_pb.GetEntry(context.Background(), f.fs, fullPath)
	}

	if f.entry == nil {
		return 0, getErr
	}
	if getErr != nil {
		return 0, getErr
	}

	if f.bufWriter.FlushFunc == nil {
		f.bufWriter.FlushFunc = func(data []byte, offset int64) (flushErr error) {

			var chunk *filer_pb.FileChunk
			chunk, flushErr = f.saveDataAsChunk(util.NewBytesReader(data), f.name, offset, time.Now().UnixNano(), uint64(len(data)))

			if flushErr != nil {
				if f.entry.Attributes.Mtime == 0 {
					if err := f.fs.removeAll(ctx, f.name, false); err != nil {
						glog.Errorf("bufWriter.Flush remove file error: %+v", f.name)
					}
				}
				return fmt.Errorf("%s upload result: %v", f.name, flushErr)
			}

			f.entry.Content = nil
			f.entry.Chunks = append(f.entry.GetChunks(), chunk)

			return flushErr
		}
		f.bufWriter.CloseFunc = func() error {

			// no chunk deleter here: a failed fold reports the blobs it saved
			manifestedChunks, manifestErr := filer.MaybeManifestize(f.saveDataAsChunk, nil, f.entry.GetChunks())
			if manifestErr != nil {
				// not good, but should be ok
				glog.V(0).Infof("file %s close MaybeManifestize: %v", f.name, manifestErr)
			} else {
				f.entry.Chunks = manifestedChunks
			}

			flushErr := f.fs.WithFilerClient(false, func(client filer_pb.SeaweedFilerClient) error {
				f.entry.Attributes.Mtime = time.Now().Unix()

				request := &filer_pb.UpdateEntryRequest{
					Directory:  dir,
					Entry:      f.entry,
					Signatures: []int32{f.fs.signature},
				}

				if _, err := client.UpdateEntry(ctx, request); err != nil {
					return fmt.Errorf("update %s: %v", f.name, err)
				}

				return nil
			})
			return flushErr
		}
	}

	written, err := f.bufWriter.Write(buf)

	if err == nil {
		f.entry.Attributes.FileSize = uint64(max(f.off+int64(written), int64(f.entry.Attributes.FileSize)))
		glog.V(3).Infof("WebDavFileSystem.Write %v: written [%d,%d)", f.name, f.off, f.off+int64(len(buf)))
		f.off += int64(written)
	}

	return written, err
}

func (f *WebDavFile) Close() error {

	glog.V(2).Infof("WebDavFileSystem.Close %v", f.name)
	if f.reader != nil {
		f.reader.ReleaseStream()
	}
	if f.bufWriter == nil {
		return nil
	}
	err := f.bufWriter.Close()

	if f.entry != nil {
		f.entry = nil
		f.visibleIntervals = nil
	}

	return err
}

func (f *WebDavFile) Read(p []byte) (readSize int, err error) {

	glog.V(2).Infof("WebDavFileSystem.Read %v", f.name)

	if f.entry == nil {
		f.entry, _, _, err = filer_pb.GetEntry(context.Background(), f.fs, util.FullPath(f.name))
	}
	if f.entry == nil {
		return 0, err
	}
	if err != nil {
		return 0, err
	}
	fileSize := int64(filer.FileSize(f.entry))
	if fileSize == 0 {
		return 0, io.EOF
	}
	if len(f.entry.Content) > 0 {
		if f.off >= int64(len(f.entry.Content)) {
			return 0, io.EOF
		}
		readSize = copy(p, f.entry.Content[f.off:])
		f.off += int64(readSize)
		return readSize, nil
	}
	if f.visibleIntervals == nil {
		f.visibleIntervals, err = filer.NonOverlappingVisibleIntervals(f.ctx, f.fs.filerClient.GetLookupFileIdFunction(), f.entry.GetChunks(), 0, fileSize)
		if err != nil {
			return 0, err
		}
		f.reader = nil
	}
	if f.reader == nil {
		chunkViews := filer.ViewFromVisibleIntervals(f.visibleIntervals, 0, fileSize)
		f.reader = filer.NewChunkReaderAtFromClient(f.ctx, f.fs.readerCache, chunkViews, fileSize, filer.DefaultPrefetchCount)
	}

	readSize, err = f.reader.ReadAt(p, f.off)

	glog.V(3).Infof("WebDavFileSystem.Read %v: [%d,%d)", f.name, f.off, f.off+int64(readSize))
	f.off += int64(readSize)

	if err != nil && err != io.EOF {
		glog.Errorf("file read %s: %v", f.name, err)
	}

	return

}

func (f *WebDavFile) Readdir(count int) (ret []os.FileInfo, err error) {

	glog.V(2).Infof("WebDavFileSystem.Readdir %v count %d", f.name, count)

	dir, _ := util.FullPath(f.name).DirAndName()

	ctx := f.requestContext()
	listed := listedEntriesFrom(ctx)

	err = filer_pb.ReadDirAllEntries(ctx, f.fs, util.FullPath(dir), "", func(entry *filer_pb.Entry, isLast bool) error {
		childPath := util.NewFullPath(dir, entry.Name)
		fi := toFileInfo(childPath, entry)

		glog.V(4).Infof("entry: %v", fi.name)

		listed.put(string(childPath), fi)

		ret = append(ret, fi)
		return nil
	})
	if err != nil {
		return nil, err
	}

	old := f.off
	if old >= int64(len(ret)) {
		if count > 0 {
			return nil, io.EOF
		}
		return nil, nil
	}
	if count > 0 {
		f.off += int64(count)
		if f.off > int64(len(ret)) {
			f.off = int64(len(ret))
		}
	} else {
		f.off = int64(len(ret))
		old = 0
	}

	return ret[old:f.off], nil
}

func (f *WebDavFile) Seek(offset int64, whence int) (int64, error) {

	glog.V(2).Infof("WebDavFile.Seek %v %v %v", f.name, offset, whence)

	ctx := f.requestContext()

	var err error
	switch whence {
	case io.SeekStart:
		f.off = 0
	case io.SeekEnd:
		if fi, err := f.fs.stat(ctx, f.name); err != nil {
			return 0, err
		} else {
			f.off = fi.Size()
		}
	}
	f.off += offset
	return f.off, err
}

func (f *WebDavFile) Stat() (os.FileInfo, error) {

	glog.V(2).Infof("WebDavFile.Stat %v", f.name)

	return f.fs.stat(f.requestContext(), f.name)
}

// the context of the request that opened the file, or a bare one for files
// opened outside a request
func (f *WebDavFile) requestContext() context.Context {
	if f.ctx != nil {
		return f.ctx
	}
	return context.Background()
}