fixed the activity when file with file-id gives move activity instead…

… of rename

changelog/unreleased/fix-activity-rename.md

@@ -0,0 +1,6 @@
+Bugfix: Fix rename activity
+
+We fixed the activity when file with file-id gives move activity instead of rename.
+
+https://github.com/cs3org/reva/pull/4874
+https://github.com/owncloud/ocis/issues/9744

internal/grpc/interceptors/eventsmiddleware/events.go

@@ -75,6 +75,7 @@ func NewUnary(m map[string]interface{}) (grpc.UnaryServerInterceptor, int, error
 
  executant, _ := revactx.ContextGetUser(ctx)
 
+ // The MoveResponse event is moved to the decomposedfs
  var ev interface{}
  switch v := res.(type) {
  case *collaboration.CreateShareResponse:
@@ -141,10 +142,6 @@ func NewUnary(m map[string]interface{}) (grpc.UnaryServerInterceptor, int, error
  if isSuccess(v) {
  ev = ItemTrashed(v, req.(*provider.DeleteRequest), ownerID, executant)
  }
- case *provider.MoveResponse:
- if isSuccess(v) {
- ev = ItemMoved(v, req.(*provider.MoveRequest), ownerID, executant)
- }
  case *provider.PurgeRecycleResponse:
  if isSuccess(v) {
  ev = ItemPurged(v, req.(*provider.PurgeRecycleRequest), executant)

pkg/storage/utils/decomposedfs/decomposedfs.go

@@ -836,13 +836,13 @@ func (fs *Decomposedfs) Move(ctx context.Context, oldRef, newRef *provider.Refer
  return
  }
 
- rp, err := fs.p.AssemblePermissions(ctx, oldNode)
+ orp, err := fs.p.AssemblePermissions(ctx, oldNode)
  switch {
  case err != nil:
  return err
- case !rp.Move:
+ case !orp.Move:
  f, _ := storagespace.FormatReference(oldRef)
- if rp.Stat {
+ if orp.Stat {
  return errtypes.PermissionDenied(f)
  }
  return errtypes.NotFound(f)
@@ -856,19 +856,19 @@ func (fs *Decomposedfs) Move(ctx context.Context, oldRef, newRef *provider.Refer
  return
  }
 
- rp, err = fs.p.AssemblePermissions(ctx, newNode)
+ nrp, err := fs.p.AssemblePermissions(ctx, newNode)
  switch {
  case err != nil:
  return err
- case oldNode.IsDir(ctx) && !rp.CreateContainer:
+ case oldNode.IsDir(ctx) && !nrp.CreateContainer:
  f, _ := storagespace.FormatReference(newRef)
- if rp.Stat {
+ if nrp.Stat {
  return errtypes.PermissionDenied(f)
  }
  return errtypes.NotFound(f)
- case !oldNode.IsDir(ctx) && !rp.InitiateFileUpload:
+ case !oldNode.IsDir(ctx) && !nrp.InitiateFileUpload:
  f, _ := storagespace.FormatReference(newRef)
- if rp.Stat {
+ if nrp.Stat {
  return errtypes.PermissionDenied(f)
  }
  return errtypes.NotFound(f)
@@ -882,7 +882,13 @@ func (fs *Decomposedfs) Move(ctx context.Context, oldRef, newRef *provider.Refer
  return err
  }
 
- return fs.tp.Move(ctx, oldNode, newNode)
+ if err := fs.tp.Move(ctx, oldNode, newNode); err != nil {
+ return err
+ }
+
+ fs.publishEvent(ctx, fs.moveEvent(ctx, oldRef, newRef, oldNode, newNode, orp, nrp))
+
+ return nil
 }
 
 // GetMD returns the metadata for the specified resource
@@ -1241,3 +1247,35 @@ func (fs *Decomposedfs) PurgeRecycleItem(ctx context.Context, ref *provider.Refe
 func (fs *Decomposedfs) EmptyRecycle(ctx context.Context, ref *provider.Reference) error {
  return fs.trashbin.EmptyRecycle(ctx, ref)
 }
+
+func (fs *Decomposedfs) getNodePath(ctx context.Context, n *node.Node, perms *provider.ResourcePermissions) (string, error) {
+ hp := func(n *node.Node) bool {
+ if perms == nil {
+ return false
+ }
+ return perms.GetPath
+ }
+ return fs.lu.Path(ctx, n, hp)
+}
+
+func (fs *Decomposedfs) refFromNode(ctx context.Context, n *node.Node, storageId string, perms *provider.ResourcePermissions) (*provider.Reference, error) {
+ var err error
+ if perms == nil {
+ perms, err = fs.p.AssemblePermissions(ctx, n)
+ if err != nil {
+ return nil, err
+ }
+ }
+ path, err := fs.getNodePath(ctx, n, perms)
+ if err != nil {
+ return nil, err
+ }
+ return &provider.Reference{
+ ResourceId: &provider.ResourceId{
+ StorageId: storageId,
+ OpaqueId: n.SpaceID,
+ SpaceId: n.SpaceID,
+ },
+ Path: path,
+ }, nil
+}

pkg/storage/utils/decomposedfs/events.go

@@ -0,0 +1,83 @@
+// Copyright 2018-2021 CERN
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// In applying this license, CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+package decomposedfs
+
+import (
+ "context"
+
+ user "github.com/cs3org/go-cs3apis/cs3/identity/user/v1beta1"
+ provider "github.com/cs3org/go-cs3apis/cs3/storage/provider/v1beta1"
+ "github.com/cs3org/reva/v2/pkg/appctx"
+ revactx "github.com/cs3org/reva/v2/pkg/ctx"
+ "github.com/cs3org/reva/v2/pkg/events"
+ "github.com/cs3org/reva/v2/pkg/storage/utils/decomposedfs/node"
+ "github.com/cs3org/reva/v2/pkg/utils"
+)
+
+func (fs *Decomposedfs) publishEvent(ctx context.Context, evf func() (any, error)) {
+ log := appctx.GetLogger(ctx)
+ if fs.stream == nil {
+ log.Error().Msg("Failed to publish event, stream is undefined")
+ return
+ }
+ ev, err := evf()
+ if err != nil || ev == nil {
+ log.Error().Err(err).Msg("Failed to crete the event")
+ return
+ }
+ if err := events.Publish(ctx, fs.stream, ev); err != nil {
+ log.Error().Err(err).Msg("Failed to publish event")
+ }
+}
+
+func (fs *Decomposedfs) moveEvent(ctx context.Context, oldRef, newRef *provider.Reference, oldNode, newNode *node.Node, orp, nrp *provider.ResourcePermissions) func() (any, error) {
+ return func() (any, error) {
+ executant, _ := revactx.ContextGetUser(ctx)
+ ev := events.ItemMoved{
+ SpaceOwner: newNode.Owner(),
+ Executant: executant.GetId(),
+ Ref: newRef,
+ OldReference: oldRef,
+ Timestamp: utils.TSNow(),
+ ImpersonatingUser: extractImpersonator(executant),
+ }
+ log := appctx.GetLogger(ctx)
+ if nref, err := fs.refFromNode(ctx, newNode, newRef.GetResourceId().GetStorageId(), nrp); err == nil {
+ ev.Ref = nref
+ } else {
+ log.Error().Err(err).Msg("Failed to get destination reference")
+ }
+
+ if oref, err := fs.refFromNode(ctx, oldNode, oldRef.GetResourceId().GetStorageId(), orp); err == nil {
+ ev.OldReference = oref
+ } else {
+ log.Error().Err(err).Msg("Failed to get source reference")
+ }
+
+ return ev, nil
+ }
+}
+
+func extractImpersonator(u *user.User) *user.User {
+ var impersonator user.User
+ if err := utils.ReadJSONFromOpaque(u.Opaque, "impersonating-user", &impersonator); err != nil {
+ return nil
+ }
+ return &impersonator
+}

tests/integration/grpc/storageprovider_test.go

@@ -264,8 +264,9 @@ var _ = Describe("storage providers", func() {
 
  targetRef := &storagep.Reference{ResourceId: subdirRef.ResourceId, Path: "/new_subdir"}
  res, err := providerClient.Move(ctx, &storagep.MoveRequest{Source: subdirRef, Destination: targetRef})
- Expect(res.Status.Code).To(Equal(rpcv1beta1.Code_CODE_OK))
+
  Expect(err).ToNot(HaveOccurred())
+ Expect(res.GetStatus().GetCode()).To(Equal(rpcv1beta1.Code_CODE_OK))
 
  statRes, err = providerClient.Stat(ctx, &storagep.StatRequest{Ref: subdirRef})
  Expect(err).ToNot(HaveOccurred())