From 68e00dcc4e741e0591f4754ef4017f518d226a42 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?J=C3=B6rn=20Friedrich=20Dreyer?= Date: Wed, 21 Aug 2024 16:03:56 +0200 Subject: [PATCH] allow listing directory trash items by key MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Jörn Friedrich Dreyer --- .../unreleased/trash-listing-bykey-fixes.md | 9 ++ .../storageprovider/storageprovider.go | 31 +++++-- .../http/services/owncloud/ocdav/spaces.go | 25 ++++-- .../http/services/owncloud/ocdav/trashbin.go | 32 ++++--- pkg/storage/utils/decomposedfs/recycle.go | 84 ++++++++++++++----- .../utils/decomposedfs/recycle_test.go | 20 ++--- 6 files changed, 135 insertions(+), 66 deletions(-) create mode 100644 changelog/unreleased/trash-listing-bykey-fixes.md diff --git a/changelog/unreleased/trash-listing-bykey-fixes.md b/changelog/unreleased/trash-listing-bykey-fixes.md new file mode 100644 index 0000000000..dd649013af --- /dev/null +++ b/changelog/unreleased/trash-listing-bykey-fixes.md @@ -0,0 +1,9 @@ +Bugfix: Allow listing directory trash items by key + +The storageprovider now passes on the key without inventing a `/` as the relative path when it was not present at the end of the key. This allows differentiating requests that want to get the trash item of a folder itself (where the relative path is empty) or listing the children of a folder in the trash (where the relative path at least starts with a `/`). + +We also fixed the `/dav/spaces` endpoint to not invent a `/` at the end of URLs to allow clients to actually make these different requests. + +As a byproduct we now return the size of trashed items. + +https://github.com/cs3org/reva/pull/4818 diff --git a/internal/grpc/services/storageprovider/storageprovider.go b/internal/grpc/services/storageprovider/storageprovider.go index 763148e8e7..3637980c0a 100644 --- a/internal/grpc/services/storageprovider/storageprovider.go +++ b/internal/grpc/services/storageprovider/storageprovider.go @@ -27,6 +27,7 @@ import ( "path" "sort" "strconv" + "strings" "time" rpc "github.com/cs3org/go-cs3apis/cs3/rpc/v1beta1" @@ -880,8 +881,11 @@ func (s *Service) ListRecycleStream(req *provider.ListRecycleStreamRequest, ss p ctx := ss.Context() log := appctx.GetLogger(ctx) - key, itemPath := router.ShiftPath(req.Key) - items, err := s.Storage.ListRecycle(ctx, req.Ref, key, itemPath) + // if no slash is present in the key, do not pass a relative path to the storage + // when a path is passed to the storage, it will list the contents of the directory + key, relativePath := splitKeyAndPath(req.GetKey()) + items, err := s.Storage.ListRecycle(ctx, req.Ref, key, relativePath) + if err != nil { var st *rpc.Status switch err.(type) { @@ -924,8 +928,10 @@ func (s *Service) ListRecycleStream(req *provider.ListRecycleStreamRequest, ss p } func (s *Service) ListRecycle(ctx context.Context, req *provider.ListRecycleRequest) (*provider.ListRecycleResponse, error) { - key, itemPath := router.ShiftPath(req.Key) - items, err := s.Storage.ListRecycle(ctx, req.Ref, key, itemPath) + // if no slash is present in the key, do not pass a relative path to the storage + // when a path is passed to the storage, it will list the contents of the directory + key, relativePath := splitKeyAndPath(req.GetKey()) + items, err := s.Storage.ListRecycle(ctx, req.Ref, key, relativePath) if err != nil { var st *rpc.Status switch err.(type) { @@ -962,8 +968,8 @@ func (s *Service) RestoreRecycleItem(ctx context.Context, req *provider.RestoreR ctx = ctxpkg.ContextSetLockID(ctx, req.LockId) // TODO(labkode): CRITICAL: fill recycle info with storage provider. - key, itemPath := router.ShiftPath(req.Key) - err := s.Storage.RestoreRecycleItem(ctx, req.Ref, key, itemPath, req.RestoreRef) + key, relativePath := splitKeyAndPath(req.GetKey()) + err := s.Storage.RestoreRecycleItem(ctx, req.Ref, key, relativePath, req.RestoreRef) res := &provider.RestoreRecycleItemResponse{ Status: status.NewStatusFromErrType(ctx, "restore recycle item", err), @@ -980,9 +986,9 @@ func (s *Service) PurgeRecycle(ctx context.Context, req *provider.PurgeRecycleRe } // if a key was sent as opaque id purge only that item - key, itemPath := router.ShiftPath(req.Key) + key, relativePath := splitKeyAndPath(req.GetKey()) if key != "" { - if err := s.Storage.PurgeRecycleItem(ctx, req.Ref, key, itemPath); err != nil { + if err := s.Storage.PurgeRecycleItem(ctx, req.Ref, key, relativePath); err != nil { st := status.NewStatusFromErrType(ctx, "error purging recycle item", err) appctx.GetLogger(ctx). Error(). @@ -1313,3 +1319,12 @@ func canLockPublicShare(ctx context.Context) bool { psr := utils.ReadPlainFromOpaque(u.Opaque, "public-share-role") return psr == "" || psr == conversions.RoleEditor } + +// splitKeyAndPath splits a key into a root and a relative path +func splitKeyAndPath(key string) (string, string) { + root, relativePath := router.ShiftPath(key) + if relativePath == "/" && !strings.HasSuffix(key, "/") { + relativePath = "" + } + return root, relativePath +} diff --git a/internal/http/services/owncloud/ocdav/spaces.go b/internal/http/services/owncloud/ocdav/spaces.go index 37797d60ad..2439a98251 100644 --- a/internal/http/services/owncloud/ocdav/spaces.go +++ b/internal/http/services/owncloud/ocdav/spaces.go @@ -21,6 +21,7 @@ package ocdav import ( "net/http" "path" + "strings" provider "github.com/cs3org/go-cs3apis/cs3/storage/provider/v1beta1" "github.com/cs3org/reva/v2/internal/http/services/owncloud/ocdav/config" @@ -132,8 +133,7 @@ func (h *SpacesHandler) handleSpacesTrashbin(w http.ResponseWriter, r *http.Requ ctx := r.Context() log := appctx.GetLogger(ctx) - var spaceID string - spaceID, r.URL.Path = router.ShiftPath(r.URL.Path) + spaceID, key := splitSpaceAndKey(r.URL.Path) if spaceID == "" { // listing is disabled, no auth will change that w.WriteHeader(http.StatusMethodNotAllowed) @@ -146,12 +146,9 @@ func (h *SpacesHandler) handleSpacesTrashbin(w http.ResponseWriter, r *http.Requ return } - var key string - key, r.URL.Path = router.ShiftPath(r.URL.Path) - switch r.Method { case MethodPropfind: - trashbinHandler.listTrashbin(w, r, s, &ref, path.Join(_trashbinPath, spaceID), key, r.URL.Path) + trashbinHandler.listTrashbin(w, r, s, &ref, path.Join(_trashbinPath, spaceID), key) case MethodMove: if key == "" { http.Error(w, "501 Not implemented", http.StatusNotImplemented) @@ -167,15 +164,25 @@ func (h *SpacesHandler) handleSpacesTrashbin(w http.ResponseWriter, r *http.Requ w.WriteHeader(http.StatusBadRequest) return } - log.Debug().Str("key", key).Str("path", r.URL.Path).Str("dst", dst).Msg("spaces restore") + log.Debug().Str("key", key).Str("dst", dst).Msg("spaces restore") dstRef := proto.Clone(&ref).(*provider.Reference) dstRef.Path = utils.MakeRelativePath(dst) - trashbinHandler.restore(w, r, s, &ref, dstRef, key, r.URL.Path) + trashbinHandler.restore(w, r, s, &ref, dstRef, key) case http.MethodDelete: - trashbinHandler.delete(w, r, s, &ref, key, r.URL.Path) + trashbinHandler.delete(w, r, s, &ref, key) default: http.Error(w, "501 Not implemented", http.StatusNotImplemented) } } + +func splitSpaceAndKey(p string) (space, key string) { + p = strings.TrimPrefix(p, "/") + parts := strings.SplitN(p, "/", 2) + space = parts[0] + if len(parts) > 1 { + key = parts[1] + } + return +} diff --git a/internal/http/services/owncloud/ocdav/trashbin.go b/internal/http/services/owncloud/ocdav/trashbin.go index ef742c54df..a1f32fb89a 100644 --- a/internal/http/services/owncloud/ocdav/trashbin.go +++ b/internal/http/services/owncloud/ocdav/trashbin.go @@ -131,13 +131,12 @@ func (h *TrashbinHandler) Handler(s *svc) http.Handler { } ref := spacelookup.MakeRelativeReference(space, ".", false) - // key will be a base64 encoded cs3 path, it uniquely identifies a trash item & storage - var key string - key, r.URL.Path = router.ShiftPath(r.URL.Path) + // key will be a base64 encoded cs3 path, it uniquely identifies a trash item with an opaque id and an optional path + key := r.URL.Path switch r.Method { case MethodPropfind: - h.listTrashbin(w, r, s, ref, user.Username, key, r.URL.Path) + h.listTrashbin(w, r, s, ref, user.Username, key) case MethodMove: if key == "" { http.Error(w, "501 Not implemented", http.StatusNotImplemented) @@ -172,16 +171,16 @@ func (h *TrashbinHandler) Handler(s *svc) http.Handler { dstRef := spacelookup.MakeRelativeReference(space, p, false) log.Debug().Str("key", key).Str("dst", dst).Msg("restore") - h.restore(w, r, s, ref, dstRef, key, r.URL.Path) + h.restore(w, r, s, ref, dstRef, key) case http.MethodDelete: - h.delete(w, r, s, ref, key, r.URL.Path) + h.delete(w, r, s, ref, key) default: http.Error(w, "501 Not implemented", http.StatusNotImplemented) } }) } -func (h *TrashbinHandler) listTrashbin(w http.ResponseWriter, r *http.Request, s *svc, ref *provider.Reference, refBase, key, itemPath string) { +func (h *TrashbinHandler) listTrashbin(w http.ResponseWriter, r *http.Request, s *svc, ref *provider.Reference, refBase, key string) { ctx, span := appctx.GetTracerProvider(r.Context()).Tracer(tracerName).Start(r.Context(), "list_trashbin") defer span.End() @@ -214,7 +213,7 @@ func (h *TrashbinHandler) listTrashbin(w http.ResponseWriter, r *http.Request, s } if depth == net.DepthZero { - rootHref := path.Join(refBase, key, itemPath) + rootHref := path.Join(refBase, key) propRes, err := h.formatTrashPropfind(ctx, s, ref.ResourceId.SpaceId, refBase, rootHref, nil, nil) if err != nil { sublog.Error().Err(err).Msg("error formatting propfind") @@ -246,7 +245,7 @@ func (h *TrashbinHandler) listTrashbin(w http.ResponseWriter, r *http.Request, s return } // ask gateway for recycle items - getRecycleRes, err := client.ListRecycle(ctx, &provider.ListRecycleRequest{Ref: ref, Key: path.Join(key, itemPath)}) + getRecycleRes, err := client.ListRecycle(ctx, &provider.ListRecycleRequest{Ref: ref, Key: key}) if err != nil { sublog.Error().Err(err).Msg("error calling ListRecycle") w.WriteHeader(http.StatusInternalServerError) @@ -304,7 +303,7 @@ func (h *TrashbinHandler) listTrashbin(w http.ResponseWriter, r *http.Request, s } } - rootHref := path.Join(refBase, key, itemPath) + rootHref := path.Join(refBase, key) propRes, err := h.formatTrashPropfind(ctx, s, ref.ResourceId.SpaceId, refBase, rootHref, &pf, items) if err != nil { sublog.Error().Err(err).Msg("error formatting propfind") @@ -480,7 +479,7 @@ func (h *TrashbinHandler) itemToPropResponse(ctx context.Context, s *svc, spaceI return &response, nil } -func (h *TrashbinHandler) restore(w http.ResponseWriter, r *http.Request, s *svc, ref, dst *provider.Reference, key, itemPath string) { +func (h *TrashbinHandler) restore(w http.ResponseWriter, r *http.Request, s *svc, ref, dst *provider.Reference, key string) { ctx, span := appctx.GetTracerProvider(r.Context()).Tracer(tracerName).Start(r.Context(), "restore") defer span.End() @@ -566,7 +565,7 @@ func (h *TrashbinHandler) restore(w http.ResponseWriter, r *http.Request, s *svc req := &provider.RestoreRecycleItemRequest{ Ref: ref, - Key: path.Join(key, itemPath), + Key: key, RestoreRef: dst, } @@ -608,16 +607,15 @@ func (h *TrashbinHandler) restore(w http.ResponseWriter, r *http.Request, s *svc } // delete has only a key -func (h *TrashbinHandler) delete(w http.ResponseWriter, r *http.Request, s *svc, ref *provider.Reference, key, itemPath string) { +func (h *TrashbinHandler) delete(w http.ResponseWriter, r *http.Request, s *svc, ref *provider.Reference, key string) { ctx, span := appctx.GetTracerProvider(r.Context()).Tracer(tracerName).Start(r.Context(), "erase") defer span.End() - sublog := appctx.GetLogger(ctx).With().Interface("reference", ref).Str("key", key).Str("item_path", itemPath).Logger() + sublog := appctx.GetLogger(ctx).With().Interface("reference", ref).Str("key", key).Logger() - trashPath := path.Join(key, itemPath) req := &provider.PurgeRecycleRequest{ Ref: ref, - Key: trashPath, + Key: key, } client, err := s.gatewaySelector.Next() @@ -638,7 +636,7 @@ func (h *TrashbinHandler) delete(w http.ResponseWriter, r *http.Request, s *svc, case rpc.Code_CODE_NOT_FOUND: sublog.Debug().Interface("status", res.Status).Msg("resource not found") w.WriteHeader(http.StatusConflict) - m := fmt.Sprintf("path %s not found", trashPath) + m := fmt.Sprintf("key %s not found", key) b, err := errors.Marshal(http.StatusConflict, m, "", "") errors.HandleWebdavError(&sublog, w, b, err) case rpc.Code_CODE_PERMISSION_DENIED: diff --git a/pkg/storage/utils/decomposedfs/recycle.go b/pkg/storage/utils/decomposedfs/recycle.go index aa0ead067b..00bd13ced6 100644 --- a/pkg/storage/utils/decomposedfs/recycle.go +++ b/pkg/storage/utils/decomposedfs/recycle.go @@ -20,10 +20,10 @@ package decomposedfs import ( "context" + "fmt" iofs "io/fs" "os" "path/filepath" - "strconv" "strings" "time" @@ -55,6 +55,9 @@ func (fs *Decomposedfs) ListRecycle(ctx context.Context, ref *provider.Reference if ref == nil || ref.ResourceId == nil || ref.ResourceId.OpaqueId == "" { return nil, errtypes.BadRequest("spaceid required") } + if key == "" && relativePath != "" { + return nil, errtypes.BadRequest("key is required when navigating with a path") + } spaceID := ref.ResourceId.OpaqueId sublog := appctx.GetLogger(ctx).With().Str("spaceid", spaceID).Str("key", key).Str("relative_path", relativePath).Logger() @@ -75,7 +78,7 @@ func (fs *Decomposedfs) ListRecycle(ctx context.Context, ref *provider.Reference return nil, errtypes.NotFound(key) } - if key == "" && relativePath == "/" { + if key == "" && relativePath == "" { return fs.listTrashRoot(ctx, spaceID) } @@ -113,16 +116,25 @@ func (fs *Decomposedfs) ListRecycle(ctx context.Context, ref *provider.Reference sublog.Error().Err(err).Msg("could not parse time format, ignoring") } - nodeType := fs.lu.TypeFromPath(ctx, originalPath) - if nodeType != provider.ResourceType_RESOURCE_TYPE_CONTAINER { + var size int64 + if relativePath == "" { // this is the case when we want to directly list a file in the trashbin - blobsize, err := strconv.ParseInt(string(attrs[prefixes.BlobsizeAttr]), 10, 64) - if err != nil { - return items, err + nodeType := fs.lu.TypeFromPath(ctx, originalPath) + switch nodeType { + case provider.ResourceType_RESOURCE_TYPE_FILE: + size, err = fs.lu.ReadBlobSizeAttr(ctx, originalPath) + if err != nil { + return items, err + } + case provider.ResourceType_RESOURCE_TYPE_CONTAINER: + size, err = fs.lu.MetadataBackend().GetInt64(ctx, originalPath, prefixes.TreesizeAttr) + if err != nil { + return items, err + } } item := &provider.RecycleItem{ - Type: nodeType, - Size: uint64(blobsize), + Type: fs.lu.TypeFromPath(ctx, originalPath), + Size: uint64(size), Key: filepath.Join(key, relativePath), DeletionTime: deletionTime, Ref: &provider.Reference{ @@ -134,9 +146,6 @@ func (fs *Decomposedfs) ListRecycle(ctx context.Context, ref *provider.Reference } // we have to read the names and stat the path to follow the symlinks - if err != nil { - return nil, err - } childrenPath := filepath.Join(originalPath, relativePath) childrenDir, err := os.Open(childrenPath) if err != nil { @@ -154,9 +163,10 @@ func (fs *Decomposedfs) ListRecycle(ctx context.Context, ref *provider.Reference continue } - size := int64(0) + // reset size + size = 0 - nodeType = fs.lu.TypeFromPath(ctx, resolvedChildPath) + nodeType := fs.lu.TypeFromPath(ctx, resolvedChildPath) switch nodeType { case provider.ResourceType_RESOURCE_TYPE_FILE: size, err = fs.lu.ReadBlobSizeAttr(ctx, resolvedChildPath) @@ -165,12 +175,7 @@ func (fs *Decomposedfs) ListRecycle(ctx context.Context, ref *provider.Reference continue } case provider.ResourceType_RESOURCE_TYPE_CONTAINER: - attr, err := fs.lu.MetadataBackend().Get(ctx, resolvedChildPath, prefixes.TreesizeAttr) - if err != nil { - sublog.Error().Err(err).Str("name", name).Msg("invalid tree size, skipping") - continue - } - size, err = strconv.ParseInt(string(attr), 10, 64) + size, err = fs.lu.MetadataBackend().GetInt64(ctx, resolvedChildPath, prefixes.TreesizeAttr) if err != nil { sublog.Error().Err(err).Str("name", name).Msg("invalid tree size, skipping") continue @@ -196,14 +201,24 @@ func (fs *Decomposedfs) ListRecycle(ctx context.Context, ref *provider.Reference // readTrashLink returns path, nodeID and timestamp func readTrashLink(path string) (string, string, string, error) { + start := time.Now() + defer func() { + delta := time.Since(start) + fmt.Println(" readTrashLink", delta, "path", path) + }() link, err := os.Readlink(path) if err != nil { return "", "", "", err } + delta := time.Since(start) + fmt.Println(" readTrashLink Readlink", delta, "path", path) + start = time.Now() resolved, err := filepath.EvalSymlinks(path) if err != nil { return "", "", "", err } + delta = time.Since(start) + fmt.Println(" readTrashLink EvalSymlinks", delta, "path", path) // ../../../../../nodes/e5/6c/75/a8/-d235-4cbb-8b4e-48b6fd0f2094.T.2022-02-16T14:38:11.769917408Z // TODO use filepath.Separator to support windows link = strings.ReplaceAll(link, "/", "") @@ -217,11 +232,18 @@ func readTrashLink(path string) (string, string, string, error) { func (fs *Decomposedfs) listTrashRoot(ctx context.Context, spaceID string) ([]*provider.RecycleItem, error) { log := appctx.GetLogger(ctx) trashRoot := fs.getRecycleRoot(spaceID) - + items := []*provider.RecycleItem{} + start := time.Now() + defer func() { + delta := time.Since(start) + fmt.Println("listTrashRoot delta", delta, "trashRoot", trashRoot, "items", len(items)) + }() subTrees, err := filepath.Glob(trashRoot + "/*") if err != nil { return nil, err } + delta := time.Since(start) + fmt.Println("listTrashRoot glob", delta, "trashRoot", trashRoot, "subTrees", len(subTrees)) numWorkers := fs.o.MaxConcurrency if len(subTrees) < numWorkers { @@ -250,35 +272,49 @@ func (fs *Decomposedfs) listTrashRoot(ctx context.Context, spaceID string) ([]*p for i := 0; i < numWorkers; i++ { g.Go(func() error { for subTree := range work { + subtreeStart := time.Now() matches, err := filepath.Glob(subTree + "/*/*/*/*") if err != nil { return err } + delta := time.Since(subtreeStart) + fmt.Println(" subtree glob", delta, "nodePath", subTree) for _, itemPath := range matches { + matchDelta := time.Now() + // TODO can we encode this in the path instead of reading the link? nodePath, nodeID, timeSuffix, err := readTrashLink(itemPath) if err != nil { log.Error().Err(err).Str("trashRoot", trashRoot).Str("item", itemPath).Msg("error reading trash link, skipping") continue } + statDelta := time.Now() md, err := os.Stat(nodePath) if err != nil { log.Error().Err(err).Str("trashRoot", trashRoot).Str("item", itemPath).Str("node_path", nodePath).Msg("could not stat trash item, skipping") continue } + delta := time.Since(statDelta) + fmt.Println(" match stat", delta, "nodePath", nodePath) + attrsDelta := time.Now() attrs, err := fs.lu.MetadataBackend().All(ctx, nodePath) if err != nil { log.Error().Err(err).Str("trashRoot", trashRoot).Str("item", itemPath).Str("node_path", nodePath).Msg("could not get extended attributes, skipping") continue } + delta = time.Since(attrsDelta) + fmt.Println(" match metadata", delta, "nodePath", nodePath) + typeDelta := time.Now() nodeType := fs.lu.TypeFromPath(ctx, nodePath) if nodeType == provider.ResourceType_RESOURCE_TYPE_INVALID { log.Error().Err(err).Str("trashRoot", trashRoot).Str("item", itemPath).Str("node_path", nodePath).Msg("invalid node type, skipping") continue } + delta = time.Since(typeDelta) + fmt.Println(" match type", delta, "nodePath", nodePath) item := &provider.RecycleItem{ Type: nodeType, @@ -300,12 +336,17 @@ func (fs *Decomposedfs) listTrashRoot(ctx context.Context, spaceID string) ([]*p } else { log.Error().Str("trashRoot", trashRoot).Str("item", itemPath).Str("spaceid", spaceID).Str("nodeid", nodeID).Str("dtime", timeSuffix).Msg("could not read origin path") } + + delta = time.Since(matchDelta) + fmt.Println(" match delta", delta, "item", itemPath) select { case results <- item: case <-ctx.Done(): return ctx.Err() } } + delta = time.Since(subtreeStart) + fmt.Println(" subtree delta", delta, "nodePath", subTree, "matches", len(matches)) } return nil }) @@ -318,7 +359,6 @@ func (fs *Decomposedfs) listTrashRoot(ctx context.Context, spaceID string) ([]*p }() // Collect results - items := []*provider.RecycleItem{} for ri := range results { items = append(items, ri) } diff --git a/pkg/storage/utils/decomposedfs/recycle_test.go b/pkg/storage/utils/decomposedfs/recycle_test.go index 5cfe9ec5e7..f10fcc4bab 100644 --- a/pkg/storage/utils/decomposedfs/recycle_test.go +++ b/pkg/storage/utils/decomposedfs/recycle_test.go @@ -340,7 +340,7 @@ var _ = Describe("Recycle", func() { }) Expect(err).ToNot(HaveOccurred()) - items, err := env.Fs.ListRecycle(ctx, &provider.Reference{ResourceId: env.SpaceRootRes}, "", "/") + items, err := env.Fs.ListRecycle(ctx, &provider.Reference{ResourceId: env.SpaceRootRes}, "", "") Expect(err).ToNot(HaveOccurred()) Expect(len(items)).To(Equal(1)) }) @@ -353,7 +353,7 @@ var _ = Describe("Recycle", func() { Expect(err).To(HaveOccurred()) Expect(err.Error()).To(ContainSubstring("permission denied")) - items, err := env.Fs.ListRecycle(ctx, &provider.Reference{ResourceId: env.SpaceRootRes}, "", "/") + items, err := env.Fs.ListRecycle(ctx, &provider.Reference{ResourceId: env.SpaceRootRes}, "", "") Expect(err).ToNot(HaveOccurred()) Expect(len(items)).To(Equal(0)) }) @@ -365,11 +365,11 @@ var _ = Describe("Recycle", func() { }) Expect(err).ToNot(HaveOccurred()) - items, err := env.Fs.ListRecycle(ctx, &provider.Reference{ResourceId: env.SpaceRootRes}, "", "/") + items, err := env.Fs.ListRecycle(ctx, &provider.Reference{ResourceId: env.SpaceRootRes}, "", "") Expect(err).ToNot(HaveOccurred()) Expect(len(items)).To(Equal(1)) - err = env.Fs.PurgeRecycleItem(ctx, &provider.Reference{ResourceId: env.SpaceRootRes}, items[0].Key, "/") + err = env.Fs.PurgeRecycleItem(ctx, &provider.Reference{ResourceId: env.SpaceRootRes}, items[0].Key, "") Expect(err).To(HaveOccurred()) Expect(err.Error()).To(ContainSubstring("permission denied")) }) @@ -381,11 +381,11 @@ var _ = Describe("Recycle", func() { }) Expect(err).ToNot(HaveOccurred()) - items, err := env.Fs.ListRecycle(ctx, &provider.Reference{ResourceId: env.SpaceRootRes}, "", "/") + items, err := env.Fs.ListRecycle(ctx, &provider.Reference{ResourceId: env.SpaceRootRes}, "", "") Expect(err).ToNot(HaveOccurred()) Expect(len(items)).To(Equal(1)) - err = env.Fs.RestoreRecycleItem(ctx, &provider.Reference{ResourceId: env.SpaceRootRes}, items[0].Key, "/", nil) + err = env.Fs.RestoreRecycleItem(ctx, &provider.Reference{ResourceId: env.SpaceRootRes}, items[0].Key, "", nil) Expect(err).To(HaveOccurred()) Expect(err.Error()).To(ContainSubstring("permission denied")) }) @@ -432,19 +432,19 @@ var _ = Describe("Recycle", func() { }) Expect(err).ToNot(HaveOccurred()) - _, err = env.Fs.ListRecycle(ctx, &provider.Reference{ResourceId: env.SpaceRootRes}, "", "/") + _, err = env.Fs.ListRecycle(ctx, &provider.Reference{ResourceId: env.SpaceRootRes}, "", "") Expect(err).To(HaveOccurred()) Expect(err.Error()).To(ContainSubstring("not found")) - items, err := env.Fs.ListRecycle(env.Ctx, &provider.Reference{ResourceId: env.SpaceRootRes}, "", "/") + items, err := env.Fs.ListRecycle(env.Ctx, &provider.Reference{ResourceId: env.SpaceRootRes}, "", "") Expect(err).ToNot(HaveOccurred()) Expect(len(items)).To(Equal(1)) - err = env.Fs.PurgeRecycleItem(ctx, &provider.Reference{ResourceId: env.SpaceRootRes}, items[0].Key, "/") + err = env.Fs.PurgeRecycleItem(ctx, &provider.Reference{ResourceId: env.SpaceRootRes}, items[0].Key, "") Expect(err).To(HaveOccurred()) Expect(err.Error()).To(ContainSubstring("not found")) - err = env.Fs.RestoreRecycleItem(ctx, &provider.Reference{ResourceId: env.SpaceRootRes}, items[0].Key, "/", nil) + err = env.Fs.RestoreRecycleItem(ctx, &provider.Reference{ResourceId: env.SpaceRootRes}, items[0].Key, "", nil) Expect(err).To(HaveOccurred()) Expect(err.Error()).To(ContainSubstring("not found")) })