seaweedfs/weed/filesys/dir_rename.go

150 lines
4.4 KiB
Go
Raw Normal View History

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"
"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"
"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 {
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)
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
err := dir.wfs.WithFilerClient(true, func(client filer_pb.SeaweedFilerClient) error {
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{
OldDirectory: dir.FullPath(),
OldName: req.OldName,
NewDirectory: newDir.FullPath(),
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
}
}
return nil
2018-06-07 14:39:30 +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
entryFileMode := newEntry.Attr.Mode
2021-10-17 19:22:42 +08:00
oldPath := oldParent.Child(oldName)
newPath := newParent.Child(newName)
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
}
}
})
// change file handle
if !newEntry.IsDirectory() {
inodeId := oldPath.AsInode(entryFileMode)
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)
existingHandle.handle = newPath.AsInode(entryFileMode)
existingHandle.f.entry.Name = newName
existingHandle.f.id = newPath.AsInode(entryFileMode)
dir.wfs.handles[newPath.AsInode(entryFileMode)] = existingHandle
}
dir.wfs.handlesLock.Unlock()
}
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
}