2018-06-07 14:39:30 +08:00
|
|
|
package filesys
|
|
|
|
|
|
|
|
import (
|
2019-01-17 09:17:19 +08:00
|
|
|
"context"
|
2021-07-01 16:19:28 +08:00
|
|
|
"github.com/chrislusf/seaweedfs/weed/filer"
|
2020-01-16 11:09:00 +08:00
|
|
|
"github.com/chrislusf/seaweedfs/weed/glog"
|
2019-03-31 14:08:29 +08:00
|
|
|
"github.com/chrislusf/seaweedfs/weed/pb/filer_pb"
|
2020-03-23 15:01:34 +08:00
|
|
|
"github.com/chrislusf/seaweedfs/weed/util"
|
2022-01-11 19:23:03 +08:00
|
|
|
"github.com/seaweedfs/fuse"
|
|
|
|
"github.com/seaweedfs/fuse/fs"
|
|
|
|
"io"
|
2022-01-13 03:51:13 +08:00
|
|
|
"os"
|
2022-01-11 19:23:03 +08:00
|
|
|
"strings"
|
2018-06-07 14:39:30 +08:00
|
|
|
)
|
|
|
|
|
|
|
|
func (dir *Dir) Rename(ctx context.Context, req *fuse.RenameRequest, newDirectory fs.Node) error {
|
|
|
|
|
2022-01-12 16:16:00 +08:00
|
|
|
if err := checkName(req.NewName); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
if err := checkName(req.OldName); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2018-06-07 14:39:30 +08:00
|
|
|
newDir := newDirectory.(*Dir)
|
2020-03-26 15:08:14 +08:00
|
|
|
|
|
|
|
newPath := util.NewFullPath(newDir.FullPath(), req.NewName)
|
|
|
|
oldPath := util.NewFullPath(dir.FullPath(), req.OldName)
|
|
|
|
|
2020-03-26 13:19:19 +08:00
|
|
|
glog.V(4).Infof("dir Rename %s => %s", oldPath, newPath)
|
2018-06-07 14:39:30 +08:00
|
|
|
|
2020-07-24 12:08:42 +08:00
|
|
|
// update remote filer
|
2021-12-26 16:15:03 +08:00
|
|
|
err := dir.wfs.WithFilerClient(true, func(client filer_pb.SeaweedFilerClient) error {
|
2020-09-10 03:07:15 +08:00
|
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
|
|
defer cancel()
|
2018-06-07 14:39:30 +08:00
|
|
|
|
2021-10-17 19:22:42 +08:00
|
|
|
request := &filer_pb.StreamRenameEntryRequest{
|
2020-03-26 15:08:14 +08:00
|
|
|
OldDirectory: dir.FullPath(),
|
2019-03-31 14:08:29 +08:00
|
|
|
OldName: req.OldName,
|
2020-03-26 15:08:14 +08:00
|
|
|
NewDirectory: newDir.FullPath(),
|
2019-03-31 14:08:29 +08:00
|
|
|
NewName: req.NewName,
|
2021-07-01 16:19:28 +08:00
|
|
|
Signatures: []int32{dir.wfs.signature},
|
2018-06-07 14:39:30 +08:00
|
|
|
}
|
|
|
|
|
2021-10-17 19:22:42 +08:00
|
|
|
stream, err := client.StreamRenameEntry(ctx, request)
|
2018-06-07 14:39:30 +08:00
|
|
|
if err != nil {
|
2020-09-23 00:16:07 +08:00
|
|
|
glog.Errorf("dir AtomicRenameEntry %s => %s : %v", oldPath, newPath, err)
|
2022-01-11 19:23:03 +08:00
|
|
|
return fuse.EIO
|
2018-06-07 14:39:30 +08:00
|
|
|
}
|
|
|
|
|
2021-10-17 19:22:42 +08:00
|
|
|
for {
|
|
|
|
resp, recvErr := stream.Recv()
|
|
|
|
if recvErr != nil {
|
|
|
|
if recvErr == io.EOF {
|
|
|
|
break
|
|
|
|
} else {
|
2022-01-11 19:23:03 +08:00
|
|
|
glog.V(0).Infof("dir Rename %s => %s receive: %v", oldPath, newPath, recvErr)
|
|
|
|
if strings.Contains(recvErr.Error(), "not empty") {
|
|
|
|
return fuse.EEXIST
|
|
|
|
}
|
|
|
|
if strings.Contains(recvErr.Error(), "not directory") {
|
|
|
|
return fuse.ENOTDIR
|
|
|
|
}
|
2021-10-17 19:22:42 +08:00
|
|
|
return recvErr
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if err = dir.handleRenameResponse(ctx, resp); err != nil {
|
2022-01-11 19:23:03 +08:00
|
|
|
glog.V(0).Infof("dir Rename %s => %s : %v", oldPath, newPath, err)
|
2021-10-17 19:22:42 +08:00
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2019-03-31 14:08:29 +08:00
|
|
|
return nil
|
2018-06-07 14:39:30 +08:00
|
|
|
|
|
|
|
})
|
2020-01-21 12:21:01 +08:00
|
|
|
|
2022-01-11 19:23:03 +08:00
|
|
|
return err
|
2018-06-07 14:39:30 +08:00
|
|
|
}
|
2021-07-01 16:19:28 +08:00
|
|
|
|
2021-10-17 19:22:42 +08:00
|
|
|
func (dir *Dir) handleRenameResponse(ctx context.Context, resp *filer_pb.StreamRenameEntryResponse) error {
|
|
|
|
// comes from filer StreamRenameEntry, can only be create or delete entry
|
|
|
|
|
|
|
|
if resp.EventNotification.NewEntry != nil {
|
|
|
|
// with new entry, the old entry name also exists. This is the first step to create new entry
|
|
|
|
newEntry := filer.FromPbEntry(resp.EventNotification.NewParentPath, resp.EventNotification.NewEntry)
|
|
|
|
if err := dir.wfs.metaCache.AtomicUpdateEntryFromFiler(ctx, "", newEntry); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2021-07-01 16:19:28 +08:00
|
|
|
|
2021-10-17 19:22:42 +08:00
|
|
|
oldParent, newParent := util.FullPath(resp.Directory), util.FullPath(resp.EventNotification.NewParentPath)
|
|
|
|
oldName, newName := resp.EventNotification.OldEntry.Name, resp.EventNotification.NewEntry.Name
|
2021-07-01 16:19:28 +08:00
|
|
|
|
2022-01-13 03:51:13 +08:00
|
|
|
entryFileMode := newEntry.Attr.Mode
|
2022-01-12 15:44:48 +08:00
|
|
|
|
2021-10-17 19:22:42 +08:00
|
|
|
oldPath := oldParent.Child(oldName)
|
|
|
|
newPath := newParent.Child(newName)
|
2022-01-13 03:51:13 +08:00
|
|
|
oldFsNode := NodeWithId(oldPath.AsInode(entryFileMode))
|
|
|
|
newFsNode := NodeWithId(newPath.AsInode(entryFileMode))
|
|
|
|
newDirNode, found := dir.wfs.Server.FindInternalNode(NodeWithId(newParent.AsInode(os.ModeDir)))
|
2021-07-01 16:19:28 +08:00
|
|
|
var newDir *Dir
|
|
|
|
if found {
|
|
|
|
newDir = newDirNode.(*Dir)
|
|
|
|
}
|
|
|
|
dir.wfs.Server.InvalidateInternalNode(oldFsNode, newFsNode, func(internalNode fs.Node) {
|
|
|
|
if file, ok := internalNode.(*File); ok {
|
|
|
|
glog.V(4).Infof("internal file node %s", oldParent.Child(oldName))
|
|
|
|
file.Name = newName
|
|
|
|
file.id = uint64(newFsNode)
|
|
|
|
if found {
|
|
|
|
file.dir = newDir
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if dir, ok := internalNode.(*Dir); ok {
|
|
|
|
glog.V(4).Infof("internal dir node %s", oldParent.Child(oldName))
|
|
|
|
dir.name = newName
|
|
|
|
dir.id = uint64(newFsNode)
|
|
|
|
if found {
|
|
|
|
dir.parent = newDir
|
|
|
|
}
|
|
|
|
}
|
|
|
|
})
|
|
|
|
|
2021-07-03 17:59:35 +08:00
|
|
|
// change file handle
|
2022-01-13 03:51:13 +08:00
|
|
|
if !newEntry.IsDirectory() {
|
|
|
|
inodeId := oldPath.AsInode(entryFileMode)
|
2022-01-12 15:44:48 +08:00
|
|
|
dir.wfs.handlesLock.Lock()
|
|
|
|
if existingHandle, found := dir.wfs.handles[inodeId]; found && existingHandle != nil {
|
|
|
|
glog.V(4).Infof("opened file handle %s => %s", oldPath, newPath)
|
|
|
|
delete(dir.wfs.handles, inodeId)
|
2022-01-13 03:51:13 +08:00
|
|
|
existingHandle.handle = newPath.AsInode(entryFileMode)
|
2022-01-12 15:44:48 +08:00
|
|
|
existingHandle.f.entry.Name = newName
|
2022-01-13 03:51:13 +08:00
|
|
|
existingHandle.f.id = newPath.AsInode(entryFileMode)
|
|
|
|
dir.wfs.handles[newPath.AsInode(entryFileMode)] = existingHandle
|
2022-01-12 15:44:48 +08:00
|
|
|
}
|
|
|
|
dir.wfs.handlesLock.Unlock()
|
2021-07-03 17:59:35 +08:00
|
|
|
}
|
|
|
|
|
2021-11-03 14:39:16 +08:00
|
|
|
} else if resp.EventNotification.OldEntry != nil {
|
2021-10-17 19:22:42 +08:00
|
|
|
// without new entry, only old entry name exists. This is the second step to delete old entry
|
|
|
|
if err := dir.wfs.metaCache.AtomicUpdateEntryFromFiler(ctx, util.NewFullPath(resp.Directory, resp.EventNotification.OldEntry.Name), nil); err != nil {
|
|
|
|
return err
|
2021-07-01 16:19:28 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return nil
|
|
|
|
|
|
|
|
}
|