Chris Lu
3 years ago
committed by
GitHub
GitHub
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
54 changed files with 4503 additions and 1 deletions
-
5go.mod
-
6go.sum
-
4weed/Makefile
-
1weed/command/command.go
-
83weed/command/mount2.go
-
210weed/command/mount2_std.go
-
42weed/mount/directory.go
-
84weed/mount/directory_read.go
-
99weed/mount/dirty_pages_chunked.go
-
95weed/mount/filehandle.go
-
84weed/mount/filehandle_map.go
-
114weed/mount/filehandle_read.go
-
161weed/mount/inode_to_path.go
-
32weed/mount/meta_cache/cache_config.go
-
101weed/mount/meta_cache/id_mapper.go
-
160weed/mount/meta_cache/meta_cache.go
-
67weed/mount/meta_cache/meta_cache_init.go
-
68weed/mount/meta_cache/meta_cache_subscribe.go
-
95weed/mount/page_writer.go
-
115weed/mount/page_writer/chunk_interval_list.go
-
49weed/mount/page_writer/chunk_interval_list_test.go
-
30weed/mount/page_writer/dirty_pages.go
-
16weed/mount/page_writer/page_chunk.go
-
69weed/mount/page_writer/page_chunk_mem.go
-
121weed/mount/page_writer/page_chunk_swapfile.go
-
182weed/mount/page_writer/upload_pipeline.go
-
63weed/mount/page_writer/upload_pipeline_lock.go
-
47weed/mount/page_writer/upload_pipeline_test.go
-
6weed/mount/unmount/unmount.go
-
21weed/mount/unmount/unmount_linux.go
-
18weed/mount/unmount/unmount_std.go
-
187weed/mount/weedfs.go
-
208weed/mount/weedfs_attr.go
-
8weed/mount/weedfs_attr_darwin.go
-
9weed/mount/weedfs_attr_linux.go
-
59weed/mount/weedfs_dir_lookup.go
-
111weed/mount/weedfs_dir_mkrm.go
-
132weed/mount/weedfs_dir_read.go
-
98weed/mount/weedfs_file_io.go
-
130weed/mount/weedfs_file_mkrm.go
-
59weed/mount/weedfs_file_read.go
-
180weed/mount/weedfs_file_sync.go
-
66weed/mount/weedfs_file_write.go
-
20weed/mount/weedfs_filehandle.go
-
68weed/mount/weedfs_forget.go
-
93weed/mount/weedfs_link.go
-
235weed/mount/weedfs_rename.go
-
80weed/mount/weedfs_stats.go
-
78weed/mount/weedfs_symlink.go
-
65weed/mount/weedfs_unsupported.go
-
84weed/mount/weedfs_write.go
-
168weed/mount/weedfs_xattr.go
-
51weed/mount/wfs_filer_client.go
-
67weed/mount/wfs_save.go
@ -0,0 +1,83 @@ |
|||||
|
package command |
||||
|
|
||||
|
import ( |
||||
|
"os" |
||||
|
"time" |
||||
|
) |
||||
|
|
||||
|
type Mount2Options struct { |
||||
|
filer *string |
||||
|
filerMountRootPath *string |
||||
|
dir *string |
||||
|
dirAutoCreate *bool |
||||
|
collection *string |
||||
|
replication *string |
||||
|
diskType *string |
||||
|
ttlSec *int |
||||
|
chunkSizeLimitMB *int |
||||
|
concurrentWriters *int |
||||
|
cacheDir *string |
||||
|
cacheSizeMB *int64 |
||||
|
dataCenter *string |
||||
|
allowOthers *bool |
||||
|
umaskString *string |
||||
|
nonempty *bool |
||||
|
volumeServerAccess *string |
||||
|
uidMap *string |
||||
|
gidMap *string |
||||
|
readOnly *bool |
||||
|
debug *bool |
||||
|
debugPort *int |
||||
|
} |
||||
|
|
||||
|
var ( |
||||
|
mount2Options Mount2Options |
||||
|
) |
||||
|
|
||||
|
func init() { |
||||
|
cmdMount2.Run = runMount2 // break init cycle
|
||||
|
mount2Options.filer = cmdMount2.Flag.String("filer", "localhost:8888", "comma-separated weed filer location") |
||||
|
mount2Options.filerMountRootPath = cmdMount2.Flag.String("filer.path", "/", "mount this remote path from filer server") |
||||
|
mount2Options.dir = cmdMount2.Flag.String("dir", ".", "mount weed filer to this directory") |
||||
|
mount2Options.dirAutoCreate = cmdMount2.Flag.Bool("dirAutoCreate", false, "auto create the directory to mount to") |
||||
|
mount2Options.collection = cmdMount2.Flag.String("collection", "", "collection to create the files") |
||||
|
mount2Options.replication = cmdMount2.Flag.String("replication", "", "replication(e.g. 000, 001) to create to files. If empty, let filer decide.") |
||||
|
mount2Options.diskType = cmdMount2.Flag.String("disk", "", "[hdd|ssd|<tag>] hard drive or solid state drive or any tag") |
||||
|
mount2Options.ttlSec = cmdMount2.Flag.Int("ttl", 0, "file ttl in seconds") |
||||
|
mount2Options.chunkSizeLimitMB = cmdMount2.Flag.Int("chunkSizeLimitMB", 2, "local write buffer size, also chunk large files") |
||||
|
mount2Options.concurrentWriters = cmdMount2.Flag.Int("concurrentWriters", 32, "limit concurrent goroutine writers if not 0") |
||||
|
mount2Options.cacheDir = cmdMount2.Flag.String("cacheDir", os.TempDir(), "local cache directory for file chunks and meta data") |
||||
|
mount2Options.cacheSizeMB = cmdMount2.Flag.Int64("cacheCapacityMB", 1000, "local file chunk cache capacity in MB (0 will disable cache)") |
||||
|
mount2Options.dataCenter = cmdMount2.Flag.String("dataCenter", "", "prefer to write to the data center") |
||||
|
mount2Options.allowOthers = cmdMount2.Flag.Bool("allowOthers", true, "allows other users to access the file system") |
||||
|
mount2Options.umaskString = cmdMount2.Flag.String("umask", "022", "octal umask, e.g., 022, 0111") |
||||
|
mount2Options.nonempty = cmdMount2.Flag.Bool("nonempty", false, "allows the mounting over a non-empty directory") |
||||
|
mount2Options.volumeServerAccess = cmdMount2.Flag.String("volumeServerAccess", "direct", "access volume servers by [direct|publicUrl|filerProxy]") |
||||
|
mount2Options.uidMap = cmdMount2.Flag.String("map.uid", "", "map local uid to uid on filer, comma-separated <local_uid>:<filer_uid>") |
||||
|
mount2Options.gidMap = cmdMount2.Flag.String("map.gid", "", "map local gid to gid on filer, comma-separated <local_gid>:<filer_gid>") |
||||
|
mount2Options.readOnly = cmdMount2.Flag.Bool("readOnly", false, "read only") |
||||
|
mount2Options.debug = cmdMount2.Flag.Bool("debug", false, "serves runtime profiling data, e.g., http://localhost:<debug.port>/debug/pprof/goroutine?debug=2") |
||||
|
mount2Options.debugPort = cmdMount2.Flag.Int("debug.port", 6061, "http port for debugging") |
||||
|
|
||||
|
mountCpuProfile = cmdMount2.Flag.String("cpuprofile", "", "cpu profile output file") |
||||
|
mountMemProfile = cmdMount2.Flag.String("memprofile", "", "memory profile output file") |
||||
|
mountReadRetryTime = cmdMount2.Flag.Duration("readRetryTime", 6*time.Second, "maximum read retry wait time") |
||||
|
} |
||||
|
|
||||
|
var cmdMount2 = &Command{ |
||||
|
UsageLine: "mount2 -filer=localhost:8888 -dir=/some/dir", |
||||
|
Short: "<WIP> mount weed filer to a directory as file system in userspace(FUSE)", |
||||
|
Long: `mount weed filer to userspace. |
||||
|
|
||||
|
Pre-requisites: |
||||
|
1) have SeaweedFS master and volume servers running |
||||
|
2) have a "weed filer" running |
||||
|
These 2 requirements can be achieved with one command "weed server -filer=true" |
||||
|
|
||||
|
This uses github.com/seaweedfs/fuse, which enables writing FUSE file systems on |
||||
|
Linux, and OS X. |
||||
|
|
||||
|
On OS X, it requires OSXFUSE (http://osxfuse.github.com/).
|
||||
|
|
||||
|
`, |
||||
|
} |
||||
@ -0,0 +1,210 @@ |
|||||
|
package command |
||||
|
|
||||
|
import ( |
||||
|
"context" |
||||
|
"fmt" |
||||
|
"github.com/chrislusf/seaweedfs/weed/glog" |
||||
|
"github.com/chrislusf/seaweedfs/weed/mount" |
||||
|
"github.com/chrislusf/seaweedfs/weed/mount/meta_cache" |
||||
|
"github.com/chrislusf/seaweedfs/weed/mount/unmount" |
||||
|
"github.com/chrislusf/seaweedfs/weed/pb" |
||||
|
"github.com/chrislusf/seaweedfs/weed/pb/filer_pb" |
||||
|
"github.com/chrislusf/seaweedfs/weed/security" |
||||
|
"github.com/chrislusf/seaweedfs/weed/storage/types" |
||||
|
"github.com/hanwen/go-fuse/v2/fuse" |
||||
|
"net/http" |
||||
|
"os" |
||||
|
"os/user" |
||||
|
"runtime" |
||||
|
"strconv" |
||||
|
"strings" |
||||
|
"time" |
||||
|
|
||||
|
"github.com/chrislusf/seaweedfs/weed/util" |
||||
|
"github.com/chrislusf/seaweedfs/weed/util/grace" |
||||
|
) |
||||
|
|
||||
|
func runMount2(cmd *Command, args []string) bool { |
||||
|
|
||||
|
if *mountOptions.debug { |
||||
|
go http.ListenAndServe(fmt.Sprintf(":%d", *mountOptions.debugPort), nil) |
||||
|
} |
||||
|
|
||||
|
grace.SetupProfiling(*mountCpuProfile, *mountMemProfile) |
||||
|
if *mountReadRetryTime < time.Second { |
||||
|
*mountReadRetryTime = time.Second |
||||
|
} |
||||
|
util.RetryWaitTime = *mountReadRetryTime |
||||
|
|
||||
|
umask, umaskErr := strconv.ParseUint(*mountOptions.umaskString, 8, 64) |
||||
|
if umaskErr != nil { |
||||
|
fmt.Printf("can not parse umask %s", *mountOptions.umaskString) |
||||
|
return false |
||||
|
} |
||||
|
|
||||
|
if len(args) > 0 { |
||||
|
return false |
||||
|
} |
||||
|
|
||||
|
return RunMount2(&mount2Options, os.FileMode(umask)) |
||||
|
} |
||||
|
|
||||
|
func RunMount2(option *Mount2Options, umask os.FileMode) bool { |
||||
|
|
||||
|
// basic checks
|
||||
|
chunkSizeLimitMB := *mountOptions.chunkSizeLimitMB |
||||
|
if chunkSizeLimitMB <= 0 { |
||||
|
fmt.Printf("Please specify a reasonable buffer size.") |
||||
|
return false |
||||
|
} |
||||
|
|
||||
|
// try to connect to filer
|
||||
|
filerAddresses := pb.ServerAddresses(*option.filer).ToAddresses() |
||||
|
util.LoadConfiguration("security", false) |
||||
|
grpcDialOption := security.LoadClientTLS(util.GetViper(), "grpc.client") |
||||
|
var cipher bool |
||||
|
var err error |
||||
|
for i := 0; i < 10; i++ { |
||||
|
err = pb.WithOneOfGrpcFilerClients(false, filerAddresses, grpcDialOption, func(client filer_pb.SeaweedFilerClient) error { |
||||
|
resp, err := client.GetFilerConfiguration(context.Background(), &filer_pb.GetFilerConfigurationRequest{}) |
||||
|
if err != nil { |
||||
|
return fmt.Errorf("get filer grpc address %v configuration: %v", filerAddresses, err) |
||||
|
} |
||||
|
cipher = resp.Cipher |
||||
|
return nil |
||||
|
}) |
||||
|
if err != nil { |
||||
|
glog.V(0).Infof("failed to talk to filer %v: %v", filerAddresses, err) |
||||
|
glog.V(0).Infof("wait for %d seconds ...", i+1) |
||||
|
time.Sleep(time.Duration(i+1) * time.Second) |
||||
|
} |
||||
|
} |
||||
|
if err != nil { |
||||
|
glog.Errorf("failed to talk to filer %v: %v", filerAddresses, err) |
||||
|
return true |
||||
|
} |
||||
|
|
||||
|
filerMountRootPath := *option.filerMountRootPath |
||||
|
|
||||
|
// clean up mount point
|
||||
|
dir := util.ResolvePath(*option.dir) |
||||
|
if dir == "" { |
||||
|
fmt.Printf("Please specify the mount directory via \"-dir\"") |
||||
|
return false |
||||
|
} |
||||
|
|
||||
|
unmount.Unmount(dir) |
||||
|
|
||||
|
// detect mount folder mode
|
||||
|
if *option.dirAutoCreate { |
||||
|
os.MkdirAll(dir, os.FileMode(0777)&^umask) |
||||
|
} |
||||
|
fileInfo, err := os.Stat(dir) |
||||
|
|
||||
|
// collect uid, gid
|
||||
|
uid, gid := uint32(0), uint32(0) |
||||
|
mountMode := os.ModeDir | 0777 |
||||
|
if err == nil { |
||||
|
mountMode = os.ModeDir | os.FileMode(0777)&^umask |
||||
|
uid, gid = util.GetFileUidGid(fileInfo) |
||||
|
fmt.Printf("mount point owner uid=%d gid=%d mode=%s\n", uid, gid, mountMode) |
||||
|
} else { |
||||
|
fmt.Printf("can not stat %s\n", dir) |
||||
|
return false |
||||
|
} |
||||
|
|
||||
|
// detect uid, gid
|
||||
|
if uid == 0 { |
||||
|
if u, err := user.Current(); err == nil { |
||||
|
if parsedId, pe := strconv.ParseUint(u.Uid, 10, 32); pe == nil { |
||||
|
uid = uint32(parsedId) |
||||
|
} |
||||
|
if parsedId, pe := strconv.ParseUint(u.Gid, 10, 32); pe == nil { |
||||
|
gid = uint32(parsedId) |
||||
|
} |
||||
|
fmt.Printf("current uid=%d gid=%d\n", uid, gid) |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
// mapping uid, gid
|
||||
|
uidGidMapper, err := meta_cache.NewUidGidMapper(*option.uidMap, *option.gidMap) |
||||
|
if err != nil { |
||||
|
fmt.Printf("failed to parse %s %s: %v\n", *option.uidMap, *option.gidMap, err) |
||||
|
return false |
||||
|
} |
||||
|
|
||||
|
// Ensure target mount point availability
|
||||
|
if isValid := checkMountPointAvailable(dir); !isValid { |
||||
|
glog.Fatalf("Expected mount to still be active, target mount point: %s, please check!", dir) |
||||
|
return true |
||||
|
} |
||||
|
|
||||
|
// mount fuse
|
||||
|
fuseMountOptions := &fuse.MountOptions{ |
||||
|
AllowOther: *option.allowOthers, |
||||
|
Options: nil, |
||||
|
MaxBackground: 128, |
||||
|
MaxWrite: 1024 * 1024 * 2, |
||||
|
MaxReadAhead: 1024 * 1024 * 2, |
||||
|
IgnoreSecurityLabels: false, |
||||
|
RememberInodes: false, |
||||
|
FsName: *option.filer + ":" + filerMountRootPath, |
||||
|
Name: "seaweedfs", |
||||
|
SingleThreaded: false, |
||||
|
DisableXAttrs: false, |
||||
|
Debug: true, |
||||
|
EnableLocks: false, |
||||
|
ExplicitDataCacheControl: false, |
||||
|
// SyncRead: false, // set to false to enable the FUSE_CAP_ASYNC_READ capability
|
||||
|
DirectMount: true, |
||||
|
DirectMountFlags: 0, |
||||
|
// EnableAcl: false,
|
||||
|
} |
||||
|
|
||||
|
// find mount point
|
||||
|
mountRoot := filerMountRootPath |
||||
|
if mountRoot != "/" && strings.HasSuffix(mountRoot, "/") { |
||||
|
mountRoot = mountRoot[0 : len(mountRoot)-1] |
||||
|
} |
||||
|
|
||||
|
seaweedFileSystem := mount.NewSeaweedFileSystem(&mount.Option{ |
||||
|
MountDirectory: dir, |
||||
|
FilerAddresses: filerAddresses, |
||||
|
GrpcDialOption: grpcDialOption, |
||||
|
FilerMountRootPath: mountRoot, |
||||
|
Collection: *option.collection, |
||||
|
Replication: *option.replication, |
||||
|
TtlSec: int32(*option.ttlSec), |
||||
|
DiskType: types.ToDiskType(*option.diskType), |
||||
|
ChunkSizeLimit: int64(chunkSizeLimitMB) * 1024 * 1024, |
||||
|
ConcurrentWriters: *option.concurrentWriters, |
||||
|
CacheDir: *option.cacheDir, |
||||
|
CacheSizeMB: *option.cacheSizeMB, |
||||
|
DataCenter: *option.dataCenter, |
||||
|
MountUid: uid, |
||||
|
MountGid: gid, |
||||
|
MountMode: mountMode, |
||||
|
MountCtime: fileInfo.ModTime(), |
||||
|
MountMtime: time.Now(), |
||||
|
Umask: umask, |
||||
|
VolumeServerAccess: *mountOptions.volumeServerAccess, |
||||
|
Cipher: cipher, |
||||
|
UidGidMapper: uidGidMapper, |
||||
|
}) |
||||
|
|
||||
|
server, err := fuse.NewServer(seaweedFileSystem, dir, fuseMountOptions) |
||||
|
if err != nil { |
||||
|
glog.Fatalf("Mount fail: %v", err) |
||||
|
} |
||||
|
grace.OnInterrupt(func() { |
||||
|
unmount.Unmount(dir) |
||||
|
}) |
||||
|
|
||||
|
seaweedFileSystem.StartBackgroundTasks() |
||||
|
|
||||
|
fmt.Printf("This is SeaweedFS version %s %s %s\n", util.Version(), runtime.GOOS, runtime.GOARCH) |
||||
|
|
||||
|
server.Serve() |
||||
|
|
||||
|
return true |
||||
|
} |
||||
@ -0,0 +1,42 @@ |
|||||
|
package mount |
||||
|
|
||||
|
import ( |
||||
|
"bytes" |
||||
|
"github.com/chrislusf/seaweedfs/weed/pb/filer_pb" |
||||
|
"github.com/hanwen/go-fuse/v2/fs" |
||||
|
"strings" |
||||
|
) |
||||
|
|
||||
|
type Directory struct { |
||||
|
fs.Inode |
||||
|
|
||||
|
name string |
||||
|
wfs *WFS |
||||
|
entry *filer_pb.Entry |
||||
|
parent *Directory |
||||
|
id uint64 |
||||
|
} |
||||
|
|
||||
|
func (dir *Directory) FullPath() string { |
||||
|
var parts []string |
||||
|
for p := dir; p != nil; p = p.parent { |
||||
|
if strings.HasPrefix(p.name, "/") { |
||||
|
if len(p.name) > 1 { |
||||
|
parts = append(parts, p.name[1:]) |
||||
|
} |
||||
|
} else { |
||||
|
parts = append(parts, p.name) |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
if len(parts) == 0 { |
||||
|
return "/" |
||||
|
} |
||||
|
|
||||
|
var buf bytes.Buffer |
||||
|
for i := len(parts) - 1; i >= 0; i-- { |
||||
|
buf.WriteString("/") |
||||
|
buf.WriteString(parts[i]) |
||||
|
} |
||||
|
return buf.String() |
||||
|
} |
||||
@ -0,0 +1,84 @@ |
|||||
|
package mount |
||||
|
|
||||
|
import ( |
||||
|
"context" |
||||
|
"github.com/chrislusf/seaweedfs/weed/filer" |
||||
|
"github.com/chrislusf/seaweedfs/weed/glog" |
||||
|
"github.com/chrislusf/seaweedfs/weed/mount/meta_cache" |
||||
|
"github.com/chrislusf/seaweedfs/weed/util" |
||||
|
"github.com/hanwen/go-fuse/v2/fs" |
||||
|
"github.com/hanwen/go-fuse/v2/fuse" |
||||
|
"math" |
||||
|
"os" |
||||
|
"syscall" |
||||
|
) |
||||
|
|
||||
|
var _ = fs.NodeReaddirer(&Directory{}) |
||||
|
var _ = fs.NodeGetattrer(&Directory{}) |
||||
|
|
||||
|
func (dir *Directory) Getattr(ctx context.Context, fh fs.FileHandle, out *fuse.AttrOut) syscall.Errno { |
||||
|
out.Mode = 0755 |
||||
|
return 0 |
||||
|
} |
||||
|
|
||||
|
func (dir *Directory) Readdir(ctx context.Context) (fs.DirStream, syscall.Errno) { |
||||
|
|
||||
|
dirPath := util.FullPath(dir.FullPath()) |
||||
|
glog.V(4).Infof("Readdir %s", dirPath) |
||||
|
|
||||
|
sourceChan := make(chan fuse.DirEntry, 64) |
||||
|
|
||||
|
stream := newDirectoryListStream(sourceChan) |
||||
|
|
||||
|
processEachEntryFn := func(entry *filer.Entry, isLast bool) { |
||||
|
sourceChan <- fuse.DirEntry{ |
||||
|
Mode: uint32(entry.Mode), |
||||
|
Name: entry.Name(), |
||||
|
Ino: dirPath.Child(entry.Name()).AsInode(os.ModeDir), |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
if err := meta_cache.EnsureVisited(dir.wfs.metaCache, dir.wfs, dirPath); err != nil { |
||||
|
glog.Errorf("dir ReadDirAll %s: %v", dirPath, err) |
||||
|
return nil, fs.ToErrno(os.ErrInvalid) |
||||
|
} |
||||
|
go func() { |
||||
|
dir.wfs.metaCache.ListDirectoryEntries(context.Background(), dirPath, "", false, int64(math.MaxInt32), func(entry *filer.Entry) bool { |
||||
|
processEachEntryFn(entry, false) |
||||
|
return true |
||||
|
}) |
||||
|
close(sourceChan) |
||||
|
}() |
||||
|
|
||||
|
return stream, fs.OK |
||||
|
} |
||||
|
|
||||
|
var _ = fs.DirStream(&DirectoryListStream{}) |
||||
|
|
||||
|
type DirectoryListStream struct { |
||||
|
next fuse.DirEntry |
||||
|
sourceChan chan fuse.DirEntry |
||||
|
isStarted bool |
||||
|
hasNext bool |
||||
|
} |
||||
|
|
||||
|
func newDirectoryListStream(ch chan fuse.DirEntry) *DirectoryListStream { |
||||
|
return &DirectoryListStream{ |
||||
|
sourceChan: ch, |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
func (i *DirectoryListStream) HasNext() bool { |
||||
|
if !i.isStarted { |
||||
|
i.next, i.hasNext = <-i.sourceChan |
||||
|
i.isStarted = true |
||||
|
} |
||||
|
return i.hasNext |
||||
|
} |
||||
|
func (i *DirectoryListStream) Next() (fuse.DirEntry, syscall.Errno) { |
||||
|
t := i.next |
||||
|
i.next, i.hasNext = <-i.sourceChan |
||||
|
return t, fs.OK |
||||
|
} |
||||
|
func (i *DirectoryListStream) Close() { |
||||
|
} |
||||
@ -0,0 +1,99 @@ |
|||||
|
package mount |
||||
|
|
||||
|
import ( |
||||
|
"fmt" |
||||
|
"github.com/chrislusf/seaweedfs/weed/filesys/page_writer" |
||||
|
"github.com/chrislusf/seaweedfs/weed/glog" |
||||
|
"github.com/chrislusf/seaweedfs/weed/pb/filer_pb" |
||||
|
"io" |
||||
|
"sync" |
||||
|
"time" |
||||
|
) |
||||
|
|
||||
|
type ChunkedDirtyPages struct { |
||||
|
fh *FileHandle |
||||
|
writeWaitGroup sync.WaitGroup |
||||
|
lastErr error |
||||
|
collection string |
||||
|
replication string |
||||
|
uploadPipeline *page_writer.UploadPipeline |
||||
|
hasWrites bool |
||||
|
} |
||||
|
|
||||
|
var ( |
||||
|
_ = page_writer.DirtyPages(&ChunkedDirtyPages{}) |
||||
|
) |
||||
|
|
||||
|
func newMemoryChunkPages(fh *FileHandle, chunkSize int64) *ChunkedDirtyPages { |
||||
|
|
||||
|
dirtyPages := &ChunkedDirtyPages{ |
||||
|
fh: fh, |
||||
|
} |
||||
|
|
||||
|
dirtyPages.uploadPipeline = page_writer.NewUploadPipeline(fh.wfs.concurrentWriters, chunkSize, dirtyPages.saveChunkedFileIntevalToStorage, fh.wfs.option.ConcurrentWriters) |
||||
|
|
||||
|
return dirtyPages |
||||
|
} |
||||
|
|
||||
|
func (pages *ChunkedDirtyPages) AddPage(offset int64, data []byte) { |
||||
|
pages.hasWrites = true |
||||
|
|
||||
|
glog.V(4).Infof("%v memory AddPage [%d, %d)", pages.fh, offset, offset+int64(len(data))) |
||||
|
pages.uploadPipeline.SaveDataAt(data, offset) |
||||
|
|
||||
|
return |
||||
|
} |
||||
|
|
||||
|
func (pages *ChunkedDirtyPages) FlushData() error { |
||||
|
if !pages.hasWrites { |
||||
|
return nil |
||||
|
} |
||||
|
pages.uploadPipeline.FlushAll() |
||||
|
if pages.lastErr != nil { |
||||
|
return fmt.Errorf("flush data: %v", pages.lastErr) |
||||
|
} |
||||
|
return nil |
||||
|
} |
||||
|
|
||||
|
func (pages *ChunkedDirtyPages) ReadDirtyDataAt(data []byte, startOffset int64) (maxStop int64) { |
||||
|
if !pages.hasWrites { |
||||
|
return |
||||
|
} |
||||
|
return pages.uploadPipeline.MaybeReadDataAt(data, startOffset) |
||||
|
} |
||||
|
|
||||
|
func (pages *ChunkedDirtyPages) GetStorageOptions() (collection, replication string) { |
||||
|
return pages.collection, pages.replication |
||||
|
} |
||||
|
|
||||
|
func (pages *ChunkedDirtyPages) saveChunkedFileIntevalToStorage(reader io.Reader, offset int64, size int64, cleanupFn func()) { |
||||
|
|
||||
|
mtime := time.Now().UnixNano() |
||||
|
defer cleanupFn() |
||||
|
|
||||
|
fileFullPath := pages.fh.FullPath() |
||||
|
fileName := fileFullPath.Name() |
||||
|
chunk, collection, replication, err := pages.fh.wfs.saveDataAsChunk(fileFullPath)(reader, fileName, offset) |
||||
|
if err != nil { |
||||
|
glog.V(0).Infof("%v saveToStorage [%d,%d): %v", fileFullPath, offset, offset+size, err) |
||||
|
pages.lastErr = err |
||||
|
return |
||||
|
} |
||||
|
chunk.Mtime = mtime |
||||
|
pages.collection, pages.replication = collection, replication |
||||
|
pages.fh.addChunks([]*filer_pb.FileChunk{chunk}) |
||||
|
pages.fh.entryViewCache = nil |
||||
|
glog.V(3).Infof("%v saveToStorage %s [%d,%d)", fileFullPath, chunk.FileId, offset, offset+size) |
||||
|
|
||||
|
} |
||||
|
|
||||
|
func (pages ChunkedDirtyPages) Destroy() { |
||||
|
pages.uploadPipeline.Shutdown() |
||||
|
} |
||||
|
|
||||
|
func (pages *ChunkedDirtyPages) LockForRead(startOffset, stopOffset int64) { |
||||
|
pages.uploadPipeline.LockForRead(startOffset, stopOffset) |
||||
|
} |
||||
|
func (pages *ChunkedDirtyPages) UnlockForRead(startOffset, stopOffset int64) { |
||||
|
pages.uploadPipeline.UnlockForRead(startOffset, stopOffset) |
||||
|
} |
||||
@ -0,0 +1,95 @@ |
|||||
|
package mount |
||||
|
|
||||
|
import ( |
||||
|
"github.com/chrislusf/seaweedfs/weed/filer" |
||||
|
"github.com/chrislusf/seaweedfs/weed/glog" |
||||
|
"github.com/chrislusf/seaweedfs/weed/pb/filer_pb" |
||||
|
"github.com/chrislusf/seaweedfs/weed/util" |
||||
|
"io" |
||||
|
"sort" |
||||
|
"sync" |
||||
|
) |
||||
|
|
||||
|
type FileHandleId uint64 |
||||
|
|
||||
|
type FileHandle struct { |
||||
|
fh FileHandleId |
||||
|
counter int64 |
||||
|
entry *filer_pb.Entry |
||||
|
chunkAddLock sync.Mutex |
||||
|
inode uint64 |
||||
|
wfs *WFS |
||||
|
|
||||
|
// cache file has been written to
|
||||
|
dirtyMetadata bool |
||||
|
dirtyPages *PageWriter |
||||
|
entryViewCache []filer.VisibleInterval |
||||
|
reader io.ReaderAt |
||||
|
contentType string |
||||
|
handle uint64 |
||||
|
sync.Mutex |
||||
|
|
||||
|
isDeleted bool |
||||
|
} |
||||
|
|
||||
|
func newFileHandle(wfs *WFS, handleId FileHandleId, inode uint64, entry *filer_pb.Entry) *FileHandle { |
||||
|
fh := &FileHandle{ |
||||
|
fh: handleId, |
||||
|
counter: 1, |
||||
|
inode: inode, |
||||
|
wfs: wfs, |
||||
|
} |
||||
|
// dirtyPages: newContinuousDirtyPages(file, writeOnly),
|
||||
|
fh.dirtyPages = newPageWriter(fh, wfs.option.ChunkSizeLimit) |
||||
|
if entry != nil { |
||||
|
entry.Attributes.FileSize = filer.FileSize(entry) |
||||
|
} |
||||
|
|
||||
|
return fh |
||||
|
} |
||||
|
|
||||
|
func (fh *FileHandle) FullPath() util.FullPath { |
||||
|
return fh.wfs.inodeToPath.GetPath(fh.inode) |
||||
|
} |
||||
|
|
||||
|
func (fh *FileHandle) addChunks(chunks []*filer_pb.FileChunk) { |
||||
|
|
||||
|
// find the earliest incoming chunk
|
||||
|
newChunks := chunks |
||||
|
earliestChunk := newChunks[0] |
||||
|
for i := 1; i < len(newChunks); i++ { |
||||
|
if lessThan(earliestChunk, newChunks[i]) { |
||||
|
earliestChunk = newChunks[i] |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
if fh.entry == nil { |
||||
|
return |
||||
|
} |
||||
|
|
||||
|
// pick out-of-order chunks from existing chunks
|
||||
|
for _, chunk := range fh.entry.Chunks { |
||||
|
if lessThan(earliestChunk, chunk) { |
||||
|
chunks = append(chunks, chunk) |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
// sort incoming chunks
|
||||
|
sort.Slice(chunks, func(i, j int) bool { |
||||
|
return lessThan(chunks[i], chunks[j]) |
||||
|
}) |
||||
|
|
||||
|
glog.V(4).Infof("%s existing %d chunks adds %d more", fh.FullPath(), len(fh.entry.Chunks), len(chunks)) |
||||
|
|
||||
|
fh.chunkAddLock.Lock() |
||||
|
fh.entry.Chunks = append(fh.entry.Chunks, newChunks...) |
||||
|
fh.entryViewCache = nil |
||||
|
fh.chunkAddLock.Unlock() |
||||
|
} |
||||
|
|
||||
|
func lessThan(a, b *filer_pb.FileChunk) bool { |
||||
|
if a.Mtime == b.Mtime { |
||||
|
return a.Fid.FileKey < b.Fid.FileKey |
||||
|
} |
||||
|
return a.Mtime < b.Mtime |
||||
|
} |
||||
@ -0,0 +1,84 @@ |
|||||
|
package mount |
||||
|
|
||||
|
import ( |
||||
|
"github.com/chrislusf/seaweedfs/weed/pb/filer_pb" |
||||
|
"sync" |
||||
|
) |
||||
|
|
||||
|
type FileHandleToInode struct { |
||||
|
sync.RWMutex |
||||
|
nextFh FileHandleId |
||||
|
inode2fh map[uint64]*FileHandle |
||||
|
fh2inode map[FileHandleId]uint64 |
||||
|
} |
||||
|
|
||||
|
func NewFileHandleToInode() *FileHandleToInode { |
||||
|
return &FileHandleToInode{ |
||||
|
inode2fh: make(map[uint64]*FileHandle), |
||||
|
fh2inode: make(map[FileHandleId]uint64), |
||||
|
nextFh: 0, |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
func (i *FileHandleToInode) GetFileHandle(fh FileHandleId) *FileHandle { |
||||
|
i.RLock() |
||||
|
defer i.RUnlock() |
||||
|
inode, found := i.fh2inode[fh] |
||||
|
if found { |
||||
|
return i.inode2fh[inode] |
||||
|
} |
||||
|
return nil |
||||
|
} |
||||
|
|
||||
|
func (i *FileHandleToInode) FindFileHandle(inode uint64) (fh *FileHandle, found bool) { |
||||
|
i.RLock() |
||||
|
defer i.RUnlock() |
||||
|
fh, found = i.inode2fh[inode] |
||||
|
return |
||||
|
} |
||||
|
|
||||
|
func (i *FileHandleToInode) AcquireFileHandle(wfs *WFS, inode uint64, entry *filer_pb.Entry) *FileHandle { |
||||
|
i.Lock() |
||||
|
defer i.Unlock() |
||||
|
fh, found := i.inode2fh[inode] |
||||
|
if !found { |
||||
|
fh = newFileHandle(wfs, i.nextFh, inode, entry) |
||||
|
i.nextFh++ |
||||
|
i.inode2fh[inode] = fh |
||||
|
i.fh2inode[fh.fh] = inode |
||||
|
} else { |
||||
|
fh.counter++ |
||||
|
} |
||||
|
return fh |
||||
|
} |
||||
|
|
||||
|
func (i *FileHandleToInode) ReleaseByInode(inode uint64) { |
||||
|
i.Lock() |
||||
|
defer i.Unlock() |
||||
|
fh, found := i.inode2fh[inode] |
||||
|
if found { |
||||
|
fh.counter-- |
||||
|
if fh.counter <= 0 { |
||||
|
delete(i.inode2fh, inode) |
||||
|
delete(i.fh2inode, fh.fh) |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
func (i *FileHandleToInode) ReleaseByHandle(fh FileHandleId) { |
||||
|
i.Lock() |
||||
|
defer i.Unlock() |
||||
|
inode, found := i.fh2inode[fh] |
||||
|
if found { |
||||
|
fhHandle, fhFound := i.inode2fh[inode] |
||||
|
if !fhFound { |
||||
|
delete(i.fh2inode, fh) |
||||
|
} else { |
||||
|
fhHandle.counter-- |
||||
|
if fhHandle.counter <= 0 { |
||||
|
delete(i.inode2fh, inode) |
||||
|
delete(i.fh2inode, fhHandle.fh) |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,114 @@ |
|||||
|
package mount |
||||
|
|
||||
|
import ( |
||||
|
"context" |
||||
|
"fmt" |
||||
|
"github.com/chrislusf/seaweedfs/weed/filer" |
||||
|
"github.com/chrislusf/seaweedfs/weed/glog" |
||||
|
"github.com/chrislusf/seaweedfs/weed/pb/filer_pb" |
||||
|
"io" |
||||
|
"math" |
||||
|
) |
||||
|
|
||||
|
func (fh *FileHandle) lockForRead(startOffset int64, size int) { |
||||
|
fh.dirtyPages.LockForRead(startOffset, startOffset+int64(size)) |
||||
|
} |
||||
|
func (fh *FileHandle) unlockForRead(startOffset int64, size int) { |
||||
|
fh.dirtyPages.UnlockForRead(startOffset, startOffset+int64(size)) |
||||
|
} |
||||
|
|
||||
|
func (fh *FileHandle) readFromDirtyPages(buff []byte, startOffset int64) (maxStop int64) { |
||||
|
maxStop = fh.dirtyPages.ReadDirtyDataAt(buff, startOffset) |
||||
|
return |
||||
|
} |
||||
|
|
||||
|
func (fh *FileHandle) readFromChunks(buff []byte, offset int64) (int64, error) { |
||||
|
|
||||
|
fileFullPath := fh.FullPath() |
||||
|
|
||||
|
entry := fh.entry |
||||
|
if entry == nil { |
||||
|
return 0, io.EOF |
||||
|
} |
||||
|
|
||||
|
if entry.IsInRemoteOnly() { |
||||
|
glog.V(4).Infof("download remote entry %s", fileFullPath) |
||||
|
newEntry, err := fh.downloadRemoteEntry(entry) |
||||
|
if err != nil { |
||||
|
glog.V(1).Infof("download remote entry %s: %v", fileFullPath, err) |
||||
|
return 0, err |
||||
|
} |
||||
|
entry = newEntry |
||||
|
} |
||||
|
|
||||
|
fileSize := int64(filer.FileSize(entry)) |
||||
|
|
||||
|
if fileSize == 0 { |
||||
|
glog.V(1).Infof("empty fh %v", fileFullPath) |
||||
|
return 0, io.EOF |
||||
|
} |
||||
|
|
||||
|
if offset+int64(len(buff)) <= int64(len(entry.Content)) { |
||||
|
totalRead := copy(buff, entry.Content[offset:]) |
||||
|
glog.V(4).Infof("file handle read cached %s [%d,%d] %d", fileFullPath, offset, offset+int64(totalRead), totalRead) |
||||
|
return int64(totalRead), nil |
||||
|
} |
||||
|
|
||||
|
var chunkResolveErr error |
||||
|
if fh.entryViewCache == nil { |
||||
|
fh.entryViewCache, chunkResolveErr = filer.NonOverlappingVisibleIntervals(fh.wfs.LookupFn(), entry.Chunks, 0, math.MaxInt64) |
||||
|
if chunkResolveErr != nil { |
||||
|
return 0, fmt.Errorf("fail to resolve chunk manifest: %v", chunkResolveErr) |
||||
|
} |
||||
|
fh.reader = nil |
||||
|
} |
||||
|
|
||||
|
reader := fh.reader |
||||
|
if reader == nil { |
||||
|
chunkViews := filer.ViewFromVisibleIntervals(fh.entryViewCache, 0, math.MaxInt64) |
||||
|
glog.V(4).Infof("file handle read %s [%d,%d) from %d views", fileFullPath, offset, offset+int64(len(buff)), len(chunkViews)) |
||||
|
for _, chunkView := range chunkViews { |
||||
|
glog.V(4).Infof(" read %s [%d,%d) from chunk %+v", fileFullPath, chunkView.LogicOffset, chunkView.LogicOffset+int64(chunkView.Size), chunkView.FileId) |
||||
|
} |
||||
|
reader = filer.NewChunkReaderAtFromClient(fh.wfs.LookupFn(), chunkViews, fh.wfs.chunkCache, fileSize) |
||||
|
} |
||||
|
fh.reader = reader |
||||
|
|
||||
|
totalRead, err := reader.ReadAt(buff, offset) |
||||
|
|
||||
|
if err != nil && err != io.EOF { |
||||
|
glog.Errorf("file handle read %s: %v", fileFullPath, err) |
||||
|
} |
||||
|
|
||||
|
glog.V(4).Infof("file handle read %s [%d,%d] %d : %v", fileFullPath, offset, offset+int64(totalRead), totalRead, err) |
||||
|
|
||||
|
return int64(totalRead), err |
||||
|
} |
||||
|
|
||||
|
func (fh *FileHandle) downloadRemoteEntry(entry *filer_pb.Entry) (*filer_pb.Entry, error) { |
||||
|
|
||||
|
fileFullPath := fh.FullPath() |
||||
|
dir, _ := fileFullPath.DirAndName() |
||||
|
|
||||
|
err := fh.wfs.WithFilerClient(false, func(client filer_pb.SeaweedFilerClient) error { |
||||
|
|
||||
|
request := &filer_pb.CacheRemoteObjectToLocalClusterRequest{ |
||||
|
Directory: string(dir), |
||||
|
Name: entry.Name, |
||||
|
} |
||||
|
|
||||
|
glog.V(4).Infof("download entry: %v", request) |
||||
|
resp, err := client.CacheRemoteObjectToLocalCluster(context.Background(), request) |
||||
|
if err != nil { |
||||
|
return fmt.Errorf("CacheRemoteObjectToLocalCluster file %s: %v", fileFullPath, err) |
||||
|
} |
||||
|
|
||||
|
entry = resp.Entry |
||||
|
|
||||
|
fh.wfs.metaCache.InsertEntry(context.Background(), filer.FromPbEntry(request.Directory, resp.Entry)) |
||||
|
|
||||
|
return nil |
||||
|
}) |
||||
|
|
||||
|
return entry, err |
||||
|
} |
||||
@ -0,0 +1,161 @@ |
|||||
|
package mount |
||||
|
|
||||
|
import ( |
||||
|
"github.com/chrislusf/seaweedfs/weed/glog" |
||||
|
"github.com/chrislusf/seaweedfs/weed/util" |
||||
|
"sync" |
||||
|
) |
||||
|
|
||||
|
type InodeToPath struct { |
||||
|
sync.RWMutex |
||||
|
nextInodeId uint64 |
||||
|
inode2path map[uint64]*InodeEntry |
||||
|
path2inode map[util.FullPath]uint64 |
||||
|
} |
||||
|
type InodeEntry struct { |
||||
|
util.FullPath |
||||
|
nlookup uint64 |
||||
|
isDirectory bool |
||||
|
isChildrenCached bool |
||||
|
} |
||||
|
|
||||
|
func NewInodeToPath() *InodeToPath { |
||||
|
t := &InodeToPath{ |
||||
|
inode2path: make(map[uint64]*InodeEntry), |
||||
|
path2inode: make(map[util.FullPath]uint64), |
||||
|
nextInodeId: 2, // the root inode id is 1
|
||||
|
} |
||||
|
t.inode2path[1] = &InodeEntry{"/", 1, true, false} |
||||
|
t.path2inode["/"] = 1 |
||||
|
return t |
||||
|
} |
||||
|
|
||||
|
func (i *InodeToPath) Lookup(path util.FullPath, isDirectory bool) uint64 { |
||||
|
i.Lock() |
||||
|
defer i.Unlock() |
||||
|
inode, found := i.path2inode[path] |
||||
|
if !found { |
||||
|
inode = i.nextInodeId |
||||
|
i.nextInodeId++ |
||||
|
i.path2inode[path] = inode |
||||
|
i.inode2path[inode] = &InodeEntry{path, 1, isDirectory, false} |
||||
|
} else { |
||||
|
i.inode2path[inode].nlookup++ |
||||
|
} |
||||
|
return inode |
||||
|
} |
||||
|
|
||||
|
func (i *InodeToPath) GetInode(path util.FullPath) uint64 { |
||||
|
if path == "/" { |
||||
|
return 1 |
||||
|
} |
||||
|
i.Lock() |
||||
|
defer i.Unlock() |
||||
|
inode, found := i.path2inode[path] |
||||
|
if !found { |
||||
|
// glog.Fatalf("GetInode unknown inode for %s", path)
|
||||
|
// this could be the parent for mount point
|
||||
|
} |
||||
|
return inode |
||||
|
} |
||||
|
|
||||
|
func (i *InodeToPath) GetPath(inode uint64) util.FullPath { |
||||
|
i.RLock() |
||||
|
defer i.RUnlock() |
||||
|
path, found := i.inode2path[inode] |
||||
|
if !found { |
||||
|
glog.Fatalf("not found inode %d", inode) |
||||
|
} |
||||
|
return path.FullPath |
||||
|
} |
||||
|
|
||||
|
func (i *InodeToPath) HasPath(path util.FullPath) bool { |
||||
|
i.RLock() |
||||
|
defer i.RUnlock() |
||||
|
_, found := i.path2inode[path] |
||||
|
return found |
||||
|
} |
||||
|
|
||||
|
func (i *InodeToPath) MarkChildrenCached(fullpath util.FullPath) { |
||||
|
i.RLock() |
||||
|
defer i.RUnlock() |
||||
|
inode, found := i.path2inode[fullpath] |
||||
|
if !found { |
||||
|
glog.Fatalf("MarkChildrenCached not found inode %v", fullpath) |
||||
|
} |
||||
|
path, found := i.inode2path[inode] |
||||
|
path.isChildrenCached = true |
||||
|
} |
||||
|
|
||||
|
func (i *InodeToPath) IsChildrenCached(fullpath util.FullPath) bool { |
||||
|
i.RLock() |
||||
|
defer i.RUnlock() |
||||
|
inode, found := i.path2inode[fullpath] |
||||
|
if !found { |
||||
|
return false |
||||
|
} |
||||
|
path, found := i.inode2path[inode] |
||||
|
if found { |
||||
|
return path.isChildrenCached |
||||
|
} |
||||
|
return false |
||||
|
} |
||||
|
|
||||
|
func (i *InodeToPath) HasInode(inode uint64) bool { |
||||
|
if inode == 1 { |
||||
|
return true |
||||
|
} |
||||
|
i.RLock() |
||||
|
defer i.RUnlock() |
||||
|
_, found := i.inode2path[inode] |
||||
|
return found |
||||
|
} |
||||
|
|
||||
|
func (i *InodeToPath) RemovePath(path util.FullPath) { |
||||
|
i.Lock() |
||||
|
defer i.Unlock() |
||||
|
inode, found := i.path2inode[path] |
||||
|
if found { |
||||
|
delete(i.path2inode, path) |
||||
|
delete(i.inode2path, inode) |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
func (i *InodeToPath) MovePath(sourcePath, targetPath util.FullPath) { |
||||
|
i.Lock() |
||||
|
defer i.Unlock() |
||||
|
sourceInode, sourceFound := i.path2inode[sourcePath] |
||||
|
targetInode, targetFound := i.path2inode[targetPath] |
||||
|
if sourceFound { |
||||
|
delete(i.path2inode, sourcePath) |
||||
|
i.path2inode[targetPath] = sourceInode |
||||
|
} else { |
||||
|
// it is possible some source folder items has not been visited before
|
||||
|
// so no need to worry about their source inodes
|
||||
|
return |
||||
|
} |
||||
|
i.inode2path[sourceInode].FullPath = targetPath |
||||
|
if targetFound { |
||||
|
delete(i.inode2path, targetInode) |
||||
|
} else { |
||||
|
i.inode2path[sourceInode].nlookup++ |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
func (i *InodeToPath) Forget(inode, nlookup uint64, onForgetDir func(dir util.FullPath)) { |
||||
|
i.Lock() |
||||
|
path, found := i.inode2path[inode] |
||||
|
if found { |
||||
|
path.nlookup -= nlookup |
||||
|
if path.nlookup <= 0 { |
||||
|
delete(i.path2inode, path.FullPath) |
||||
|
delete(i.inode2path, inode) |
||||
|
} |
||||
|
} |
||||
|
i.Unlock() |
||||
|
if found { |
||||
|
if path.isDirectory && onForgetDir != nil { |
||||
|
onForgetDir(path.FullPath) |
||||
|
} |
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,32 @@ |
|||||
|
package meta_cache |
||||
|
|
||||
|
import "github.com/chrislusf/seaweedfs/weed/util" |
||||
|
|
||||
|
var ( |
||||
|
_ = util.Configuration(&cacheConfig{}) |
||||
|
) |
||||
|
|
||||
|
// implementing util.Configuraion
|
||||
|
type cacheConfig struct { |
||||
|
dir string |
||||
|
} |
||||
|
|
||||
|
func (c cacheConfig) GetString(key string) string { |
||||
|
return c.dir |
||||
|
} |
||||
|
|
||||
|
func (c cacheConfig) GetBool(key string) bool { |
||||
|
panic("implement me") |
||||
|
} |
||||
|
|
||||
|
func (c cacheConfig) GetInt(key string) int { |
||||
|
panic("implement me") |
||||
|
} |
||||
|
|
||||
|
func (c cacheConfig) GetStringSlice(key string) []string { |
||||
|
panic("implement me") |
||||
|
} |
||||
|
|
||||
|
func (c cacheConfig) SetDefault(key string, value interface{}) { |
||||
|
panic("implement me") |
||||
|
} |
||||
@ -0,0 +1,101 @@ |
|||||
|
package meta_cache |
||||
|
|
||||
|
import ( |
||||
|
"fmt" |
||||
|
"strconv" |
||||
|
"strings" |
||||
|
) |
||||
|
|
||||
|
type UidGidMapper struct { |
||||
|
uidMapper *IdMapper |
||||
|
gidMapper *IdMapper |
||||
|
} |
||||
|
|
||||
|
type IdMapper struct { |
||||
|
localToFiler map[uint32]uint32 |
||||
|
filerToLocal map[uint32]uint32 |
||||
|
} |
||||
|
|
||||
|
// UidGidMapper translates local uid/gid to filer uid/gid
|
||||
|
// The local storage always persists the same as the filer.
|
||||
|
// The local->filer translation happens when updating the filer first and later saving to meta_cache.
|
||||
|
// And filer->local happens when reading from the meta_cache.
|
||||
|
func NewUidGidMapper(uidPairsStr, gidPairStr string) (*UidGidMapper, error) { |
||||
|
uidMapper, err := newIdMapper(uidPairsStr) |
||||
|
if err != nil { |
||||
|
return nil, err |
||||
|
} |
||||
|
gidMapper, err := newIdMapper(gidPairStr) |
||||
|
if err != nil { |
||||
|
return nil, err |
||||
|
} |
||||
|
|
||||
|
return &UidGidMapper{ |
||||
|
uidMapper: uidMapper, |
||||
|
gidMapper: gidMapper, |
||||
|
}, nil |
||||
|
} |
||||
|
|
||||
|
func (m *UidGidMapper) LocalToFiler(uid, gid uint32) (uint32, uint32) { |
||||
|
return m.uidMapper.LocalToFiler(uid), m.gidMapper.LocalToFiler(gid) |
||||
|
} |
||||
|
func (m *UidGidMapper) FilerToLocal(uid, gid uint32) (uint32, uint32) { |
||||
|
return m.uidMapper.FilerToLocal(uid), m.gidMapper.FilerToLocal(gid) |
||||
|
} |
||||
|
|
||||
|
func (m *IdMapper) LocalToFiler(id uint32) uint32 { |
||||
|
value, found := m.localToFiler[id] |
||||
|
if found { |
||||
|
return value |
||||
|
} |
||||
|
return id |
||||
|
} |
||||
|
func (m *IdMapper) FilerToLocal(id uint32) uint32 { |
||||
|
value, found := m.filerToLocal[id] |
||||
|
if found { |
||||
|
return value |
||||
|
} |
||||
|
return id |
||||
|
} |
||||
|
|
||||
|
func newIdMapper(pairsStr string) (*IdMapper, error) { |
||||
|
|
||||
|
localToFiler, filerToLocal, err := parseUint32Pairs(pairsStr) |
||||
|
if err != nil { |
||||
|
return nil, err |
||||
|
} |
||||
|
|
||||
|
return &IdMapper{ |
||||
|
localToFiler: localToFiler, |
||||
|
filerToLocal: filerToLocal, |
||||
|
}, nil |
||||
|
|
||||
|
} |
||||
|
|
||||
|
func parseUint32Pairs(pairsStr string) (localToFiler, filerToLocal map[uint32]uint32, err error) { |
||||
|
|
||||
|
if pairsStr == "" { |
||||
|
return |
||||
|
} |
||||
|
|
||||
|
localToFiler = make(map[uint32]uint32) |
||||
|
filerToLocal = make(map[uint32]uint32) |
||||
|
for _, pairStr := range strings.Split(pairsStr, ",") { |
||||
|
pair := strings.Split(pairStr, ":") |
||||
|
localUidStr, filerUidStr := pair[0], pair[1] |
||||
|
localUid, localUidErr := strconv.Atoi(localUidStr) |
||||
|
if localUidErr != nil { |
||||
|
err = fmt.Errorf("failed to parse local %s: %v", localUidStr, localUidErr) |
||||
|
return |
||||
|
} |
||||
|
filerUid, filerUidErr := strconv.Atoi(filerUidStr) |
||||
|
if filerUidErr != nil { |
||||
|
err = fmt.Errorf("failed to parse remote %s: %v", filerUidStr, filerUidErr) |
||||
|
return |
||||
|
} |
||||
|
localToFiler[uint32(localUid)] = uint32(filerUid) |
||||
|
filerToLocal[uint32(filerUid)] = uint32(localUid) |
||||
|
} |
||||
|
|
||||
|
return |
||||
|
} |
||||
@ -0,0 +1,160 @@ |
|||||
|
package meta_cache |
||||
|
|
||||
|
import ( |
||||
|
"context" |
||||
|
"github.com/chrislusf/seaweedfs/weed/filer" |
||||
|
"github.com/chrislusf/seaweedfs/weed/filer/leveldb" |
||||
|
"github.com/chrislusf/seaweedfs/weed/glog" |
||||
|
"github.com/chrislusf/seaweedfs/weed/pb/filer_pb" |
||||
|
"github.com/chrislusf/seaweedfs/weed/util" |
||||
|
"os" |
||||
|
) |
||||
|
|
||||
|
// need to have logic similar to FilerStoreWrapper
|
||||
|
// e.g. fill fileId field for chunks
|
||||
|
|
||||
|
type MetaCache struct { |
||||
|
localStore filer.VirtualFilerStore |
||||
|
// sync.RWMutex
|
||||
|
uidGidMapper *UidGidMapper |
||||
|
markCachedFn func(fullpath util.FullPath) |
||||
|
isCachedFn func(fullpath util.FullPath) bool |
||||
|
invalidateFunc func(fullpath util.FullPath, entry *filer_pb.Entry) |
||||
|
} |
||||
|
|
||||
|
func NewMetaCache(dbFolder string, uidGidMapper *UidGidMapper, markCachedFn func(path util.FullPath), isCachedFn func(path util.FullPath) bool, invalidateFunc func(util.FullPath, *filer_pb.Entry)) *MetaCache { |
||||
|
return &MetaCache{ |
||||
|
localStore: openMetaStore(dbFolder), |
||||
|
markCachedFn: markCachedFn, |
||||
|
isCachedFn: isCachedFn, |
||||
|
uidGidMapper: uidGidMapper, |
||||
|
invalidateFunc: func(fullpath util.FullPath, entry *filer_pb.Entry) { |
||||
|
invalidateFunc(fullpath, entry) |
||||
|
}, |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
func openMetaStore(dbFolder string) filer.VirtualFilerStore { |
||||
|
|
||||
|
os.RemoveAll(dbFolder) |
||||
|
os.MkdirAll(dbFolder, 0755) |
||||
|
|
||||
|
store := &leveldb.LevelDBStore{} |
||||
|
config := &cacheConfig{ |
||||
|
dir: dbFolder, |
||||
|
} |
||||
|
|
||||
|
if err := store.Initialize(config, ""); err != nil { |
||||
|
glog.Fatalf("Failed to initialize metadata cache store for %s: %+v", store.GetName(), err) |
||||
|
} |
||||
|
|
||||
|
return filer.NewFilerStoreWrapper(store) |
||||
|
|
||||
|
} |
||||
|
|
||||
|
func (mc *MetaCache) InsertEntry(ctx context.Context, entry *filer.Entry) error { |
||||
|
//mc.Lock()
|
||||
|
//defer mc.Unlock()
|
||||
|
return mc.doInsertEntry(ctx, entry) |
||||
|
} |
||||
|
|
||||
|
func (mc *MetaCache) doInsertEntry(ctx context.Context, entry *filer.Entry) error { |
||||
|
return mc.localStore.InsertEntry(ctx, entry) |
||||
|
} |
||||
|
|
||||
|
func (mc *MetaCache) AtomicUpdateEntryFromFiler(ctx context.Context, oldPath util.FullPath, newEntry *filer.Entry) error { |
||||
|
//mc.Lock()
|
||||
|
//defer mc.Unlock()
|
||||
|
|
||||
|
oldDir, _ := oldPath.DirAndName() |
||||
|
if mc.isCachedFn(util.FullPath(oldDir)) { |
||||
|
if oldPath != "" { |
||||
|
if newEntry != nil && oldPath == newEntry.FullPath { |
||||
|
// skip the unnecessary deletion
|
||||
|
// leave the update to the following InsertEntry operation
|
||||
|
} else { |
||||
|
glog.V(3).Infof("DeleteEntry %s", oldPath) |
||||
|
if err := mc.localStore.DeleteEntry(ctx, oldPath); err != nil { |
||||
|
return err |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
} else { |
||||
|
// println("unknown old directory:", oldDir)
|
||||
|
} |
||||
|
|
||||
|
if newEntry != nil { |
||||
|
newDir, _ := newEntry.DirAndName() |
||||
|
if mc.isCachedFn(util.FullPath(newDir)) { |
||||
|
glog.V(3).Infof("InsertEntry %s/%s", newDir, newEntry.Name()) |
||||
|
if err := mc.localStore.InsertEntry(ctx, newEntry); err != nil { |
||||
|
return err |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
return nil |
||||
|
} |
||||
|
|
||||
|
func (mc *MetaCache) UpdateEntry(ctx context.Context, entry *filer.Entry) error { |
||||
|
//mc.Lock()
|
||||
|
//defer mc.Unlock()
|
||||
|
return mc.localStore.UpdateEntry(ctx, entry) |
||||
|
} |
||||
|
|
||||
|
func (mc *MetaCache) FindEntry(ctx context.Context, fp util.FullPath) (entry *filer.Entry, err error) { |
||||
|
//mc.RLock()
|
||||
|
//defer mc.RUnlock()
|
||||
|
entry, err = mc.localStore.FindEntry(ctx, fp) |
||||
|
if err != nil { |
||||
|
return nil, err |
||||
|
} |
||||
|
mc.mapIdFromFilerToLocal(entry) |
||||
|
return |
||||
|
} |
||||
|
|
||||
|
func (mc *MetaCache) DeleteEntry(ctx context.Context, fp util.FullPath) (err error) { |
||||
|
//mc.Lock()
|
||||
|
//defer mc.Unlock()
|
||||
|
return mc.localStore.DeleteEntry(ctx, fp) |
||||
|
} |
||||
|
func (mc *MetaCache) DeleteFolderChildren(ctx context.Context, fp util.FullPath) (err error) { |
||||
|
//mc.Lock()
|
||||
|
//defer mc.Unlock()
|
||||
|
return mc.localStore.DeleteFolderChildren(ctx, fp) |
||||
|
} |
||||
|
|
||||
|
func (mc *MetaCache) ListDirectoryEntries(ctx context.Context, dirPath util.FullPath, startFileName string, includeStartFile bool, limit int64, eachEntryFunc filer.ListEachEntryFunc) error { |
||||
|
//mc.RLock()
|
||||
|
//defer mc.RUnlock()
|
||||
|
|
||||
|
if !mc.isCachedFn(dirPath) { |
||||
|
// if this request comes after renaming, it should be fine
|
||||
|
glog.Warningf("unsynchronized dir: %v", dirPath) |
||||
|
} |
||||
|
|
||||
|
_, err := mc.localStore.ListDirectoryEntries(ctx, dirPath, startFileName, includeStartFile, limit, func(entry *filer.Entry) bool { |
||||
|
mc.mapIdFromFilerToLocal(entry) |
||||
|
return eachEntryFunc(entry) |
||||
|
}) |
||||
|
if err != nil { |
||||
|
return err |
||||
|
} |
||||
|
return err |
||||
|
} |
||||
|
|
||||
|
func (mc *MetaCache) Shutdown() { |
||||
|
//mc.Lock()
|
||||
|
//defer mc.Unlock()
|
||||
|
mc.localStore.Shutdown() |
||||
|
} |
||||
|
|
||||
|
func (mc *MetaCache) mapIdFromFilerToLocal(entry *filer.Entry) { |
||||
|
entry.Attr.Uid, entry.Attr.Gid = mc.uidGidMapper.FilerToLocal(entry.Attr.Uid, entry.Attr.Gid) |
||||
|
} |
||||
|
|
||||
|
func (mc *MetaCache) Debug() { |
||||
|
if debuggable, ok := mc.localStore.(filer.Debuggable); ok { |
||||
|
println("start debugging") |
||||
|
debuggable.Debug(os.Stderr) |
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,67 @@ |
|||||
|
package meta_cache |
||||
|
|
||||
|
import ( |
||||
|
"context" |
||||
|
"fmt" |
||||
|
|
||||
|
"github.com/chrislusf/seaweedfs/weed/filer" |
||||
|
"github.com/chrislusf/seaweedfs/weed/glog" |
||||
|
"github.com/chrislusf/seaweedfs/weed/pb/filer_pb" |
||||
|
"github.com/chrislusf/seaweedfs/weed/util" |
||||
|
) |
||||
|
|
||||
|
func EnsureVisited(mc *MetaCache, client filer_pb.FilerClient, dirPath util.FullPath) error { |
||||
|
|
||||
|
for { |
||||
|
|
||||
|
// the directory children are already cached
|
||||
|
// so no need for this and upper directories
|
||||
|
if mc.isCachedFn(dirPath) { |
||||
|
return nil |
||||
|
} |
||||
|
|
||||
|
if err := doEnsureVisited(mc, client, dirPath); err != nil { |
||||
|
return err |
||||
|
} |
||||
|
|
||||
|
// continue to parent directory
|
||||
|
if dirPath != "/" { |
||||
|
parent, _ := dirPath.DirAndName() |
||||
|
dirPath = util.FullPath(parent) |
||||
|
} else { |
||||
|
break |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
return nil |
||||
|
|
||||
|
} |
||||
|
|
||||
|
func doEnsureVisited(mc *MetaCache, client filer_pb.FilerClient, path util.FullPath) error { |
||||
|
|
||||
|
glog.V(4).Infof("ReadDirAllEntries %s ...", path) |
||||
|
|
||||
|
err := util.Retry("ReadDirAllEntries", func() error { |
||||
|
return filer_pb.ReadDirAllEntries(client, path, "", func(pbEntry *filer_pb.Entry, isLast bool) error { |
||||
|
entry := filer.FromPbEntry(string(path), pbEntry) |
||||
|
if IsHiddenSystemEntry(string(path), entry.Name()) { |
||||
|
return nil |
||||
|
} |
||||
|
if err := mc.doInsertEntry(context.Background(), entry); err != nil { |
||||
|
glog.V(0).Infof("read %s: %v", entry.FullPath, err) |
||||
|
return err |
||||
|
} |
||||
|
return nil |
||||
|
}) |
||||
|
}) |
||||
|
|
||||
|
if err != nil { |
||||
|
err = fmt.Errorf("list %s: %v", path, err) |
||||
|
} |
||||
|
mc.markCachedFn(path) |
||||
|
return err |
||||
|
} |
||||
|
|
||||
|
func IsHiddenSystemEntry(dir, name string) bool { |
||||
|
return dir == "/" && (name == "topics" || name == "etc") |
||||
|
} |
||||
@ -0,0 +1,68 @@ |
|||||
|
package meta_cache |
||||
|
|
||||
|
import ( |
||||
|
"context" |
||||
|
"github.com/chrislusf/seaweedfs/weed/filer" |
||||
|
"github.com/chrislusf/seaweedfs/weed/glog" |
||||
|
"github.com/chrislusf/seaweedfs/weed/pb" |
||||
|
"github.com/chrislusf/seaweedfs/weed/pb/filer_pb" |
||||
|
"github.com/chrislusf/seaweedfs/weed/util" |
||||
|
) |
||||
|
|
||||
|
func SubscribeMetaEvents(mc *MetaCache, selfSignature int32, client filer_pb.FilerClient, dir string, lastTsNs int64) error { |
||||
|
|
||||
|
processEventFn := func(resp *filer_pb.SubscribeMetadataResponse) error { |
||||
|
message := resp.EventNotification |
||||
|
|
||||
|
for _, sig := range message.Signatures { |
||||
|
if sig == selfSignature && selfSignature != 0 { |
||||
|
return nil |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
dir := resp.Directory |
||||
|
var oldPath util.FullPath |
||||
|
var newEntry *filer.Entry |
||||
|
if message.OldEntry != nil { |
||||
|
oldPath = util.NewFullPath(dir, message.OldEntry.Name) |
||||
|
glog.V(4).Infof("deleting %v", oldPath) |
||||
|
} |
||||
|
|
||||
|
if message.NewEntry != nil { |
||||
|
if message.NewParentPath != "" { |
||||
|
dir = message.NewParentPath |
||||
|
} |
||||
|
key := util.NewFullPath(dir, message.NewEntry.Name) |
||||
|
glog.V(4).Infof("creating %v", key) |
||||
|
newEntry = filer.FromPbEntry(dir, message.NewEntry) |
||||
|
} |
||||
|
err := mc.AtomicUpdateEntryFromFiler(context.Background(), oldPath, newEntry) |
||||
|
if err == nil { |
||||
|
if message.OldEntry != nil && message.NewEntry != nil { |
||||
|
oldKey := util.NewFullPath(resp.Directory, message.OldEntry.Name) |
||||
|
mc.invalidateFunc(oldKey, message.OldEntry) |
||||
|
if message.OldEntry.Name != message.NewEntry.Name { |
||||
|
newKey := util.NewFullPath(dir, message.NewEntry.Name) |
||||
|
mc.invalidateFunc(newKey, message.NewEntry) |
||||
|
} |
||||
|
} else if message.OldEntry == nil && message.NewEntry != nil { |
||||
|
// no need to invaalidate
|
||||
|
} else if message.OldEntry != nil && message.NewEntry == nil { |
||||
|
oldKey := util.NewFullPath(resp.Directory, message.OldEntry.Name) |
||||
|
mc.invalidateFunc(oldKey, message.OldEntry) |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
return err |
||||
|
|
||||
|
} |
||||
|
|
||||
|
util.RetryForever("followMetaUpdates", func() error { |
||||
|
return pb.WithFilerClientFollowMetadata(client, "mount", selfSignature, dir, &lastTsNs, selfSignature, processEventFn, true) |
||||
|
}, func(err error) bool { |
||||
|
glog.Errorf("follow metadata updates: %v", err) |
||||
|
return true |
||||
|
}) |
||||
|
|
||||
|
return nil |
||||
|
} |
||||
@ -0,0 +1,95 @@ |
|||||
|
package mount |
||||
|
|
||||
|
import ( |
||||
|
"github.com/chrislusf/seaweedfs/weed/filesys/page_writer" |
||||
|
"github.com/chrislusf/seaweedfs/weed/glog" |
||||
|
) |
||||
|
|
||||
|
type PageWriter struct { |
||||
|
fh *FileHandle |
||||
|
collection string |
||||
|
replication string |
||||
|
chunkSize int64 |
||||
|
|
||||
|
randomWriter page_writer.DirtyPages |
||||
|
} |
||||
|
|
||||
|
var ( |
||||
|
_ = page_writer.DirtyPages(&PageWriter{}) |
||||
|
) |
||||
|
|
||||
|
func newPageWriter(fh *FileHandle, chunkSize int64) *PageWriter { |
||||
|
pw := &PageWriter{ |
||||
|
fh: fh, |
||||
|
chunkSize: chunkSize, |
||||
|
randomWriter: newMemoryChunkPages(fh, chunkSize), |
||||
|
// randomWriter: newTempFileDirtyPages(fh.f, chunkSize),
|
||||
|
} |
||||
|
return pw |
||||
|
} |
||||
|
|
||||
|
func (pw *PageWriter) AddPage(offset int64, data []byte) { |
||||
|
|
||||
|
glog.V(4).Infof("%v AddPage [%d, %d)", pw.fh.fh, offset, offset+int64(len(data))) |
||||
|
|
||||
|
chunkIndex := offset / pw.chunkSize |
||||
|
for i := chunkIndex; len(data) > 0; i++ { |
||||
|
writeSize := min(int64(len(data)), (i+1)*pw.chunkSize-offset) |
||||
|
pw.addToOneChunk(i, offset, data[:writeSize]) |
||||
|
offset += writeSize |
||||
|
data = data[writeSize:] |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
func (pw *PageWriter) addToOneChunk(chunkIndex, offset int64, data []byte) { |
||||
|
pw.randomWriter.AddPage(offset, data) |
||||
|
} |
||||
|
|
||||
|
func (pw *PageWriter) FlushData() error { |
||||
|
return pw.randomWriter.FlushData() |
||||
|
} |
||||
|
|
||||
|
func (pw *PageWriter) ReadDirtyDataAt(data []byte, offset int64) (maxStop int64) { |
||||
|
glog.V(4).Infof("ReadDirtyDataAt %v [%d, %d)", pw.fh.fh, offset, offset+int64(len(data))) |
||||
|
|
||||
|
chunkIndex := offset / pw.chunkSize |
||||
|
for i := chunkIndex; len(data) > 0; i++ { |
||||
|
readSize := min(int64(len(data)), (i+1)*pw.chunkSize-offset) |
||||
|
|
||||
|
maxStop = pw.randomWriter.ReadDirtyDataAt(data[:readSize], offset) |
||||
|
|
||||
|
offset += readSize |
||||
|
data = data[readSize:] |
||||
|
} |
||||
|
|
||||
|
return |
||||
|
} |
||||
|
|
||||
|
func (pw *PageWriter) GetStorageOptions() (collection, replication string) { |
||||
|
return pw.randomWriter.GetStorageOptions() |
||||
|
} |
||||
|
|
||||
|
func (pw *PageWriter) LockForRead(startOffset, stopOffset int64) { |
||||
|
pw.randomWriter.LockForRead(startOffset, stopOffset) |
||||
|
} |
||||
|
|
||||
|
func (pw *PageWriter) UnlockForRead(startOffset, stopOffset int64) { |
||||
|
pw.randomWriter.UnlockForRead(startOffset, stopOffset) |
||||
|
} |
||||
|
|
||||
|
func (pw *PageWriter) Destroy() { |
||||
|
pw.randomWriter.Destroy() |
||||
|
} |
||||
|
|
||||
|
func max(x, y int64) int64 { |
||||
|
if x > y { |
||||
|
return x |
||||
|
} |
||||
|
return y |
||||
|
} |
||||
|
func min(x, y int64) int64 { |
||||
|
if x < y { |
||||
|
return x |
||||
|
} |
||||
|
return y |
||||
|
} |
||||
@ -0,0 +1,115 @@ |
|||||
|
package page_writer |
||||
|
|
||||
|
import "math" |
||||
|
|
||||
|
// ChunkWrittenInterval mark one written interval within one page chunk
|
||||
|
type ChunkWrittenInterval struct { |
||||
|
StartOffset int64 |
||||
|
stopOffset int64 |
||||
|
prev *ChunkWrittenInterval |
||||
|
next *ChunkWrittenInterval |
||||
|
} |
||||
|
|
||||
|
func (interval *ChunkWrittenInterval) Size() int64 { |
||||
|
return interval.stopOffset - interval.StartOffset |
||||
|
} |
||||
|
|
||||
|
func (interval *ChunkWrittenInterval) isComplete(chunkSize int64) bool { |
||||
|
return interval.stopOffset-interval.StartOffset == chunkSize |
||||
|
} |
||||
|
|
||||
|
// ChunkWrittenIntervalList mark written intervals within one page chunk
|
||||
|
type ChunkWrittenIntervalList struct { |
||||
|
head *ChunkWrittenInterval |
||||
|
tail *ChunkWrittenInterval |
||||
|
} |
||||
|
|
||||
|
func newChunkWrittenIntervalList() *ChunkWrittenIntervalList { |
||||
|
list := &ChunkWrittenIntervalList{ |
||||
|
head: &ChunkWrittenInterval{ |
||||
|
StartOffset: -1, |
||||
|
stopOffset: -1, |
||||
|
}, |
||||
|
tail: &ChunkWrittenInterval{ |
||||
|
StartOffset: math.MaxInt64, |
||||
|
stopOffset: math.MaxInt64, |
||||
|
}, |
||||
|
} |
||||
|
list.head.next = list.tail |
||||
|
list.tail.prev = list.head |
||||
|
return list |
||||
|
} |
||||
|
|
||||
|
func (list *ChunkWrittenIntervalList) MarkWritten(startOffset, stopOffset int64) { |
||||
|
interval := &ChunkWrittenInterval{ |
||||
|
StartOffset: startOffset, |
||||
|
stopOffset: stopOffset, |
||||
|
} |
||||
|
list.addInterval(interval) |
||||
|
} |
||||
|
|
||||
|
func (list *ChunkWrittenIntervalList) IsComplete(chunkSize int64) bool { |
||||
|
return list.size() == 1 && list.head.next.isComplete(chunkSize) |
||||
|
} |
||||
|
func (list *ChunkWrittenIntervalList) WrittenSize() (writtenByteCount int64) { |
||||
|
for t := list.head; t != nil; t = t.next { |
||||
|
writtenByteCount += t.Size() |
||||
|
} |
||||
|
return |
||||
|
} |
||||
|
|
||||
|
func (list *ChunkWrittenIntervalList) addInterval(interval *ChunkWrittenInterval) { |
||||
|
|
||||
|
p := list.head |
||||
|
for ; p.next != nil && p.next.StartOffset <= interval.StartOffset; p = p.next { |
||||
|
} |
||||
|
q := list.tail |
||||
|
for ; q.prev != nil && q.prev.stopOffset >= interval.stopOffset; q = q.prev { |
||||
|
} |
||||
|
|
||||
|
if interval.StartOffset <= p.stopOffset && q.StartOffset <= interval.stopOffset { |
||||
|
// merge p and q together
|
||||
|
p.stopOffset = q.stopOffset |
||||
|
unlinkNodesBetween(p, q.next) |
||||
|
return |
||||
|
} |
||||
|
if interval.StartOffset <= p.stopOffset { |
||||
|
// merge new interval into p
|
||||
|
p.stopOffset = interval.stopOffset |
||||
|
unlinkNodesBetween(p, q) |
||||
|
return |
||||
|
} |
||||
|
if q.StartOffset <= interval.stopOffset { |
||||
|
// merge new interval into q
|
||||
|
q.StartOffset = interval.StartOffset |
||||
|
unlinkNodesBetween(p, q) |
||||
|
return |
||||
|
} |
||||
|
|
||||
|
// add the new interval between p and q
|
||||
|
unlinkNodesBetween(p, q) |
||||
|
p.next = interval |
||||
|
interval.prev = p |
||||
|
q.prev = interval |
||||
|
interval.next = q |
||||
|
|
||||
|
} |
||||
|
|
||||
|
// unlinkNodesBetween remove all nodes after start and before stop, exclusive
|
||||
|
func unlinkNodesBetween(start *ChunkWrittenInterval, stop *ChunkWrittenInterval) { |
||||
|
if start.next == stop { |
||||
|
return |
||||
|
} |
||||
|
start.next.prev = nil |
||||
|
start.next = stop |
||||
|
stop.prev.next = nil |
||||
|
stop.prev = start |
||||
|
} |
||||
|
|
||||
|
func (list *ChunkWrittenIntervalList) size() int { |
||||
|
var count int |
||||
|
for t := list.head; t != nil; t = t.next { |
||||
|
count++ |
||||
|
} |
||||
|
return count - 2 |
||||
|
} |
||||
@ -0,0 +1,49 @@ |
|||||
|
package page_writer |
||||
|
|
||||
|
import ( |
||||
|
"github.com/stretchr/testify/assert" |
||||
|
"testing" |
||||
|
) |
||||
|
|
||||
|
func Test_PageChunkWrittenIntervalList(t *testing.T) { |
||||
|
list := newChunkWrittenIntervalList() |
||||
|
|
||||
|
assert.Equal(t, 0, list.size(), "empty list") |
||||
|
|
||||
|
list.MarkWritten(0, 5) |
||||
|
assert.Equal(t, 1, list.size(), "one interval") |
||||
|
|
||||
|
list.MarkWritten(0, 5) |
||||
|
assert.Equal(t, 1, list.size(), "duplicated interval2") |
||||
|
|
||||
|
list.MarkWritten(95, 100) |
||||
|
assert.Equal(t, 2, list.size(), "two intervals") |
||||
|
|
||||
|
list.MarkWritten(50, 60) |
||||
|
assert.Equal(t, 3, list.size(), "three intervals") |
||||
|
|
||||
|
list.MarkWritten(50, 55) |
||||
|
assert.Equal(t, 3, list.size(), "three intervals merge") |
||||
|
|
||||
|
list.MarkWritten(40, 50) |
||||
|
assert.Equal(t, 3, list.size(), "three intervals grow forward") |
||||
|
|
||||
|
list.MarkWritten(50, 65) |
||||
|
assert.Equal(t, 3, list.size(), "three intervals grow backward") |
||||
|
|
||||
|
list.MarkWritten(70, 80) |
||||
|
assert.Equal(t, 4, list.size(), "four intervals") |
||||
|
|
||||
|
list.MarkWritten(60, 70) |
||||
|
assert.Equal(t, 3, list.size(), "three intervals merged") |
||||
|
|
||||
|
list.MarkWritten(59, 71) |
||||
|
assert.Equal(t, 3, list.size(), "covered three intervals") |
||||
|
|
||||
|
list.MarkWritten(5, 59) |
||||
|
assert.Equal(t, 2, list.size(), "covered two intervals") |
||||
|
|
||||
|
list.MarkWritten(70, 99) |
||||
|
assert.Equal(t, 1, list.size(), "covered one intervals") |
||||
|
|
||||
|
} |
||||
@ -0,0 +1,30 @@ |
|||||
|
package page_writer |
||||
|
|
||||
|
type DirtyPages interface { |
||||
|
AddPage(offset int64, data []byte) |
||||
|
FlushData() error |
||||
|
ReadDirtyDataAt(data []byte, startOffset int64) (maxStop int64) |
||||
|
GetStorageOptions() (collection, replication string) |
||||
|
Destroy() |
||||
|
LockForRead(startOffset, stopOffset int64) |
||||
|
UnlockForRead(startOffset, stopOffset int64) |
||||
|
} |
||||
|
|
||||
|
func max(x, y int64) int64 { |
||||
|
if x > y { |
||||
|
return x |
||||
|
} |
||||
|
return y |
||||
|
} |
||||
|
func min(x, y int64) int64 { |
||||
|
if x < y { |
||||
|
return x |
||||
|
} |
||||
|
return y |
||||
|
} |
||||
|
func minInt(x, y int) int { |
||||
|
if x < y { |
||||
|
return x |
||||
|
} |
||||
|
return y |
||||
|
} |
||||
@ -0,0 +1,16 @@ |
|||||
|
package page_writer |
||||
|
|
||||
|
import ( |
||||
|
"io" |
||||
|
) |
||||
|
|
||||
|
type SaveToStorageFunc func(reader io.Reader, offset int64, size int64, cleanupFn func()) |
||||
|
|
||||
|
type PageChunk interface { |
||||
|
FreeResource() |
||||
|
WriteDataAt(src []byte, offset int64) (n int) |
||||
|
ReadDataAt(p []byte, off int64) (maxStop int64) |
||||
|
IsComplete() bool |
||||
|
WrittenSize() int64 |
||||
|
SaveContent(saveFn SaveToStorageFunc) |
||||
|
} |
||||
@ -0,0 +1,69 @@ |
|||||
|
package page_writer |
||||
|
|
||||
|
import ( |
||||
|
"github.com/chrislusf/seaweedfs/weed/util" |
||||
|
"github.com/chrislusf/seaweedfs/weed/util/mem" |
||||
|
) |
||||
|
|
||||
|
var ( |
||||
|
_ = PageChunk(&MemChunk{}) |
||||
|
) |
||||
|
|
||||
|
type MemChunk struct { |
||||
|
buf []byte |
||||
|
usage *ChunkWrittenIntervalList |
||||
|
chunkSize int64 |
||||
|
logicChunkIndex LogicChunkIndex |
||||
|
} |
||||
|
|
||||
|
func NewMemChunk(logicChunkIndex LogicChunkIndex, chunkSize int64) *MemChunk { |
||||
|
return &MemChunk{ |
||||
|
logicChunkIndex: logicChunkIndex, |
||||
|
chunkSize: chunkSize, |
||||
|
buf: mem.Allocate(int(chunkSize)), |
||||
|
usage: newChunkWrittenIntervalList(), |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
func (mc *MemChunk) FreeResource() { |
||||
|
mem.Free(mc.buf) |
||||
|
} |
||||
|
|
||||
|
func (mc *MemChunk) WriteDataAt(src []byte, offset int64) (n int) { |
||||
|
innerOffset := offset % mc.chunkSize |
||||
|
n = copy(mc.buf[innerOffset:], src) |
||||
|
mc.usage.MarkWritten(innerOffset, innerOffset+int64(n)) |
||||
|
return |
||||
|
} |
||||
|
|
||||
|
func (mc *MemChunk) ReadDataAt(p []byte, off int64) (maxStop int64) { |
||||
|
memChunkBaseOffset := int64(mc.logicChunkIndex) * mc.chunkSize |
||||
|
for t := mc.usage.head.next; t != mc.usage.tail; t = t.next { |
||||
|
logicStart := max(off, int64(mc.logicChunkIndex)*mc.chunkSize+t.StartOffset) |
||||
|
logicStop := min(off+int64(len(p)), memChunkBaseOffset+t.stopOffset) |
||||
|
if logicStart < logicStop { |
||||
|
copy(p[logicStart-off:logicStop-off], mc.buf[logicStart-memChunkBaseOffset:logicStop-memChunkBaseOffset]) |
||||
|
maxStop = max(maxStop, logicStop) |
||||
|
} |
||||
|
} |
||||
|
return |
||||
|
} |
||||
|
|
||||
|
func (mc *MemChunk) IsComplete() bool { |
||||
|
return mc.usage.IsComplete(mc.chunkSize) |
||||
|
} |
||||
|
|
||||
|
func (mc *MemChunk) WrittenSize() int64 { |
||||
|
return mc.usage.WrittenSize() |
||||
|
} |
||||
|
|
||||
|
func (mc *MemChunk) SaveContent(saveFn SaveToStorageFunc) { |
||||
|
if saveFn == nil { |
||||
|
return |
||||
|
} |
||||
|
for t := mc.usage.head.next; t != mc.usage.tail; t = t.next { |
||||
|
reader := util.NewBytesReader(mc.buf[t.StartOffset:t.stopOffset]) |
||||
|
saveFn(reader, int64(mc.logicChunkIndex)*mc.chunkSize+t.StartOffset, t.Size(), func() { |
||||
|
}) |
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,121 @@ |
|||||
|
package page_writer |
||||
|
|
||||
|
import ( |
||||
|
"github.com/chrislusf/seaweedfs/weed/glog" |
||||
|
"github.com/chrislusf/seaweedfs/weed/util" |
||||
|
"github.com/chrislusf/seaweedfs/weed/util/mem" |
||||
|
"os" |
||||
|
) |
||||
|
|
||||
|
var ( |
||||
|
_ = PageChunk(&SwapFileChunk{}) |
||||
|
) |
||||
|
|
||||
|
type ActualChunkIndex int |
||||
|
|
||||
|
type SwapFile struct { |
||||
|
dir string |
||||
|
file *os.File |
||||
|
logicToActualChunkIndex map[LogicChunkIndex]ActualChunkIndex |
||||
|
chunkSize int64 |
||||
|
} |
||||
|
|
||||
|
type SwapFileChunk struct { |
||||
|
swapfile *SwapFile |
||||
|
usage *ChunkWrittenIntervalList |
||||
|
logicChunkIndex LogicChunkIndex |
||||
|
actualChunkIndex ActualChunkIndex |
||||
|
} |
||||
|
|
||||
|
func NewSwapFile(dir string, chunkSize int64) *SwapFile { |
||||
|
return &SwapFile{ |
||||
|
dir: dir, |
||||
|
file: nil, |
||||
|
logicToActualChunkIndex: make(map[LogicChunkIndex]ActualChunkIndex), |
||||
|
chunkSize: chunkSize, |
||||
|
} |
||||
|
} |
||||
|
func (sf *SwapFile) FreeResource() { |
||||
|
if sf.file != nil { |
||||
|
sf.file.Close() |
||||
|
os.Remove(sf.file.Name()) |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
func (sf *SwapFile) NewTempFileChunk(logicChunkIndex LogicChunkIndex) (tc *SwapFileChunk) { |
||||
|
if sf.file == nil { |
||||
|
var err error |
||||
|
sf.file, err = os.CreateTemp(sf.dir, "") |
||||
|
if err != nil { |
||||
|
glog.Errorf("create swap file: %v", err) |
||||
|
return nil |
||||
|
} |
||||
|
} |
||||
|
actualChunkIndex, found := sf.logicToActualChunkIndex[logicChunkIndex] |
||||
|
if !found { |
||||
|
actualChunkIndex = ActualChunkIndex(len(sf.logicToActualChunkIndex)) |
||||
|
sf.logicToActualChunkIndex[logicChunkIndex] = actualChunkIndex |
||||
|
} |
||||
|
|
||||
|
return &SwapFileChunk{ |
||||
|
swapfile: sf, |
||||
|
usage: newChunkWrittenIntervalList(), |
||||
|
logicChunkIndex: logicChunkIndex, |
||||
|
actualChunkIndex: actualChunkIndex, |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
func (sc *SwapFileChunk) FreeResource() { |
||||
|
} |
||||
|
|
||||
|
func (sc *SwapFileChunk) WriteDataAt(src []byte, offset int64) (n int) { |
||||
|
innerOffset := offset % sc.swapfile.chunkSize |
||||
|
var err error |
||||
|
n, err = sc.swapfile.file.WriteAt(src, int64(sc.actualChunkIndex)*sc.swapfile.chunkSize+innerOffset) |
||||
|
if err == nil { |
||||
|
sc.usage.MarkWritten(innerOffset, innerOffset+int64(n)) |
||||
|
} else { |
||||
|
glog.Errorf("failed to write swap file %s: %v", sc.swapfile.file.Name(), err) |
||||
|
} |
||||
|
return |
||||
|
} |
||||
|
|
||||
|
func (sc *SwapFileChunk) ReadDataAt(p []byte, off int64) (maxStop int64) { |
||||
|
chunkStartOffset := int64(sc.logicChunkIndex) * sc.swapfile.chunkSize |
||||
|
for t := sc.usage.head.next; t != sc.usage.tail; t = t.next { |
||||
|
logicStart := max(off, chunkStartOffset+t.StartOffset) |
||||
|
logicStop := min(off+int64(len(p)), chunkStartOffset+t.stopOffset) |
||||
|
if logicStart < logicStop { |
||||
|
actualStart := logicStart - chunkStartOffset + int64(sc.actualChunkIndex)*sc.swapfile.chunkSize |
||||
|
if _, err := sc.swapfile.file.ReadAt(p[logicStart-off:logicStop-off], actualStart); err != nil { |
||||
|
glog.Errorf("failed to reading swap file %s: %v", sc.swapfile.file.Name(), err) |
||||
|
break |
||||
|
} |
||||
|
maxStop = max(maxStop, logicStop) |
||||
|
} |
||||
|
} |
||||
|
return |
||||
|
} |
||||
|
|
||||
|
func (sc *SwapFileChunk) IsComplete() bool { |
||||
|
return sc.usage.IsComplete(sc.swapfile.chunkSize) |
||||
|
} |
||||
|
|
||||
|
func (sc *SwapFileChunk) WrittenSize() int64 { |
||||
|
return sc.usage.WrittenSize() |
||||
|
} |
||||
|
|
||||
|
func (sc *SwapFileChunk) SaveContent(saveFn SaveToStorageFunc) { |
||||
|
if saveFn == nil { |
||||
|
return |
||||
|
} |
||||
|
for t := sc.usage.head.next; t != sc.usage.tail; t = t.next { |
||||
|
data := mem.Allocate(int(t.Size())) |
||||
|
sc.swapfile.file.ReadAt(data, t.StartOffset+int64(sc.actualChunkIndex)*sc.swapfile.chunkSize) |
||||
|
reader := util.NewBytesReader(data) |
||||
|
saveFn(reader, int64(sc.logicChunkIndex)*sc.swapfile.chunkSize+t.StartOffset, t.Size(), func() { |
||||
|
}) |
||||
|
mem.Free(data) |
||||
|
} |
||||
|
sc.usage = newChunkWrittenIntervalList() |
||||
|
} |
||||
@ -0,0 +1,182 @@ |
|||||
|
package page_writer |
||||
|
|
||||
|
import ( |
||||
|
"fmt" |
||||
|
"github.com/chrislusf/seaweedfs/weed/glog" |
||||
|
"github.com/chrislusf/seaweedfs/weed/util" |
||||
|
"sync" |
||||
|
"sync/atomic" |
||||
|
"time" |
||||
|
) |
||||
|
|
||||
|
type LogicChunkIndex int |
||||
|
|
||||
|
type UploadPipeline struct { |
||||
|
filepath util.FullPath |
||||
|
ChunkSize int64 |
||||
|
writableChunks map[LogicChunkIndex]PageChunk |
||||
|
writableChunksLock sync.Mutex |
||||
|
sealedChunks map[LogicChunkIndex]*SealedChunk |
||||
|
sealedChunksLock sync.Mutex |
||||
|
uploaders *util.LimitedConcurrentExecutor |
||||
|
uploaderCount int32 |
||||
|
uploaderCountCond *sync.Cond |
||||
|
saveToStorageFn SaveToStorageFunc |
||||
|
activeReadChunks map[LogicChunkIndex]int |
||||
|
activeReadChunksLock sync.Mutex |
||||
|
bufferChunkLimit int |
||||
|
} |
||||
|
|
||||
|
type SealedChunk struct { |
||||
|
chunk PageChunk |
||||
|
referenceCounter int // track uploading or reading processes
|
||||
|
} |
||||
|
|
||||
|
func (sc *SealedChunk) FreeReference(messageOnFree string) { |
||||
|
sc.referenceCounter-- |
||||
|
if sc.referenceCounter == 0 { |
||||
|
glog.V(4).Infof("Free sealed chunk: %s", messageOnFree) |
||||
|
sc.chunk.FreeResource() |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
func NewUploadPipeline(writers *util.LimitedConcurrentExecutor, chunkSize int64, saveToStorageFn SaveToStorageFunc, bufferChunkLimit int) *UploadPipeline { |
||||
|
return &UploadPipeline{ |
||||
|
ChunkSize: chunkSize, |
||||
|
writableChunks: make(map[LogicChunkIndex]PageChunk), |
||||
|
sealedChunks: make(map[LogicChunkIndex]*SealedChunk), |
||||
|
uploaders: writers, |
||||
|
uploaderCountCond: sync.NewCond(&sync.Mutex{}), |
||||
|
saveToStorageFn: saveToStorageFn, |
||||
|
activeReadChunks: make(map[LogicChunkIndex]int), |
||||
|
bufferChunkLimit: bufferChunkLimit, |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
func (up *UploadPipeline) SaveDataAt(p []byte, off int64) (n int) { |
||||
|
up.writableChunksLock.Lock() |
||||
|
defer up.writableChunksLock.Unlock() |
||||
|
|
||||
|
logicChunkIndex := LogicChunkIndex(off / up.ChunkSize) |
||||
|
|
||||
|
memChunk, found := up.writableChunks[logicChunkIndex] |
||||
|
if !found { |
||||
|
if len(up.writableChunks) < up.bufferChunkLimit { |
||||
|
memChunk = NewMemChunk(logicChunkIndex, up.ChunkSize) |
||||
|
} else { |
||||
|
fullestChunkIndex, fullness := LogicChunkIndex(-1), int64(0) |
||||
|
for lci, mc := range up.writableChunks { |
||||
|
chunkFullness := mc.WrittenSize() |
||||
|
if fullness < chunkFullness { |
||||
|
fullestChunkIndex = lci |
||||
|
fullness = chunkFullness |
||||
|
} |
||||
|
} |
||||
|
up.moveToSealed(up.writableChunks[fullestChunkIndex], fullestChunkIndex) |
||||
|
delete(up.writableChunks, fullestChunkIndex) |
||||
|
fmt.Printf("flush chunk %d with %d bytes written", logicChunkIndex, fullness) |
||||
|
memChunk = NewMemChunk(logicChunkIndex, up.ChunkSize) |
||||
|
} |
||||
|
up.writableChunks[logicChunkIndex] = memChunk |
||||
|
} |
||||
|
n = memChunk.WriteDataAt(p, off) |
||||
|
up.maybeMoveToSealed(memChunk, logicChunkIndex) |
||||
|
|
||||
|
return |
||||
|
} |
||||
|
|
||||
|
func (up *UploadPipeline) MaybeReadDataAt(p []byte, off int64) (maxStop int64) { |
||||
|
logicChunkIndex := LogicChunkIndex(off / up.ChunkSize) |
||||
|
|
||||
|
// read from sealed chunks first
|
||||
|
up.sealedChunksLock.Lock() |
||||
|
sealedChunk, found := up.sealedChunks[logicChunkIndex] |
||||
|
if found { |
||||
|
sealedChunk.referenceCounter++ |
||||
|
} |
||||
|
up.sealedChunksLock.Unlock() |
||||
|
if found { |
||||
|
maxStop = sealedChunk.chunk.ReadDataAt(p, off) |
||||
|
glog.V(4).Infof("%s read sealed memchunk [%d,%d)", up.filepath, off, maxStop) |
||||
|
sealedChunk.FreeReference(fmt.Sprintf("%s finish reading chunk %d", up.filepath, logicChunkIndex)) |
||||
|
} |
||||
|
|
||||
|
// read from writable chunks last
|
||||
|
up.writableChunksLock.Lock() |
||||
|
defer up.writableChunksLock.Unlock() |
||||
|
writableChunk, found := up.writableChunks[logicChunkIndex] |
||||
|
if !found { |
||||
|
return |
||||
|
} |
||||
|
writableMaxStop := writableChunk.ReadDataAt(p, off) |
||||
|
glog.V(4).Infof("%s read writable memchunk [%d,%d)", up.filepath, off, writableMaxStop) |
||||
|
maxStop = max(maxStop, writableMaxStop) |
||||
|
|
||||
|
return |
||||
|
} |
||||
|
|
||||
|
func (up *UploadPipeline) FlushAll() { |
||||
|
up.writableChunksLock.Lock() |
||||
|
defer up.writableChunksLock.Unlock() |
||||
|
|
||||
|
for logicChunkIndex, memChunk := range up.writableChunks { |
||||
|
up.moveToSealed(memChunk, logicChunkIndex) |
||||
|
} |
||||
|
|
||||
|
up.waitForCurrentWritersToComplete() |
||||
|
} |
||||
|
|
||||
|
func (up *UploadPipeline) maybeMoveToSealed(memChunk PageChunk, logicChunkIndex LogicChunkIndex) { |
||||
|
if memChunk.IsComplete() { |
||||
|
up.moveToSealed(memChunk, logicChunkIndex) |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
func (up *UploadPipeline) moveToSealed(memChunk PageChunk, logicChunkIndex LogicChunkIndex) { |
||||
|
atomic.AddInt32(&up.uploaderCount, 1) |
||||
|
glog.V(4).Infof("%s uploaderCount %d ++> %d", up.filepath, up.uploaderCount-1, up.uploaderCount) |
||||
|
|
||||
|
up.sealedChunksLock.Lock() |
||||
|
|
||||
|
if oldMemChunk, found := up.sealedChunks[logicChunkIndex]; found { |
||||
|
oldMemChunk.FreeReference(fmt.Sprintf("%s replace chunk %d", up.filepath, logicChunkIndex)) |
||||
|
} |
||||
|
sealedChunk := &SealedChunk{ |
||||
|
chunk: memChunk, |
||||
|
referenceCounter: 1, // default 1 is for uploading process
|
||||
|
} |
||||
|
up.sealedChunks[logicChunkIndex] = sealedChunk |
||||
|
delete(up.writableChunks, logicChunkIndex) |
||||
|
|
||||
|
up.sealedChunksLock.Unlock() |
||||
|
|
||||
|
up.uploaders.Execute(func() { |
||||
|
// first add to the file chunks
|
||||
|
sealedChunk.chunk.SaveContent(up.saveToStorageFn) |
||||
|
|
||||
|
// notify waiting process
|
||||
|
atomic.AddInt32(&up.uploaderCount, -1) |
||||
|
glog.V(4).Infof("%s uploaderCount %d --> %d", up.filepath, up.uploaderCount+1, up.uploaderCount) |
||||
|
// Lock and Unlock are not required,
|
||||
|
// but it may signal multiple times during one wakeup,
|
||||
|
// and the waiting goroutine may miss some of them!
|
||||
|
up.uploaderCountCond.L.Lock() |
||||
|
up.uploaderCountCond.Broadcast() |
||||
|
up.uploaderCountCond.L.Unlock() |
||||
|
|
||||
|
// wait for readers
|
||||
|
for up.IsLocked(logicChunkIndex) { |
||||
|
time.Sleep(59 * time.Millisecond) |
||||
|
} |
||||
|
|
||||
|
// then remove from sealed chunks
|
||||
|
up.sealedChunksLock.Lock() |
||||
|
defer up.sealedChunksLock.Unlock() |
||||
|
delete(up.sealedChunks, logicChunkIndex) |
||||
|
sealedChunk.FreeReference(fmt.Sprintf("%s finished uploading chunk %d", up.filepath, logicChunkIndex)) |
||||
|
|
||||
|
}) |
||||
|
} |
||||
|
|
||||
|
func (up *UploadPipeline) Shutdown() { |
||||
|
} |
||||
@ -0,0 +1,63 @@ |
|||||
|
package page_writer |
||||
|
|
||||
|
import ( |
||||
|
"sync/atomic" |
||||
|
) |
||||
|
|
||||
|
func (up *UploadPipeline) LockForRead(startOffset, stopOffset int64) { |
||||
|
startLogicChunkIndex := LogicChunkIndex(startOffset / up.ChunkSize) |
||||
|
stopLogicChunkIndex := LogicChunkIndex(stopOffset / up.ChunkSize) |
||||
|
if stopOffset%up.ChunkSize > 0 { |
||||
|
stopLogicChunkIndex += 1 |
||||
|
} |
||||
|
up.activeReadChunksLock.Lock() |
||||
|
defer up.activeReadChunksLock.Unlock() |
||||
|
for i := startLogicChunkIndex; i < stopLogicChunkIndex; i++ { |
||||
|
if count, found := up.activeReadChunks[i]; found { |
||||
|
up.activeReadChunks[i] = count + 1 |
||||
|
} else { |
||||
|
up.activeReadChunks[i] = 1 |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
func (up *UploadPipeline) UnlockForRead(startOffset, stopOffset int64) { |
||||
|
startLogicChunkIndex := LogicChunkIndex(startOffset / up.ChunkSize) |
||||
|
stopLogicChunkIndex := LogicChunkIndex(stopOffset / up.ChunkSize) |
||||
|
if stopOffset%up.ChunkSize > 0 { |
||||
|
stopLogicChunkIndex += 1 |
||||
|
} |
||||
|
up.activeReadChunksLock.Lock() |
||||
|
defer up.activeReadChunksLock.Unlock() |
||||
|
for i := startLogicChunkIndex; i < stopLogicChunkIndex; i++ { |
||||
|
if count, found := up.activeReadChunks[i]; found { |
||||
|
if count == 1 { |
||||
|
delete(up.activeReadChunks, i) |
||||
|
} else { |
||||
|
up.activeReadChunks[i] = count - 1 |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
func (up *UploadPipeline) IsLocked(logicChunkIndex LogicChunkIndex) bool { |
||||
|
up.activeReadChunksLock.Lock() |
||||
|
defer up.activeReadChunksLock.Unlock() |
||||
|
if count, found := up.activeReadChunks[logicChunkIndex]; found { |
||||
|
return count > 0 |
||||
|
} |
||||
|
return false |
||||
|
} |
||||
|
|
||||
|
func (up *UploadPipeline) waitForCurrentWritersToComplete() { |
||||
|
up.uploaderCountCond.L.Lock() |
||||
|
t := int32(100) |
||||
|
for { |
||||
|
t = atomic.LoadInt32(&up.uploaderCount) |
||||
|
if t <= 0 { |
||||
|
break |
||||
|
} |
||||
|
up.uploaderCountCond.Wait() |
||||
|
} |
||||
|
up.uploaderCountCond.L.Unlock() |
||||
|
} |
||||
@ -0,0 +1,47 @@ |
|||||
|
package page_writer |
||||
|
|
||||
|
import ( |
||||
|
"github.com/chrislusf/seaweedfs/weed/util" |
||||
|
"testing" |
||||
|
) |
||||
|
|
||||
|
func TestUploadPipeline(t *testing.T) { |
||||
|
|
||||
|
uploadPipeline := NewUploadPipeline(nil, 2*1024*1024, nil, 16) |
||||
|
|
||||
|
writeRange(uploadPipeline, 0, 131072) |
||||
|
writeRange(uploadPipeline, 131072, 262144) |
||||
|
writeRange(uploadPipeline, 262144, 1025536) |
||||
|
|
||||
|
confirmRange(t, uploadPipeline, 0, 1025536) |
||||
|
|
||||
|
writeRange(uploadPipeline, 1025536, 1296896) |
||||
|
|
||||
|
confirmRange(t, uploadPipeline, 1025536, 1296896) |
||||
|
|
||||
|
writeRange(uploadPipeline, 1296896, 2162688) |
||||
|
|
||||
|
confirmRange(t, uploadPipeline, 1296896, 2162688) |
||||
|
|
||||
|
confirmRange(t, uploadPipeline, 1296896, 2162688) |
||||
|
} |
||||
|
|
||||
|
// startOff and stopOff must be divided by 4
|
||||
|
func writeRange(uploadPipeline *UploadPipeline, startOff, stopOff int64) { |
||||
|
p := make([]byte, 4) |
||||
|
for i := startOff / 4; i < stopOff/4; i += 4 { |
||||
|
util.Uint32toBytes(p, uint32(i)) |
||||
|
uploadPipeline.SaveDataAt(p, i) |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
func confirmRange(t *testing.T, uploadPipeline *UploadPipeline, startOff, stopOff int64) { |
||||
|
p := make([]byte, 4) |
||||
|
for i := startOff; i < stopOff/4; i += 4 { |
||||
|
uploadPipeline.MaybeReadDataAt(p, i) |
||||
|
x := util.BytesToUint32(p) |
||||
|
if x != uint32(i) { |
||||
|
t.Errorf("expecting %d found %d at offset [%d,%d)", i, x, i, i+4) |
||||
|
} |
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,6 @@ |
|||||
|
package unmount |
||||
|
|
||||
|
// Unmount tries to unmount the filesystem mounted at dir.
|
||||
|
func Unmount(dir string) error { |
||||
|
return unmount(dir) |
||||
|
} |
||||
@ -0,0 +1,21 @@ |
|||||
|
package unmount |
||||
|
|
||||
|
import ( |
||||
|
"bytes" |
||||
|
"errors" |
||||
|
"os/exec" |
||||
|
) |
||||
|
|
||||
|
func unmount(dir string) error { |
||||
|
cmd := exec.Command("fusermount", "-u", dir) |
||||
|
output, err := cmd.CombinedOutput() |
||||
|
if err != nil { |
||||
|
if len(output) > 0 { |
||||
|
output = bytes.TrimRight(output, "\n") |
||||
|
msg := err.Error() + ": " + string(output) |
||||
|
err = errors.New(msg) |
||||
|
} |
||||
|
return err |
||||
|
} |
||||
|
return nil |
||||
|
} |
||||
@ -0,0 +1,18 @@ |
|||||
|
//go:build !linux
|
||||
|
// +build !linux
|
||||
|
|
||||
|
package unmount |
||||
|
|
||||
|
import ( |
||||
|
"os" |
||||
|
"syscall" |
||||
|
) |
||||
|
|
||||
|
func unmount(dir string) error { |
||||
|
err := syscall.Unmount(dir, 0) |
||||
|
if err != nil { |
||||
|
err = &os.PathError{Op: "unmount", Path: dir, Err: err} |
||||
|
return err |
||||
|
} |
||||
|
return nil |
||||
|
} |
||||
@ -0,0 +1,187 @@ |
|||||
|
package mount |
||||
|
|
||||
|
import ( |
||||
|
"context" |
||||
|
"github.com/chrislusf/seaweedfs/weed/filer" |
||||
|
"github.com/chrislusf/seaweedfs/weed/mount/meta_cache" |
||||
|
"github.com/chrislusf/seaweedfs/weed/pb" |
||||
|
"github.com/chrislusf/seaweedfs/weed/pb/filer_pb" |
||||
|
"github.com/chrislusf/seaweedfs/weed/storage/types" |
||||
|
"github.com/chrislusf/seaweedfs/weed/util" |
||||
|
"github.com/chrislusf/seaweedfs/weed/util/chunk_cache" |
||||
|
"github.com/chrislusf/seaweedfs/weed/util/grace" |
||||
|
"github.com/chrislusf/seaweedfs/weed/wdclient" |
||||
|
"github.com/hanwen/go-fuse/v2/fuse" |
||||
|
"google.golang.org/grpc" |
||||
|
"math/rand" |
||||
|
"os" |
||||
|
"path" |
||||
|
"path/filepath" |
||||
|
"time" |
||||
|
|
||||
|
"github.com/hanwen/go-fuse/v2/fs" |
||||
|
) |
||||
|
|
||||
|
type Option struct { |
||||
|
MountDirectory string |
||||
|
FilerAddresses []pb.ServerAddress |
||||
|
filerIndex int |
||||
|
GrpcDialOption grpc.DialOption |
||||
|
FilerMountRootPath string |
||||
|
Collection string |
||||
|
Replication string |
||||
|
TtlSec int32 |
||||
|
DiskType types.DiskType |
||||
|
ChunkSizeLimit int64 |
||||
|
ConcurrentWriters int |
||||
|
CacheDir string |
||||
|
CacheSizeMB int64 |
||||
|
DataCenter string |
||||
|
Umask os.FileMode |
||||
|
|
||||
|
MountUid uint32 |
||||
|
MountGid uint32 |
||||
|
MountMode os.FileMode |
||||
|
MountCtime time.Time |
||||
|
MountMtime time.Time |
||||
|
MountParentInode uint64 |
||||
|
|
||||
|
VolumeServerAccess string // how to access volume servers
|
||||
|
Cipher bool // whether encrypt data on volume server
|
||||
|
UidGidMapper *meta_cache.UidGidMapper |
||||
|
|
||||
|
uniqueCacheDir string |
||||
|
uniqueCacheTempPageDir string |
||||
|
} |
||||
|
|
||||
|
type WFS struct { |
||||
|
// follow https://github.com/hanwen/go-fuse/blob/master/fuse/api.go
|
||||
|
fuse.RawFileSystem |
||||
|
fs.Inode |
||||
|
option *Option |
||||
|
metaCache *meta_cache.MetaCache |
||||
|
stats statsCache |
||||
|
root Directory |
||||
|
chunkCache *chunk_cache.TieredChunkCache |
||||
|
signature int32 |
||||
|
concurrentWriters *util.LimitedConcurrentExecutor |
||||
|
inodeToPath *InodeToPath |
||||
|
fhmap *FileHandleToInode |
||||
|
} |
||||
|
|
||||
|
func NewSeaweedFileSystem(option *Option) *WFS { |
||||
|
wfs := &WFS{ |
||||
|
RawFileSystem: fuse.NewDefaultRawFileSystem(), |
||||
|
option: option, |
||||
|
signature: util.RandomInt32(), |
||||
|
inodeToPath: NewInodeToPath(), |
||||
|
fhmap: NewFileHandleToInode(), |
||||
|
} |
||||
|
|
||||
|
wfs.root = Directory{ |
||||
|
name: "/", |
||||
|
wfs: wfs, |
||||
|
entry: nil, |
||||
|
parent: nil, |
||||
|
} |
||||
|
|
||||
|
wfs.option.filerIndex = rand.Intn(len(option.FilerAddresses)) |
||||
|
wfs.option.setupUniqueCacheDirectory() |
||||
|
if option.CacheSizeMB > 0 { |
||||
|
wfs.chunkCache = chunk_cache.NewTieredChunkCache(256, option.getUniqueCacheDir(), option.CacheSizeMB, 1024*1024) |
||||
|
} |
||||
|
|
||||
|
wfs.metaCache = meta_cache.NewMetaCache(path.Join(option.getUniqueCacheDir(), "meta"), option.UidGidMapper, func(path util.FullPath) { |
||||
|
wfs.inodeToPath.MarkChildrenCached(path) |
||||
|
}, func(path util.FullPath) bool { |
||||
|
return wfs.inodeToPath.IsChildrenCached(path) |
||||
|
}, func(filePath util.FullPath, entry *filer_pb.Entry) { |
||||
|
}) |
||||
|
grace.OnInterrupt(func() { |
||||
|
wfs.metaCache.Shutdown() |
||||
|
}) |
||||
|
|
||||
|
if wfs.option.ConcurrentWriters > 0 { |
||||
|
wfs.concurrentWriters = util.NewLimitedConcurrentExecutor(wfs.option.ConcurrentWriters) |
||||
|
} |
||||
|
return wfs |
||||
|
} |
||||
|
|
||||
|
func (wfs *WFS) StartBackgroundTasks() { |
||||
|
startTime := time.Now() |
||||
|
go meta_cache.SubscribeMetaEvents(wfs.metaCache, wfs.signature, wfs, wfs.option.FilerMountRootPath, startTime.UnixNano()) |
||||
|
} |
||||
|
|
||||
|
func (wfs *WFS) Root() *Directory { |
||||
|
return &wfs.root |
||||
|
} |
||||
|
|
||||
|
func (wfs *WFS) String() string { |
||||
|
return "seaweedfs" |
||||
|
} |
||||
|
|
||||
|
func (wfs *WFS) maybeReadEntry(inode uint64) (path util.FullPath, fh *FileHandle, entry *filer_pb.Entry, status fuse.Status) { |
||||
|
path = wfs.inodeToPath.GetPath(inode) |
||||
|
var found bool |
||||
|
if fh, found = wfs.fhmap.FindFileHandle(inode); found { |
||||
|
return path, fh, fh.entry, fuse.OK |
||||
|
} |
||||
|
entry, status = wfs.maybeLoadEntry(path) |
||||
|
return |
||||
|
} |
||||
|
|
||||
|
func (wfs *WFS) maybeLoadEntry(fullpath util.FullPath) (*filer_pb.Entry, fuse.Status) { |
||||
|
|
||||
|
// glog.V(3).Infof("read entry cache miss %s", fullpath)
|
||||
|
dir, name := fullpath.DirAndName() |
||||
|
|
||||
|
// return a valid entry for the mount root
|
||||
|
if string(fullpath) == wfs.option.FilerMountRootPath { |
||||
|
return &filer_pb.Entry{ |
||||
|
Name: name, |
||||
|
IsDirectory: true, |
||||
|
Attributes: &filer_pb.FuseAttributes{ |
||||
|
Mtime: wfs.option.MountMtime.Unix(), |
||||
|
FileMode: uint32(wfs.option.MountMode), |
||||
|
Uid: wfs.option.MountUid, |
||||
|
Gid: wfs.option.MountGid, |
||||
|
Crtime: wfs.option.MountCtime.Unix(), |
||||
|
}, |
||||
|
}, fuse.OK |
||||
|
} |
||||
|
|
||||
|
// read from async meta cache
|
||||
|
meta_cache.EnsureVisited(wfs.metaCache, wfs, util.FullPath(dir)) |
||||
|
cachedEntry, cacheErr := wfs.metaCache.FindEntry(context.Background(), fullpath) |
||||
|
if cacheErr == filer_pb.ErrNotFound { |
||||
|
return nil, fuse.ENOENT |
||||
|
} |
||||
|
return cachedEntry.ToProtoEntry(), fuse.OK |
||||
|
} |
||||
|
|
||||
|
func (wfs *WFS) LookupFn() wdclient.LookupFileIdFunctionType { |
||||
|
if wfs.option.VolumeServerAccess == "filerProxy" { |
||||
|
return func(fileId string) (targetUrls []string, err error) { |
||||
|
return []string{"http://" + wfs.getCurrentFiler().ToHttpAddress() + "/?proxyChunkId=" + fileId}, nil |
||||
|
} |
||||
|
} |
||||
|
return filer.LookupFn(wfs) |
||||
|
} |
||||
|
|
||||
|
func (wfs *WFS) getCurrentFiler() pb.ServerAddress { |
||||
|
return wfs.option.FilerAddresses[wfs.option.filerIndex] |
||||
|
} |
||||
|
|
||||
|
func (option *Option) setupUniqueCacheDirectory() { |
||||
|
cacheUniqueId := util.Md5String([]byte(option.MountDirectory + string(option.FilerAddresses[0]) + option.FilerMountRootPath + util.Version()))[0:8] |
||||
|
option.uniqueCacheDir = path.Join(option.CacheDir, cacheUniqueId) |
||||
|
option.uniqueCacheTempPageDir = filepath.Join(option.uniqueCacheDir, "sw") |
||||
|
os.MkdirAll(option.uniqueCacheTempPageDir, os.FileMode(0777)&^option.Umask) |
||||
|
} |
||||
|
|
||||
|
func (option *Option) getTempFilePageDir() string { |
||||
|
return option.uniqueCacheTempPageDir |
||||
|
} |
||||
|
func (option *Option) getUniqueCacheDir() string { |
||||
|
return option.uniqueCacheDir |
||||
|
} |
||||
@ -0,0 +1,208 @@ |
|||||
|
package mount |
||||
|
|
||||
|
import ( |
||||
|
"github.com/chrislusf/seaweedfs/weed/filer" |
||||
|
"github.com/chrislusf/seaweedfs/weed/glog" |
||||
|
"github.com/chrislusf/seaweedfs/weed/pb/filer_pb" |
||||
|
"github.com/hanwen/go-fuse/v2/fuse" |
||||
|
"os" |
||||
|
"syscall" |
||||
|
"time" |
||||
|
) |
||||
|
|
||||
|
func (wfs *WFS) GetAttr(cancel <-chan struct{}, input *fuse.GetAttrIn, out *fuse.AttrOut) (code fuse.Status) { |
||||
|
if input.NodeId == 1 { |
||||
|
wfs.setRootAttr(out) |
||||
|
return fuse.OK |
||||
|
} |
||||
|
|
||||
|
_, _, entry, status := wfs.maybeReadEntry(input.NodeId) |
||||
|
if status != fuse.OK { |
||||
|
return status |
||||
|
} |
||||
|
out.AttrValid = 1 |
||||
|
wfs.setAttrByPbEntry(&out.Attr, input.NodeId, entry) |
||||
|
|
||||
|
return fuse.OK |
||||
|
} |
||||
|
|
||||
|
func (wfs *WFS) SetAttr(cancel <-chan struct{}, input *fuse.SetAttrIn, out *fuse.AttrOut) (code fuse.Status) { |
||||
|
|
||||
|
path, fh, entry, status := wfs.maybeReadEntry(input.NodeId) |
||||
|
if status != fuse.OK { |
||||
|
return status |
||||
|
} |
||||
|
|
||||
|
if size, ok := input.GetSize(); ok { |
||||
|
glog.V(4).Infof("%v setattr set size=%v chunks=%d", path, size, len(entry.Chunks)) |
||||
|
if size < filer.FileSize(entry) { |
||||
|
// fmt.Printf("truncate %v \n", fullPath)
|
||||
|
var chunks []*filer_pb.FileChunk |
||||
|
var truncatedChunks []*filer_pb.FileChunk |
||||
|
for _, chunk := range entry.Chunks { |
||||
|
int64Size := int64(chunk.Size) |
||||
|
if chunk.Offset+int64Size > int64(size) { |
||||
|
// this chunk is truncated
|
||||
|
int64Size = int64(size) - chunk.Offset |
||||
|
if int64Size > 0 { |
||||
|
chunks = append(chunks, chunk) |
||||
|
glog.V(4).Infof("truncated chunk %+v from %d to %d\n", chunk.GetFileIdString(), chunk.Size, int64Size) |
||||
|
chunk.Size = uint64(int64Size) |
||||
|
} else { |
||||
|
glog.V(4).Infof("truncated whole chunk %+v\n", chunk.GetFileIdString()) |
||||
|
truncatedChunks = append(truncatedChunks, chunk) |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
// set the new chunks and reset entry cache
|
||||
|
entry.Chunks = chunks |
||||
|
if fh != nil { |
||||
|
fh.entryViewCache = nil |
||||
|
} |
||||
|
} |
||||
|
entry.Attributes.Mtime = time.Now().Unix() |
||||
|
entry.Attributes.FileSize = size |
||||
|
|
||||
|
} |
||||
|
|
||||
|
if mode, ok := input.GetMode(); ok { |
||||
|
entry.Attributes.FileMode = uint32(mode) |
||||
|
} |
||||
|
|
||||
|
if uid, ok := input.GetUID(); ok { |
||||
|
entry.Attributes.Uid = uid |
||||
|
} |
||||
|
|
||||
|
if gid, ok := input.GetGID(); ok { |
||||
|
entry.Attributes.Gid = gid |
||||
|
} |
||||
|
|
||||
|
if mtime, ok := input.GetMTime(); ok { |
||||
|
entry.Attributes.Mtime = mtime.Unix() |
||||
|
} |
||||
|
|
||||
|
entry.Attributes.Mtime = time.Now().Unix() |
||||
|
out.AttrValid = 1 |
||||
|
wfs.setAttrByPbEntry(&out.Attr, input.NodeId, entry) |
||||
|
|
||||
|
if fh != nil { |
||||
|
fh.dirtyMetadata = true |
||||
|
return fuse.OK |
||||
|
} |
||||
|
|
||||
|
return wfs.saveEntry(path, entry) |
||||
|
|
||||
|
} |
||||
|
|
||||
|
func (wfs *WFS) setRootAttr(out *fuse.AttrOut) { |
||||
|
now := uint64(time.Now().Unix()) |
||||
|
out.AttrValid = 119 |
||||
|
out.Ino = 1 |
||||
|
setBlksize(&out.Attr, blockSize) |
||||
|
out.Uid = wfs.option.MountUid |
||||
|
out.Gid = wfs.option.MountGid |
||||
|
out.Mtime = now |
||||
|
out.Ctime = now |
||||
|
out.Atime = now |
||||
|
out.Mode = toSystemType(os.ModeDir) | uint32(wfs.option.MountMode) |
||||
|
out.Nlink = 1 |
||||
|
} |
||||
|
|
||||
|
func (wfs *WFS) setAttrByPbEntry(out *fuse.Attr, inode uint64, entry *filer_pb.Entry) { |
||||
|
out.Ino = inode |
||||
|
out.Size = filer.FileSize(entry) |
||||
|
out.Blocks = (out.Size + blockSize - 1) / blockSize |
||||
|
setBlksize(out, blockSize) |
||||
|
out.Mtime = uint64(entry.Attributes.Mtime) |
||||
|
out.Ctime = uint64(entry.Attributes.Mtime) |
||||
|
out.Atime = uint64(entry.Attributes.Mtime) |
||||
|
out.Mode = toSystemMode(os.FileMode(entry.Attributes.FileMode)) |
||||
|
if entry.HardLinkCounter > 0 { |
||||
|
out.Nlink = uint32(entry.HardLinkCounter) |
||||
|
} else { |
||||
|
out.Nlink = 1 |
||||
|
} |
||||
|
out.Uid = entry.Attributes.Uid |
||||
|
out.Gid = entry.Attributes.Gid |
||||
|
} |
||||
|
|
||||
|
func (wfs *WFS) setAttrByFilerEntry(out *fuse.Attr, inode uint64, entry *filer.Entry) { |
||||
|
out.Ino = inode |
||||
|
out.Size = entry.FileSize |
||||
|
out.Blocks = (out.Size + blockSize - 1) / blockSize |
||||
|
setBlksize(out, blockSize) |
||||
|
out.Atime = uint64(entry.Attr.Mtime.Unix()) |
||||
|
out.Mtime = uint64(entry.Attr.Mtime.Unix()) |
||||
|
out.Ctime = uint64(entry.Attr.Mtime.Unix()) |
||||
|
out.Crtime_ = uint64(entry.Attr.Crtime.Unix()) |
||||
|
out.Mode = toSystemMode(entry.Attr.Mode) |
||||
|
if entry.HardLinkCounter > 0 { |
||||
|
out.Nlink = uint32(entry.HardLinkCounter) |
||||
|
} else { |
||||
|
out.Nlink = 1 |
||||
|
} |
||||
|
out.Uid = entry.Attr.Uid |
||||
|
out.Gid = entry.Attr.Gid |
||||
|
} |
||||
|
|
||||
|
func (wfs *WFS) outputPbEntry(out *fuse.EntryOut, inode uint64, entry *filer_pb.Entry) { |
||||
|
out.NodeId = inode |
||||
|
out.Generation = 1 |
||||
|
out.EntryValid = 1 |
||||
|
out.AttrValid = 1 |
||||
|
wfs.setAttrByPbEntry(&out.Attr, inode, entry) |
||||
|
} |
||||
|
|
||||
|
func (wfs *WFS) outputFilerEntry(out *fuse.EntryOut, inode uint64, entry *filer.Entry) { |
||||
|
out.NodeId = inode |
||||
|
out.Generation = 1 |
||||
|
out.EntryValid = 1 |
||||
|
out.AttrValid = 1 |
||||
|
wfs.setAttrByFilerEntry(&out.Attr, inode, entry) |
||||
|
} |
||||
|
|
||||
|
func toSystemMode(mode os.FileMode) uint32 { |
||||
|
return toSystemType(mode) | uint32(mode) |
||||
|
} |
||||
|
|
||||
|
func toSystemType(mode os.FileMode) uint32 { |
||||
|
switch mode & os.ModeType { |
||||
|
case os.ModeDir: |
||||
|
return syscall.S_IFDIR |
||||
|
case os.ModeSymlink: |
||||
|
return syscall.S_IFLNK |
||||
|
case os.ModeNamedPipe: |
||||
|
return syscall.S_IFIFO |
||||
|
case os.ModeSocket: |
||||
|
return syscall.S_IFSOCK |
||||
|
case os.ModeDevice: |
||||
|
return syscall.S_IFBLK |
||||
|
case os.ModeCharDevice: |
||||
|
return syscall.S_IFCHR |
||||
|
default: |
||||
|
return syscall.S_IFREG |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
func toFileType(mode uint32) os.FileMode { |
||||
|
switch mode & (syscall.S_IFMT & 0xffff) { |
||||
|
case syscall.S_IFDIR: |
||||
|
return os.ModeDir |
||||
|
case syscall.S_IFLNK: |
||||
|
return os.ModeSymlink |
||||
|
case syscall.S_IFIFO: |
||||
|
return os.ModeNamedPipe |
||||
|
case syscall.S_IFSOCK: |
||||
|
return os.ModeSocket |
||||
|
case syscall.S_IFBLK: |
||||
|
return os.ModeDevice |
||||
|
case syscall.S_IFCHR: |
||||
|
return os.ModeCharDevice |
||||
|
default: |
||||
|
return 0 |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
func toFileMode(mode uint32) os.FileMode { |
||||
|
return toFileType(mode) | os.FileMode(mode&07777) |
||||
|
} |
||||
@ -0,0 +1,8 @@ |
|||||
|
package mount |
||||
|
|
||||
|
import ( |
||||
|
"github.com/hanwen/go-fuse/v2/fuse" |
||||
|
) |
||||
|
|
||||
|
func setBlksize(out *fuse.Attr, size uint32) { |
||||
|
} |
||||
@ -0,0 +1,9 @@ |
|||||
|
package mount |
||||
|
|
||||
|
import ( |
||||
|
"github.com/hanwen/go-fuse/v2/fuse" |
||||
|
) |
||||
|
|
||||
|
func setBlksize(out *fuse.Attr, size uint32) { |
||||
|
out.Blksize = size |
||||
|
} |
||||
@ -0,0 +1,59 @@ |
|||||
|
package mount |
||||
|
|
||||
|
import ( |
||||
|
"context" |
||||
|
"github.com/chrislusf/seaweedfs/weed/filer" |
||||
|
"github.com/chrislusf/seaweedfs/weed/glog" |
||||
|
"github.com/chrislusf/seaweedfs/weed/mount/meta_cache" |
||||
|
"github.com/chrislusf/seaweedfs/weed/pb/filer_pb" |
||||
|
"github.com/hanwen/go-fuse/v2/fuse" |
||||
|
) |
||||
|
|
||||
|
// Lookup is called by the kernel when the VFS wants to know
|
||||
|
// about a file inside a directory. Many lookup calls can
|
||||
|
// occur in parallel, but only one call happens for each (dir,
|
||||
|
// name) pair.
|
||||
|
|
||||
|
func (wfs *WFS) Lookup(cancel <-chan struct{}, header *fuse.InHeader, name string, out *fuse.EntryOut) (code fuse.Status) { |
||||
|
|
||||
|
if s := checkName(name); s != fuse.OK { |
||||
|
return s |
||||
|
} |
||||
|
|
||||
|
dirPath := wfs.inodeToPath.GetPath(header.NodeId) |
||||
|
|
||||
|
fullFilePath := dirPath.Child(name) |
||||
|
|
||||
|
visitErr := meta_cache.EnsureVisited(wfs.metaCache, wfs, dirPath) |
||||
|
if visitErr != nil { |
||||
|
glog.Errorf("dir Lookup %s: %v", dirPath, visitErr) |
||||
|
return fuse.EIO |
||||
|
} |
||||
|
localEntry, cacheErr := wfs.metaCache.FindEntry(context.Background(), fullFilePath) |
||||
|
if cacheErr == filer_pb.ErrNotFound { |
||||
|
return fuse.ENOENT |
||||
|
} |
||||
|
|
||||
|
if localEntry == nil { |
||||
|
// glog.V(3).Infof("dir Lookup cache miss %s", fullFilePath)
|
||||
|
entry, err := filer_pb.GetEntry(wfs, fullFilePath) |
||||
|
if err != nil { |
||||
|
glog.V(1).Infof("dir GetEntry %s: %v", fullFilePath, err) |
||||
|
return fuse.ENOENT |
||||
|
} |
||||
|
localEntry = filer.FromPbEntry(string(dirPath), entry) |
||||
|
} else { |
||||
|
glog.V(4).Infof("dir Lookup cache hit %s", fullFilePath) |
||||
|
} |
||||
|
|
||||
|
if localEntry == nil { |
||||
|
return fuse.ENOENT |
||||
|
} |
||||
|
|
||||
|
inode := wfs.inodeToPath.Lookup(fullFilePath, localEntry.IsDirectory()) |
||||
|
|
||||
|
wfs.outputFilerEntry(out, inode, localEntry) |
||||
|
|
||||
|
return fuse.OK |
||||
|
|
||||
|
} |
||||
@ -0,0 +1,111 @@ |
|||||
|
package mount |
||||
|
|
||||
|
import ( |
||||
|
"context" |
||||
|
"fmt" |
||||
|
"github.com/chrislusf/seaweedfs/weed/filer" |
||||
|
"github.com/chrislusf/seaweedfs/weed/glog" |
||||
|
"github.com/chrislusf/seaweedfs/weed/pb/filer_pb" |
||||
|
"github.com/hanwen/go-fuse/v2/fuse" |
||||
|
"os" |
||||
|
"strings" |
||||
|
"syscall" |
||||
|
"time" |
||||
|
) |
||||
|
|
||||
|
/** Create a directory |
||||
|
* |
||||
|
* Note that the mode argument may not have the type specification |
||||
|
* bits set, i.e. S_ISDIR(mode) can be false. To obtain the |
||||
|
* correct directory type bits use mode|S_IFDIR |
||||
|
* */ |
||||
|
func (wfs *WFS) Mkdir(cancel <-chan struct{}, in *fuse.MkdirIn, name string, out *fuse.EntryOut) (code fuse.Status) { |
||||
|
|
||||
|
if s := checkName(name); s != fuse.OK { |
||||
|
return s |
||||
|
} |
||||
|
|
||||
|
newEntry := &filer_pb.Entry{ |
||||
|
Name: name, |
||||
|
IsDirectory: true, |
||||
|
Attributes: &filer_pb.FuseAttributes{ |
||||
|
Mtime: time.Now().Unix(), |
||||
|
Crtime: time.Now().Unix(), |
||||
|
FileMode: uint32(os.ModeDir) | in.Mode&^uint32(wfs.option.Umask), |
||||
|
Uid: in.Uid, |
||||
|
Gid: in.Gid, |
||||
|
}, |
||||
|
} |
||||
|
|
||||
|
dirFullPath := wfs.inodeToPath.GetPath(in.NodeId) |
||||
|
|
||||
|
entryFullPath := dirFullPath.Child(name) |
||||
|
|
||||
|
err := wfs.WithFilerClient(false, func(client filer_pb.SeaweedFilerClient) error { |
||||
|
|
||||
|
wfs.mapPbIdFromLocalToFiler(newEntry) |
||||
|
defer wfs.mapPbIdFromFilerToLocal(newEntry) |
||||
|
|
||||
|
request := &filer_pb.CreateEntryRequest{ |
||||
|
Directory: string(dirFullPath), |
||||
|
Entry: newEntry, |
||||
|
Signatures: []int32{wfs.signature}, |
||||
|
} |
||||
|
|
||||
|
glog.V(1).Infof("mkdir: %v", request) |
||||
|
if err := filer_pb.CreateEntry(client, request); err != nil { |
||||
|
glog.V(0).Infof("mkdir %s: %v", entryFullPath, err) |
||||
|
return err |
||||
|
} |
||||
|
|
||||
|
if err := wfs.metaCache.InsertEntry(context.Background(), filer.FromPbEntry(request.Directory, request.Entry)); err != nil { |
||||
|
return fmt.Errorf("local mkdir dir %s: %v", entryFullPath, err) |
||||
|
} |
||||
|
|
||||
|
return nil |
||||
|
}) |
||||
|
|
||||
|
glog.V(0).Infof("mkdir %s: %v", entryFullPath, err) |
||||
|
|
||||
|
if err != nil { |
||||
|
return fuse.EIO |
||||
|
} |
||||
|
|
||||
|
inode := wfs.inodeToPath.Lookup(entryFullPath, true) |
||||
|
|
||||
|
wfs.outputPbEntry(out, inode, newEntry) |
||||
|
|
||||
|
return fuse.OK |
||||
|
|
||||
|
} |
||||
|
|
||||
|
/** Remove a directory */ |
||||
|
func (wfs *WFS) Rmdir(cancel <-chan struct{}, header *fuse.InHeader, name string) (code fuse.Status) { |
||||
|
|
||||
|
if name == "." { |
||||
|
return fuse.Status(syscall.EINVAL) |
||||
|
} |
||||
|
if name == ".." { |
||||
|
return fuse.Status(syscall.ENOTEMPTY) |
||||
|
} |
||||
|
|
||||
|
dirFullPath := wfs.inodeToPath.GetPath(header.NodeId) |
||||
|
entryFullPath := dirFullPath.Child(name) |
||||
|
|
||||
|
glog.V(3).Infof("remove directory: %v", entryFullPath) |
||||
|
ignoreRecursiveErr := true // ignore recursion error since the OS should manage it
|
||||
|
err := filer_pb.Remove(wfs, string(dirFullPath), name, true, true, ignoreRecursiveErr, false, []int32{wfs.signature}) |
||||
|
if err != nil { |
||||
|
glog.V(0).Infof("remove %s: %v", entryFullPath, err) |
||||
|
if strings.Contains(err.Error(), filer.MsgFailDelNonEmptyFolder) { |
||||
|
return fuse.Status(syscall.ENOTEMPTY) |
||||
|
} |
||||
|
return fuse.ENOENT |
||||
|
} |
||||
|
|
||||
|
wfs.metaCache.DeleteEntry(context.Background(), entryFullPath) |
||||
|
wfs.inodeToPath.RemovePath(entryFullPath) |
||||
|
|
||||
|
return fuse.OK |
||||
|
|
||||
|
} |
||||
@ -0,0 +1,132 @@ |
|||||
|
package mount |
||||
|
|
||||
|
import ( |
||||
|
"context" |
||||
|
"github.com/chrislusf/seaweedfs/weed/filer" |
||||
|
"github.com/chrislusf/seaweedfs/weed/glog" |
||||
|
"github.com/chrislusf/seaweedfs/weed/mount/meta_cache" |
||||
|
"github.com/chrislusf/seaweedfs/weed/util" |
||||
|
"github.com/hanwen/go-fuse/v2/fuse" |
||||
|
"math" |
||||
|
"os" |
||||
|
) |
||||
|
|
||||
|
// Directory handling
|
||||
|
|
||||
|
/** Open directory |
||||
|
* |
||||
|
* Unless the 'default_permissions' mount option is given, |
||||
|
* this method should check if opendir is permitted for this |
||||
|
* directory. Optionally opendir may also return an arbitrary |
||||
|
* filehandle in the fuse_file_info structure, which will be |
||||
|
* passed to readdir, releasedir and fsyncdir. |
||||
|
*/ |
||||
|
func (wfs *WFS) OpenDir(cancel <-chan struct{}, input *fuse.OpenIn, out *fuse.OpenOut) (code fuse.Status) { |
||||
|
if !wfs.inodeToPath.HasInode(input.NodeId) { |
||||
|
return fuse.ENOENT |
||||
|
} |
||||
|
return fuse.OK |
||||
|
} |
||||
|
|
||||
|
/** Release directory |
||||
|
* |
||||
|
* If the directory has been removed after the call to opendir, the |
||||
|
* path parameter will be NULL. |
||||
|
*/ |
||||
|
func (wfs *WFS) ReleaseDir(input *fuse.ReleaseIn) { |
||||
|
} |
||||
|
|
||||
|
/** Synchronize directory contents |
||||
|
* |
||||
|
* If the directory has been removed after the call to opendir, the |
||||
|
* path parameter will be NULL. |
||||
|
* |
||||
|
* If the datasync parameter is non-zero, then only the user data |
||||
|
* should be flushed, not the meta data |
||||
|
*/ |
||||
|
func (wfs *WFS) FsyncDir(cancel <-chan struct{}, input *fuse.FsyncIn) (code fuse.Status) { |
||||
|
return fuse.OK |
||||
|
} |
||||
|
|
||||
|
/** Read directory |
||||
|
* |
||||
|
* The filesystem may choose between two modes of operation: |
||||
|
* |
||||
|
* 1) The readdir implementation ignores the offset parameter, and |
||||
|
* passes zero to the filler function's offset. The filler |
||||
|
* function will not return '1' (unless an error happens), so the |
||||
|
* whole directory is read in a single readdir operation. |
||||
|
* |
||||
|
* 2) The readdir implementation keeps track of the offsets of the |
||||
|
* directory entries. It uses the offset parameter and always |
||||
|
* passes non-zero offset to the filler function. When the buffer |
||||
|
* is full (or an error happens) the filler function will return |
||||
|
* '1'. |
||||
|
*/ |
||||
|
func (wfs *WFS) ReadDir(cancel <-chan struct{}, input *fuse.ReadIn, out *fuse.DirEntryList) (code fuse.Status) { |
||||
|
return wfs.doReadDirectory(input, out, false) |
||||
|
} |
||||
|
|
||||
|
func (wfs *WFS) ReadDirPlus(cancel <-chan struct{}, input *fuse.ReadIn, out *fuse.DirEntryList) (code fuse.Status) { |
||||
|
return wfs.doReadDirectory(input, out, true) |
||||
|
} |
||||
|
|
||||
|
func (wfs *WFS) doReadDirectory(input *fuse.ReadIn, out *fuse.DirEntryList, isPlusMode bool) fuse.Status { |
||||
|
dirPath := wfs.inodeToPath.GetPath(input.NodeId) |
||||
|
|
||||
|
var counter uint64 |
||||
|
var dirEntry fuse.DirEntry |
||||
|
if input.Offset == 0 { |
||||
|
counter++ |
||||
|
dirEntry.Ino = input.NodeId |
||||
|
dirEntry.Name = "." |
||||
|
dirEntry.Mode = toSystemMode(os.ModeDir) |
||||
|
out.AddDirEntry(dirEntry) |
||||
|
|
||||
|
counter++ |
||||
|
parentDir, _ := dirPath.DirAndName() |
||||
|
parentInode := wfs.inodeToPath.GetInode(util.FullPath(parentDir)) |
||||
|
dirEntry.Ino = parentInode |
||||
|
dirEntry.Name = ".." |
||||
|
dirEntry.Mode = toSystemMode(os.ModeDir) |
||||
|
out.AddDirEntry(dirEntry) |
||||
|
|
||||
|
} |
||||
|
|
||||
|
processEachEntryFn := func(entry *filer.Entry, isLast bool) bool { |
||||
|
counter++ |
||||
|
if counter <= input.Offset { |
||||
|
return true |
||||
|
} |
||||
|
dirEntry.Name = entry.Name() |
||||
|
inode := wfs.inodeToPath.GetInode(dirPath.Child(dirEntry.Name)) |
||||
|
dirEntry.Ino = inode |
||||
|
dirEntry.Mode = toSystemMode(entry.Mode) |
||||
|
if !isPlusMode { |
||||
|
if !out.AddDirEntry(dirEntry) { |
||||
|
return false |
||||
|
} |
||||
|
} else { |
||||
|
entryOut := out.AddDirLookupEntry(dirEntry) |
||||
|
if entryOut == nil { |
||||
|
return false |
||||
|
} |
||||
|
wfs.outputFilerEntry(entryOut, inode, entry) |
||||
|
} |
||||
|
return true |
||||
|
} |
||||
|
|
||||
|
if err := meta_cache.EnsureVisited(wfs.metaCache, wfs, dirPath); err != nil { |
||||
|
glog.Errorf("dir ReadDirAll %s: %v", dirPath, err) |
||||
|
return fuse.EIO |
||||
|
} |
||||
|
listErr := wfs.metaCache.ListDirectoryEntries(context.Background(), dirPath, "", false, int64(math.MaxInt32), func(entry *filer.Entry) bool { |
||||
|
return processEachEntryFn(entry, false) |
||||
|
}) |
||||
|
if listErr != nil { |
||||
|
glog.Errorf("list meta cache: %v", listErr) |
||||
|
return fuse.EIO |
||||
|
} |
||||
|
|
||||
|
return fuse.OK |
||||
|
} |
||||
@ -0,0 +1,98 @@ |
|||||
|
package mount |
||||
|
|
||||
|
import ( |
||||
|
"github.com/hanwen/go-fuse/v2/fuse" |
||||
|
) |
||||
|
|
||||
|
/** |
||||
|
* Open a file |
||||
|
* |
||||
|
* Open flags are available in fi->flags. The following rules |
||||
|
* apply. |
||||
|
* |
||||
|
* - Creation (O_CREAT, O_EXCL, O_NOCTTY) flags will be |
||||
|
* filtered out / handled by the kernel. |
||||
|
* |
||||
|
* - Access modes (O_RDONLY, O_WRONLY, O_RDWR) should be used |
||||
|
* by the filesystem to check if the operation is |
||||
|
* permitted. If the ``-o default_permissions`` mount |
||||
|
* option is given, this check is already done by the |
||||
|
* kernel before calling open() and may thus be omitted by |
||||
|
* the filesystem. |
||||
|
* |
||||
|
* - When writeback caching is enabled, the kernel may send |
||||
|
* read requests even for files opened with O_WRONLY. The |
||||
|
* filesystem should be prepared to handle this. |
||||
|
* |
||||
|
* - When writeback caching is disabled, the filesystem is |
||||
|
* expected to properly handle the O_APPEND flag and ensure |
||||
|
* that each write is appending to the end of the file. |
||||
|
* |
||||
|
* - When writeback caching is enabled, the kernel will |
||||
|
* handle O_APPEND. However, unless all changes to the file |
||||
|
* come through the kernel this will not work reliably. The |
||||
|
* filesystem should thus either ignore the O_APPEND flag |
||||
|
* (and let the kernel handle it), or return an error |
||||
|
* (indicating that reliably O_APPEND is not available). |
||||
|
* |
||||
|
* Filesystem may store an arbitrary file handle (pointer, |
||||
|
* index, etc) in fi->fh, and use this in other all other file |
||||
|
* operations (read, write, flush, release, fsync). |
||||
|
* |
||||
|
* Filesystem may also implement stateless file I/O and not store |
||||
|
* anything in fi->fh. |
||||
|
* |
||||
|
* There are also some flags (direct_io, keep_cache) which the |
||||
|
* filesystem may set in fi, to change the way the file is opened. |
||||
|
* See fuse_file_info structure in <fuse_common.h> for more details. |
||||
|
* |
||||
|
* If this request is answered with an error code of ENOSYS |
||||
|
* and FUSE_CAP_NO_OPEN_SUPPORT is set in |
||||
|
* `fuse_conn_info.capable`, this is treated as success and |
||||
|
* future calls to open and release will also succeed without being |
||||
|
* sent to the filesystem process. |
||||
|
* |
||||
|
* Valid replies: |
||||
|
* fuse_reply_open |
||||
|
* fuse_reply_err |
||||
|
* |
||||
|
* @param req request handle |
||||
|
* @param ino the inode number |
||||
|
* @param fi file information |
||||
|
*/ |
||||
|
func (wfs *WFS) Open(cancel <-chan struct{}, in *fuse.OpenIn, out *fuse.OpenOut) (status fuse.Status) { |
||||
|
fileHandle, code := wfs.AcquireHandle(in.NodeId, in.Uid, in.Gid) |
||||
|
if code == fuse.OK { |
||||
|
out.Fh = uint64(fileHandle.fh) |
||||
|
} |
||||
|
return code |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Release an open file |
||||
|
* |
||||
|
* Release is called when there are no more references to an open |
||||
|
* file: all file descriptors are closed and all memory mappings |
||||
|
* are unmapped. |
||||
|
* |
||||
|
* For every open call there will be exactly one release call (unless |
||||
|
* the filesystem is force-unmounted). |
||||
|
* |
||||
|
* The filesystem may reply with an error, but error values are |
||||
|
* not returned to close() or munmap() which triggered the |
||||
|
* release. |
||||
|
* |
||||
|
* fi->fh will contain the value set by the open method, or will |
||||
|
* be undefined if the open method didn't set any value. |
||||
|
* fi->flags will contain the same flags as for open. |
||||
|
* |
||||
|
* Valid replies: |
||||
|
* fuse_reply_err |
||||
|
* |
||||
|
* @param req request handle |
||||
|
* @param ino the inode number |
||||
|
* @param fi file information |
||||
|
*/ |
||||
|
func (wfs *WFS) Release(cancel <-chan struct{}, in *fuse.ReleaseIn) { |
||||
|
wfs.ReleaseHandle(FileHandleId(in.Fh)) |
||||
|
} |
||||
@ -0,0 +1,130 @@ |
|||||
|
package mount |
||||
|
|
||||
|
import ( |
||||
|
"context" |
||||
|
"fmt" |
||||
|
"github.com/chrislusf/seaweedfs/weed/filer" |
||||
|
"github.com/chrislusf/seaweedfs/weed/glog" |
||||
|
"github.com/chrislusf/seaweedfs/weed/pb/filer_pb" |
||||
|
"github.com/hanwen/go-fuse/v2/fuse" |
||||
|
"time" |
||||
|
) |
||||
|
|
||||
|
/** |
||||
|
* Create and open a file |
||||
|
* |
||||
|
* If the file does not exist, first create it with the specified |
||||
|
* mode, and then open it. |
||||
|
* |
||||
|
* If this method is not implemented or under Linux kernel |
||||
|
* versions earlier than 2.6.15, the mknod() and open() methods |
||||
|
* will be called instead. |
||||
|
*/ |
||||
|
func (wfs *WFS) Create(cancel <-chan struct{}, in *fuse.CreateIn, name string, out *fuse.CreateOut) (code fuse.Status) { |
||||
|
// if implemented, need to use
|
||||
|
// inode := wfs.inodeToPath.Lookup(entryFullPath)
|
||||
|
// to ensure nlookup counter
|
||||
|
return fuse.ENOSYS |
||||
|
} |
||||
|
|
||||
|
/** Create a file node |
||||
|
* |
||||
|
* This is called for creation of all non-directory, non-symlink |
||||
|
* nodes. If the filesystem defines a create() method, then for |
||||
|
* regular files that will be called instead. |
||||
|
*/ |
||||
|
func (wfs *WFS) Mknod(cancel <-chan struct{}, in *fuse.MknodIn, name string, out *fuse.EntryOut) (code fuse.Status) { |
||||
|
|
||||
|
if s := checkName(name); s != fuse.OK { |
||||
|
return s |
||||
|
} |
||||
|
|
||||
|
newEntry := &filer_pb.Entry{ |
||||
|
Name: name, |
||||
|
IsDirectory: false, |
||||
|
Attributes: &filer_pb.FuseAttributes{ |
||||
|
Mtime: time.Now().Unix(), |
||||
|
Crtime: time.Now().Unix(), |
||||
|
FileMode: uint32(toFileMode(in.Mode) &^ wfs.option.Umask), |
||||
|
Uid: in.Uid, |
||||
|
Gid: in.Gid, |
||||
|
Collection: wfs.option.Collection, |
||||
|
Replication: wfs.option.Replication, |
||||
|
TtlSec: wfs.option.TtlSec, |
||||
|
}, |
||||
|
} |
||||
|
|
||||
|
dirFullPath := wfs.inodeToPath.GetPath(in.NodeId) |
||||
|
|
||||
|
entryFullPath := dirFullPath.Child(name) |
||||
|
|
||||
|
err := wfs.WithFilerClient(false, func(client filer_pb.SeaweedFilerClient) error { |
||||
|
|
||||
|
wfs.mapPbIdFromLocalToFiler(newEntry) |
||||
|
defer wfs.mapPbIdFromFilerToLocal(newEntry) |
||||
|
|
||||
|
request := &filer_pb.CreateEntryRequest{ |
||||
|
Directory: string(dirFullPath), |
||||
|
Entry: newEntry, |
||||
|
Signatures: []int32{wfs.signature}, |
||||
|
} |
||||
|
|
||||
|
glog.V(1).Infof("mknod: %v", request) |
||||
|
if err := filer_pb.CreateEntry(client, request); err != nil { |
||||
|
glog.V(0).Infof("mknod %s: %v", entryFullPath, err) |
||||
|
return err |
||||
|
} |
||||
|
|
||||
|
if err := wfs.metaCache.InsertEntry(context.Background(), filer.FromPbEntry(request.Directory, request.Entry)); err != nil { |
||||
|
return fmt.Errorf("local mknod %s: %v", entryFullPath, err) |
||||
|
} |
||||
|
|
||||
|
return nil |
||||
|
}) |
||||
|
|
||||
|
glog.V(0).Infof("mknod %s: %v", entryFullPath, err) |
||||
|
|
||||
|
if err != nil { |
||||
|
return fuse.EIO |
||||
|
} |
||||
|
|
||||
|
inode := wfs.inodeToPath.Lookup(entryFullPath, false) |
||||
|
|
||||
|
wfs.outputPbEntry(out, inode, newEntry) |
||||
|
|
||||
|
return fuse.OK |
||||
|
|
||||
|
} |
||||
|
|
||||
|
/** Remove a file */ |
||||
|
func (wfs *WFS) Unlink(cancel <-chan struct{}, header *fuse.InHeader, name string) (code fuse.Status) { |
||||
|
|
||||
|
dirFullPath := wfs.inodeToPath.GetPath(header.NodeId) |
||||
|
entryFullPath := dirFullPath.Child(name) |
||||
|
|
||||
|
entry, status := wfs.maybeLoadEntry(entryFullPath) |
||||
|
if status != fuse.OK { |
||||
|
return status |
||||
|
} |
||||
|
|
||||
|
// first, ensure the filer store can correctly delete
|
||||
|
glog.V(3).Infof("remove file: %v", entryFullPath) |
||||
|
isDeleteData := entry != nil && entry.HardLinkCounter <= 1 |
||||
|
err := filer_pb.Remove(wfs, string(dirFullPath), name, isDeleteData, false, false, false, []int32{wfs.signature}) |
||||
|
if err != nil { |
||||
|
glog.V(0).Infof("remove %s: %v", entryFullPath, err) |
||||
|
return fuse.ENOENT |
||||
|
} |
||||
|
|
||||
|
// then, delete meta cache
|
||||
|
if err = wfs.metaCache.DeleteEntry(context.Background(), entryFullPath); err != nil { |
||||
|
glog.V(3).Infof("local DeleteEntry %s: %v", entryFullPath, err) |
||||
|
return fuse.EIO |
||||
|
} |
||||
|
|
||||
|
wfs.metaCache.DeleteEntry(context.Background(), entryFullPath) |
||||
|
wfs.inodeToPath.RemovePath(entryFullPath) |
||||
|
|
||||
|
return fuse.OK |
||||
|
|
||||
|
} |
||||
@ -0,0 +1,59 @@ |
|||||
|
package mount |
||||
|
|
||||
|
import ( |
||||
|
"github.com/chrislusf/seaweedfs/weed/glog" |
||||
|
"github.com/hanwen/go-fuse/v2/fuse" |
||||
|
"io" |
||||
|
) |
||||
|
|
||||
|
/** |
||||
|
* Read data |
||||
|
* |
||||
|
* Read should send exactly the number of bytes requested except |
||||
|
* on EOF or error, otherwise the rest of the data will be |
||||
|
* substituted with zeroes. An exception to this is when the file |
||||
|
* has been opened in 'direct_io' mode, in which case the return |
||||
|
* value of the read system call will reflect the return value of |
||||
|
* this operation. |
||||
|
* |
||||
|
* fi->fh will contain the value set by the open method, or will |
||||
|
* be undefined if the open method didn't set any value. |
||||
|
* |
||||
|
* Valid replies: |
||||
|
* fuse_reply_buf |
||||
|
* fuse_reply_iov |
||||
|
* fuse_reply_data |
||||
|
* fuse_reply_err |
||||
|
* |
||||
|
* @param req request handle |
||||
|
* @param ino the inode number |
||||
|
* @param size number of bytes to read |
||||
|
* @param off offset to read from |
||||
|
* @param fi file information |
||||
|
*/ |
||||
|
func (wfs *WFS) Read(cancel <-chan struct{}, in *fuse.ReadIn, buff []byte) (fuse.ReadResult, fuse.Status) { |
||||
|
fh := wfs.GetHandle(FileHandleId(in.Fh)) |
||||
|
if fh == nil { |
||||
|
return nil, fuse.ENOENT |
||||
|
} |
||||
|
|
||||
|
offset := int64(in.Offset) |
||||
|
fh.lockForRead(offset, len(buff)) |
||||
|
defer fh.unlockForRead(offset, len(buff)) |
||||
|
|
||||
|
totalRead, err := fh.readFromChunks(buff, offset) |
||||
|
if err == nil || err == io.EOF { |
||||
|
maxStop := fh.readFromDirtyPages(buff, offset) |
||||
|
totalRead = max(maxStop-offset, totalRead) |
||||
|
} |
||||
|
if err == io.EOF { |
||||
|
err = nil |
||||
|
} |
||||
|
|
||||
|
if err != nil { |
||||
|
glog.Warningf("file handle read %s %d: %v", fh.FullPath(), totalRead, err) |
||||
|
return nil, fuse.EIO |
||||
|
} |
||||
|
|
||||
|
return fuse.ReadResultData(buff[:totalRead]), fuse.OK |
||||
|
} |
||||
@ -0,0 +1,180 @@ |
|||||
|
package mount |
||||
|
|
||||
|
import ( |
||||
|
"context" |
||||
|
"fmt" |
||||
|
"github.com/chrislusf/seaweedfs/weed/filer" |
||||
|
"github.com/chrislusf/seaweedfs/weed/glog" |
||||
|
"github.com/chrislusf/seaweedfs/weed/pb/filer_pb" |
||||
|
"github.com/hanwen/go-fuse/v2/fuse" |
||||
|
"os" |
||||
|
"time" |
||||
|
) |
||||
|
|
||||
|
/** |
||||
|
* Flush method |
||||
|
* |
||||
|
* This is called on each close() of the opened file. |
||||
|
* |
||||
|
* Since file descriptors can be duplicated (dup, dup2, fork), for |
||||
|
* one open call there may be many flush calls. |
||||
|
* |
||||
|
* Filesystems shouldn't assume that flush will always be called |
||||
|
* after some writes, or that if will be called at all. |
||||
|
* |
||||
|
* fi->fh will contain the value set by the open method, or will |
||||
|
* be undefined if the open method didn't set any value. |
||||
|
* |
||||
|
* NOTE: the name of the method is misleading, since (unlike |
||||
|
* fsync) the filesystem is not forced to flush pending writes. |
||||
|
* One reason to flush data is if the filesystem wants to return |
||||
|
* write errors during close. However, such use is non-portable |
||||
|
* because POSIX does not require [close] to wait for delayed I/O to |
||||
|
* complete. |
||||
|
* |
||||
|
* If the filesystem supports file locking operations (setlk, |
||||
|
* getlk) it should remove all locks belonging to 'fi->owner'. |
||||
|
* |
||||
|
* If this request is answered with an error code of ENOSYS, |
||||
|
* this is treated as success and future calls to flush() will |
||||
|
* succeed automatically without being send to the filesystem |
||||
|
* process. |
||||
|
* |
||||
|
* Valid replies: |
||||
|
* fuse_reply_err |
||||
|
* |
||||
|
* @param req request handle |
||||
|
* @param ino the inode number |
||||
|
* @param fi file information |
||||
|
* |
||||
|
* [close]: http://pubs.opengroup.org/onlinepubs/9699919799/functions/close.html
|
||||
|
*/ |
||||
|
func (wfs *WFS) Flush(cancel <-chan struct{}, in *fuse.FlushIn) fuse.Status { |
||||
|
fh := wfs.GetHandle(FileHandleId(in.Fh)) |
||||
|
if fh == nil { |
||||
|
return fuse.ENOENT |
||||
|
} |
||||
|
|
||||
|
fh.Lock() |
||||
|
defer fh.Unlock() |
||||
|
|
||||
|
return wfs.doFlush(fh, in.Uid, in.Gid) |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Synchronize file contents |
||||
|
* |
||||
|
* If the datasync parameter is non-zero, then only the user data |
||||
|
* should be flushed, not the meta data. |
||||
|
* |
||||
|
* If this request is answered with an error code of ENOSYS, |
||||
|
* this is treated as success and future calls to fsync() will |
||||
|
* succeed automatically without being send to the filesystem |
||||
|
* process. |
||||
|
* |
||||
|
* Valid replies: |
||||
|
* fuse_reply_err |
||||
|
* |
||||
|
* @param req request handle |
||||
|
* @param ino the inode number |
||||
|
* @param datasync flag indicating if only data should be flushed |
||||
|
* @param fi file information |
||||
|
*/ |
||||
|
func (wfs *WFS) Fsync(cancel <-chan struct{}, in *fuse.FsyncIn) (code fuse.Status) { |
||||
|
|
||||
|
fh := wfs.GetHandle(FileHandleId(in.Fh)) |
||||
|
if fh == nil { |
||||
|
return fuse.ENOENT |
||||
|
} |
||||
|
|
||||
|
fh.Lock() |
||||
|
defer fh.Unlock() |
||||
|
|
||||
|
return wfs.doFlush(fh, in.Uid, in.Gid) |
||||
|
|
||||
|
} |
||||
|
|
||||
|
func (wfs *WFS) doFlush(fh *FileHandle, uid, gid uint32) fuse.Status { |
||||
|
// flush works at fh level
|
||||
|
fileFullPath := fh.FullPath() |
||||
|
dir, _ := fileFullPath.DirAndName() |
||||
|
// send the data to the OS
|
||||
|
glog.V(4).Infof("doFlush %s fh %d", fileFullPath, fh.handle) |
||||
|
|
||||
|
if err := fh.dirtyPages.FlushData(); err != nil { |
||||
|
glog.Errorf("%v doFlush: %v", fileFullPath, err) |
||||
|
return fuse.EIO |
||||
|
} |
||||
|
|
||||
|
if !fh.dirtyMetadata { |
||||
|
return fuse.OK |
||||
|
} |
||||
|
|
||||
|
err := wfs.WithFilerClient(false, func(client filer_pb.SeaweedFilerClient) error { |
||||
|
|
||||
|
entry := fh.entry |
||||
|
if entry == nil { |
||||
|
return nil |
||||
|
} |
||||
|
|
||||
|
if entry.Attributes != nil { |
||||
|
entry.Attributes.Mime = fh.contentType |
||||
|
if entry.Attributes.Uid == 0 { |
||||
|
entry.Attributes.Uid = uid |
||||
|
} |
||||
|
if entry.Attributes.Gid == 0 { |
||||
|
entry.Attributes.Gid = gid |
||||
|
} |
||||
|
if entry.Attributes.Crtime == 0 { |
||||
|
entry.Attributes.Crtime = time.Now().Unix() |
||||
|
} |
||||
|
entry.Attributes.Mtime = time.Now().Unix() |
||||
|
entry.Attributes.FileMode = uint32(os.FileMode(entry.Attributes.FileMode) &^ wfs.option.Umask) |
||||
|
entry.Attributes.Collection, entry.Attributes.Replication = fh.dirtyPages.GetStorageOptions() |
||||
|
} |
||||
|
|
||||
|
request := &filer_pb.CreateEntryRequest{ |
||||
|
Directory: string(dir), |
||||
|
Entry: entry, |
||||
|
Signatures: []int32{wfs.signature}, |
||||
|
} |
||||
|
|
||||
|
glog.V(4).Infof("%s set chunks: %v", fileFullPath, len(entry.Chunks)) |
||||
|
for i, chunk := range entry.Chunks { |
||||
|
glog.V(4).Infof("%s chunks %d: %v [%d,%d)", fileFullPath, i, chunk.GetFileIdString(), chunk.Offset, chunk.Offset+int64(chunk.Size)) |
||||
|
} |
||||
|
|
||||
|
manifestChunks, nonManifestChunks := filer.SeparateManifestChunks(entry.Chunks) |
||||
|
|
||||
|
chunks, _ := filer.CompactFileChunks(wfs.LookupFn(), nonManifestChunks) |
||||
|
chunks, manifestErr := filer.MaybeManifestize(wfs.saveDataAsChunk(fileFullPath), chunks) |
||||
|
if manifestErr != nil { |
||||
|
// not good, but should be ok
|
||||
|
glog.V(0).Infof("MaybeManifestize: %v", manifestErr) |
||||
|
} |
||||
|
entry.Chunks = append(chunks, manifestChunks...) |
||||
|
|
||||
|
wfs.mapPbIdFromLocalToFiler(request.Entry) |
||||
|
defer wfs.mapPbIdFromFilerToLocal(request.Entry) |
||||
|
|
||||
|
if err := filer_pb.CreateEntry(client, request); err != nil { |
||||
|
glog.Errorf("fh flush create %s: %v", fileFullPath, err) |
||||
|
return fmt.Errorf("fh flush create %s: %v", fileFullPath, err) |
||||
|
} |
||||
|
|
||||
|
wfs.metaCache.InsertEntry(context.Background(), filer.FromPbEntry(request.Directory, request.Entry)) |
||||
|
|
||||
|
return nil |
||||
|
}) |
||||
|
|
||||
|
if err == nil { |
||||
|
fh.dirtyMetadata = false |
||||
|
} |
||||
|
|
||||
|
if err != nil { |
||||
|
glog.Errorf("%v fh %d flush: %v", fileFullPath, fh.handle, err) |
||||
|
return fuse.EIO |
||||
|
} |
||||
|
|
||||
|
return fuse.OK |
||||
|
} |
||||
@ -0,0 +1,66 @@ |
|||||
|
package mount |
||||
|
|
||||
|
import ( |
||||
|
"github.com/hanwen/go-fuse/v2/fuse" |
||||
|
"net/http" |
||||
|
) |
||||
|
|
||||
|
/** |
||||
|
* Write data |
||||
|
* |
||||
|
* Write should return exactly the number of bytes requested |
||||
|
* except on error. An exception to this is when the file has |
||||
|
* been opened in 'direct_io' mode, in which case the return value |
||||
|
* of the write system call will reflect the return value of this |
||||
|
* operation. |
||||
|
* |
||||
|
* Unless FUSE_CAP_HANDLE_KILLPRIV is disabled, this method is |
||||
|
* expected to reset the setuid and setgid bits. |
||||
|
* |
||||
|
* fi->fh will contain the value set by the open method, or will |
||||
|
* be undefined if the open method didn't set any value. |
||||
|
* |
||||
|
* Valid replies: |
||||
|
* fuse_reply_write |
||||
|
* fuse_reply_err |
||||
|
* |
||||
|
* @param req request handle |
||||
|
* @param ino the inode number |
||||
|
* @param buf data to write |
||||
|
* @param size number of bytes to write |
||||
|
* @param off offset to write to |
||||
|
* @param fi file information |
||||
|
*/ |
||||
|
func (wfs *WFS) Write(cancel <-chan struct{}, in *fuse.WriteIn, data []byte) (written uint32, code fuse.Status) { |
||||
|
|
||||
|
fh := wfs.GetHandle(FileHandleId(in.Fh)) |
||||
|
if fh == nil { |
||||
|
return 0, fuse.ENOENT |
||||
|
} |
||||
|
|
||||
|
fh.Lock() |
||||
|
defer fh.Unlock() |
||||
|
|
||||
|
entry := fh.entry |
||||
|
if entry == nil { |
||||
|
return 0, fuse.OK |
||||
|
} |
||||
|
|
||||
|
entry.Content = nil |
||||
|
offset := int64(in.Offset) |
||||
|
entry.Attributes.FileSize = uint64(max(offset+int64(len(data)), int64(entry.Attributes.FileSize))) |
||||
|
// glog.V(4).Infof("%v write [%d,%d) %d", fh.f.fullpath(), req.Offset, req.Offset+int64(len(req.Data)), len(req.Data))
|
||||
|
|
||||
|
fh.dirtyPages.AddPage(offset, data) |
||||
|
|
||||
|
written = uint32(len(data)) |
||||
|
|
||||
|
if offset == 0 { |
||||
|
// detect mime type
|
||||
|
fh.contentType = http.DetectContentType(data) |
||||
|
} |
||||
|
|
||||
|
fh.dirtyMetadata = true |
||||
|
|
||||
|
return written, fuse.OK |
||||
|
} |
||||
@ -0,0 +1,20 @@ |
|||||
|
package mount |
||||
|
|
||||
|
import "github.com/hanwen/go-fuse/v2/fuse" |
||||
|
|
||||
|
func (wfs *WFS) AcquireHandle(inode uint64, uid, gid uint32) (fileHandle *FileHandle, code fuse.Status) { |
||||
|
_, _, entry, status := wfs.maybeReadEntry(inode) |
||||
|
if status == fuse.OK { |
||||
|
fileHandle = wfs.fhmap.AcquireFileHandle(wfs, inode, entry) |
||||
|
fileHandle.entry = entry |
||||
|
} |
||||
|
return |
||||
|
} |
||||
|
|
||||
|
func (wfs *WFS) ReleaseHandle(handleId FileHandleId) { |
||||
|
wfs.fhmap.ReleaseByHandle(handleId) |
||||
|
} |
||||
|
|
||||
|
func (wfs *WFS) GetHandle(handleId FileHandleId) *FileHandle { |
||||
|
return wfs.fhmap.GetFileHandle(handleId) |
||||
|
} |
||||
@ -0,0 +1,68 @@ |
|||||
|
package mount |
||||
|
|
||||
|
import ( |
||||
|
"context" |
||||
|
"github.com/chrislusf/seaweedfs/weed/util" |
||||
|
) |
||||
|
|
||||
|
// Forget is called when the kernel discards entries from its
|
||||
|
// dentry cache. This happens on unmount, and when the kernel
|
||||
|
// is short on memory. Since it is not guaranteed to occur at
|
||||
|
// any moment, and since there is no return value, Forget
|
||||
|
// should not do I/O, as there is no channel to report back
|
||||
|
// I/O errors.
|
||||
|
// from https://github.com/libfuse/libfuse/blob/master/include/fuse_lowlevel.h
|
||||
|
/** |
||||
|
* Forget about an inode |
||||
|
* |
||||
|
* This function is called when the kernel removes an inode |
||||
|
* from its internal caches. |
||||
|
* |
||||
|
* The inode's lookup count increases by one for every call to |
||||
|
* fuse_reply_entry and fuse_reply_create. The nlookup parameter |
||||
|
* indicates by how much the lookup count should be decreased. |
||||
|
* |
||||
|
* Inodes with a non-zero lookup count may receive request from |
||||
|
* the kernel even after calls to unlink, rmdir or (when |
||||
|
* overwriting an existing file) rename. Filesystems must handle |
||||
|
* such requests properly and it is recommended to defer removal |
||||
|
* of the inode until the lookup count reaches zero. Calls to |
||||
|
* unlink, rmdir or rename will be followed closely by forget |
||||
|
* unless the file or directory is open, in which case the |
||||
|
* kernel issues forget only after the release or releasedir |
||||
|
* calls. |
||||
|
* |
||||
|
* Note that if a file system will be exported over NFS the |
||||
|
* inodes lifetime must extend even beyond forget. See the |
||||
|
* generation field in struct fuse_entry_param above. |
||||
|
* |
||||
|
* On unmount the lookup count for all inodes implicitly drops |
||||
|
* to zero. It is not guaranteed that the file system will |
||||
|
* receive corresponding forget messages for the affected |
||||
|
* inodes. |
||||
|
* |
||||
|
* Valid replies: |
||||
|
* fuse_reply_none |
||||
|
* |
||||
|
* @param req request handle |
||||
|
* @param ino the inode number |
||||
|
* @param nlookup the number of lookups to forget |
||||
|
*/ |
||||
|
/* |
||||
|
https://libfuse.github.io/doxygen/include_2fuse__lowlevel_8h.html
|
||||
|
|
||||
|
int fuse_reply_entry ( fuse_req_t req, |
||||
|
const struct fuse_entry_param * e |
||||
|
) |
||||
|
Reply with a directory entry |
||||
|
|
||||
|
Possible requests: lookup, mknod, mkdir, symlink, link |
||||
|
|
||||
|
Side effects: increments the lookup count on success |
||||
|
|
||||
|
*/ |
||||
|
func (wfs *WFS) Forget(nodeid, nlookup uint64) { |
||||
|
wfs.inodeToPath.Forget(nodeid, nlookup, func(dir util.FullPath) { |
||||
|
wfs.metaCache.DeleteFolderChildren(context.Background(), dir) |
||||
|
}) |
||||
|
} |
||||
@ -0,0 +1,93 @@ |
|||||
|
package mount |
||||
|
|
||||
|
import ( |
||||
|
"context" |
||||
|
"github.com/chrislusf/seaweedfs/weed/filer" |
||||
|
"github.com/chrislusf/seaweedfs/weed/glog" |
||||
|
"github.com/chrislusf/seaweedfs/weed/pb/filer_pb" |
||||
|
"github.com/chrislusf/seaweedfs/weed/util" |
||||
|
"github.com/hanwen/go-fuse/v2/fuse" |
||||
|
"time" |
||||
|
) |
||||
|
|
||||
|
const ( |
||||
|
HARD_LINK_MARKER = '\x01' |
||||
|
) |
||||
|
|
||||
|
/** Create a hard link to a file */ |
||||
|
func (wfs *WFS) Link(cancel <-chan struct{}, in *fuse.LinkIn, name string, out *fuse.EntryOut) (code fuse.Status) { |
||||
|
|
||||
|
if s := checkName(name); s != fuse.OK { |
||||
|
return s |
||||
|
} |
||||
|
|
||||
|
newParentPath := wfs.inodeToPath.GetPath(in.NodeId) |
||||
|
oldEntryPath := wfs.inodeToPath.GetPath(in.Oldnodeid) |
||||
|
oldParentPath, _ := oldEntryPath.DirAndName() |
||||
|
|
||||
|
oldEntry, status := wfs.maybeLoadEntry(oldEntryPath) |
||||
|
if status != fuse.OK { |
||||
|
return status |
||||
|
} |
||||
|
|
||||
|
// update old file to hardlink mode
|
||||
|
if len(oldEntry.HardLinkId) == 0 { |
||||
|
oldEntry.HardLinkId = append(util.RandomBytes(16), HARD_LINK_MARKER) |
||||
|
oldEntry.HardLinkCounter = 1 |
||||
|
} |
||||
|
oldEntry.HardLinkCounter++ |
||||
|
updateOldEntryRequest := &filer_pb.UpdateEntryRequest{ |
||||
|
Directory: oldParentPath, |
||||
|
Entry: oldEntry, |
||||
|
Signatures: []int32{wfs.signature}, |
||||
|
} |
||||
|
|
||||
|
// CreateLink 1.2 : update new file to hardlink mode
|
||||
|
oldEntry.Attributes.Mtime = time.Now().Unix() |
||||
|
request := &filer_pb.CreateEntryRequest{ |
||||
|
Directory: string(newParentPath), |
||||
|
Entry: &filer_pb.Entry{ |
||||
|
Name: name, |
||||
|
IsDirectory: false, |
||||
|
Attributes: oldEntry.Attributes, |
||||
|
Chunks: oldEntry.Chunks, |
||||
|
Extended: oldEntry.Extended, |
||||
|
HardLinkId: oldEntry.HardLinkId, |
||||
|
HardLinkCounter: oldEntry.HardLinkCounter, |
||||
|
}, |
||||
|
Signatures: []int32{wfs.signature}, |
||||
|
} |
||||
|
|
||||
|
// apply changes to the filer, and also apply to local metaCache
|
||||
|
err := wfs.WithFilerClient(false, func(client filer_pb.SeaweedFilerClient) error { |
||||
|
|
||||
|
wfs.mapPbIdFromLocalToFiler(request.Entry) |
||||
|
defer wfs.mapPbIdFromFilerToLocal(request.Entry) |
||||
|
|
||||
|
if err := filer_pb.UpdateEntry(client, updateOldEntryRequest); err != nil { |
||||
|
return err |
||||
|
} |
||||
|
wfs.metaCache.UpdateEntry(context.Background(), filer.FromPbEntry(updateOldEntryRequest.Directory, updateOldEntryRequest.Entry)) |
||||
|
|
||||
|
if err := filer_pb.CreateEntry(client, request); err != nil { |
||||
|
return err |
||||
|
} |
||||
|
|
||||
|
wfs.metaCache.InsertEntry(context.Background(), filer.FromPbEntry(request.Directory, request.Entry)) |
||||
|
|
||||
|
return nil |
||||
|
}) |
||||
|
|
||||
|
newEntryPath := newParentPath.Child(name) |
||||
|
|
||||
|
if err != nil { |
||||
|
glog.V(0).Infof("Link %v -> %s: %v", oldEntryPath, newEntryPath, err) |
||||
|
return fuse.EIO |
||||
|
} |
||||
|
|
||||
|
inode := wfs.inodeToPath.Lookup(newEntryPath, false) |
||||
|
|
||||
|
wfs.outputPbEntry(out, inode, request.Entry) |
||||
|
|
||||
|
return fuse.OK |
||||
|
} |
||||
@ -0,0 +1,235 @@ |
|||||
|
package mount |
||||
|
|
||||
|
import ( |
||||
|
"context" |
||||
|
"fmt" |
||||
|
"github.com/chrislusf/seaweedfs/weed/filer" |
||||
|
"github.com/chrislusf/seaweedfs/weed/glog" |
||||
|
"github.com/chrislusf/seaweedfs/weed/pb/filer_pb" |
||||
|
"github.com/chrislusf/seaweedfs/weed/util" |
||||
|
"github.com/hanwen/go-fuse/v2/fs" |
||||
|
"github.com/hanwen/go-fuse/v2/fuse" |
||||
|
"io" |
||||
|
"strings" |
||||
|
"syscall" |
||||
|
) |
||||
|
|
||||
|
/** Rename a file |
||||
|
* |
||||
|
* If the target exists it should be atomically replaced. If |
||||
|
* the target's inode's lookup count is non-zero, the file |
||||
|
* system is expected to postpone any removal of the inode |
||||
|
* until the lookup count reaches zero (see description of the |
||||
|
* forget function). |
||||
|
* |
||||
|
* If this request is answered with an error code of ENOSYS, this is |
||||
|
* treated as a permanent failure with error code EINVAL, i.e. all |
||||
|
* future bmap requests will fail with EINVAL without being |
||||
|
* send to the filesystem process. |
||||
|
* |
||||
|
* *flags* may be `RENAME_EXCHANGE` or `RENAME_NOREPLACE`. If |
||||
|
* RENAME_NOREPLACE is specified, the filesystem must not |
||||
|
* overwrite *newname* if it exists and return an error |
||||
|
* instead. If `RENAME_EXCHANGE` is specified, the filesystem |
||||
|
* must atomically exchange the two files, i.e. both must |
||||
|
* exist and neither may be deleted. |
||||
|
* |
||||
|
* Valid replies: |
||||
|
* fuse_reply_err |
||||
|
* |
||||
|
* @param req request handle |
||||
|
* @param parent inode number of the old parent directory |
||||
|
* @param name old name |
||||
|
* @param newparent inode number of the new parent directory |
||||
|
* @param newname new name |
||||
|
*/ |
||||
|
/* |
||||
|
renameat2() |
||||
|
renameat2() has an additional flags argument. A renameat2() call |
||||
|
with a zero flags argument is equivalent to renameat(). |
||||
|
|
||||
|
The flags argument is a bit mask consisting of zero or more of |
||||
|
the following flags: |
||||
|
|
||||
|
RENAME_EXCHANGE |
||||
|
Atomically exchange oldpath and newpath. Both pathnames |
||||
|
must exist but may be of different types (e.g., one could |
||||
|
be a non-empty directory and the other a symbolic link). |
||||
|
|
||||
|
RENAME_NOREPLACE |
||||
|
Don't overwrite newpath of the rename. Return an error if |
||||
|
newpath already exists. |
||||
|
|
||||
|
RENAME_NOREPLACE can't be employed together with |
||||
|
RENAME_EXCHANGE. |
||||
|
|
||||
|
RENAME_NOREPLACE requires support from the underlying |
||||
|
filesystem. Support for various filesystems was added as |
||||
|
follows: |
||||
|
|
||||
|
* ext4 (Linux 3.15); |
||||
|
|
||||
|
* btrfs, tmpfs, and cifs (Linux 3.17); |
||||
|
|
||||
|
* xfs (Linux 4.0); |
||||
|
|
||||
|
* Support for many other filesystems was added in Linux |
||||
|
4.9, including ext2, minix, reiserfs, jfs, vfat, and |
||||
|
bpf. |
||||
|
|
||||
|
RENAME_WHITEOUT (since Linux 3.18) |
||||
|
This operation makes sense only for overlay/union |
||||
|
filesystem implementations. |
||||
|
|
||||
|
Specifying RENAME_WHITEOUT creates a "whiteout" object at |
||||
|
the source of the rename at the same time as performing |
||||
|
the rename. The whole operation is atomic, so that if the |
||||
|
rename succeeds then the whiteout will also have been |
||||
|
created. |
||||
|
|
||||
|
A "whiteout" is an object that has special meaning in |
||||
|
union/overlay filesystem constructs. In these constructs, |
||||
|
multiple layers exist and only the top one is ever |
||||
|
modified. A whiteout on an upper layer will effectively |
||||
|
hide a matching file in the lower layer, making it appear |
||||
|
as if the file didn't exist. |
||||
|
|
||||
|
When a file that exists on the lower layer is renamed, the |
||||
|
file is first copied up (if not already on the upper |
||||
|
layer) and then renamed on the upper, read-write layer. |
||||
|
At the same time, the source file needs to be "whiteouted" |
||||
|
(so that the version of the source file in the lower layer |
||||
|
is rendered invisible). The whole operation needs to be |
||||
|
done atomically. |
||||
|
|
||||
|
When not part of a union/overlay, the whiteout appears as |
||||
|
a character device with a {0,0} device number. (Note that |
||||
|
other union/overlay implementations may employ different |
||||
|
methods for storing whiteout entries; specifically, BSD |
||||
|
union mount employs a separate inode type, DT_WHT, which, |
||||
|
while supported by some filesystems available in Linux, |
||||
|
such as CODA and XFS, is ignored by the kernel's whiteout |
||||
|
support code, as of Linux 4.19, at least.) |
||||
|
|
||||
|
RENAME_WHITEOUT requires the same privileges as creating a |
||||
|
device node (i.e., the CAP_MKNOD capability). |
||||
|
|
||||
|
RENAME_WHITEOUT can't be employed together with |
||||
|
RENAME_EXCHANGE. |
||||
|
|
||||
|
RENAME_WHITEOUT requires support from the underlying |
||||
|
filesystem. Among the filesystems that support it are |
||||
|
tmpfs (since Linux 3.18), ext4 (since Linux 3.18), XFS |
||||
|
(since Linux 4.1), f2fs (since Linux 4.2), btrfs (since |
||||
|
Linux 4.7), and ubifs (since Linux 4.9). |
||||
|
*/ |
||||
|
const ( |
||||
|
RenameEmptyFlag = 0 |
||||
|
RenameNoReplace = 1 |
||||
|
RenameExchange = fs.RENAME_EXCHANGE |
||||
|
RenameWhiteout = 3 |
||||
|
) |
||||
|
|
||||
|
func (wfs *WFS) Rename(cancel <-chan struct{}, in *fuse.RenameIn, oldName string, newName string) (code fuse.Status) { |
||||
|
if s := checkName(newName); s != fuse.OK { |
||||
|
return s |
||||
|
} |
||||
|
|
||||
|
switch in.Flags { |
||||
|
case RenameEmptyFlag: |
||||
|
case RenameNoReplace: |
||||
|
case RenameExchange: |
||||
|
case RenameWhiteout: |
||||
|
return fuse.ENOTSUP |
||||
|
default: |
||||
|
return fuse.EINVAL |
||||
|
} |
||||
|
|
||||
|
oldDir := wfs.inodeToPath.GetPath(in.NodeId) |
||||
|
oldPath := oldDir.Child(oldName) |
||||
|
newDir := wfs.inodeToPath.GetPath(in.Newdir) |
||||
|
newPath := newDir.Child(newName) |
||||
|
|
||||
|
glog.V(4).Infof("dir Rename %s => %s", oldPath, newPath) |
||||
|
|
||||
|
// update remote filer
|
||||
|
err := wfs.WithFilerClient(true, func(client filer_pb.SeaweedFilerClient) error { |
||||
|
ctx, cancel := context.WithCancel(context.Background()) |
||||
|
defer cancel() |
||||
|
|
||||
|
request := &filer_pb.StreamRenameEntryRequest{ |
||||
|
OldDirectory: string(oldDir), |
||||
|
OldName: oldName, |
||||
|
NewDirectory: string(newDir), |
||||
|
NewName: newName, |
||||
|
Signatures: []int32{wfs.signature}, |
||||
|
} |
||||
|
|
||||
|
stream, err := client.StreamRenameEntry(ctx, request) |
||||
|
if err != nil { |
||||
|
code = fuse.EIO |
||||
|
return fmt.Errorf("dir AtomicRenameEntry %s => %s : %v", oldPath, newPath, err) |
||||
|
} |
||||
|
|
||||
|
for { |
||||
|
resp, recvErr := stream.Recv() |
||||
|
if recvErr != nil { |
||||
|
if recvErr == io.EOF { |
||||
|
break |
||||
|
} else { |
||||
|
if strings.Contains(recvErr.Error(), "not empty") { |
||||
|
code = fuse.Status(syscall.ENOTEMPTY) |
||||
|
} else if strings.Contains(recvErr.Error(), "not directory") { |
||||
|
code = fuse.ENOTDIR |
||||
|
} |
||||
|
return fmt.Errorf("dir Rename %s => %s receive: %v", oldPath, newPath, recvErr) |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
if err = wfs.handleRenameResponse(ctx, resp); err != nil { |
||||
|
glog.V(0).Infof("dir Rename %s => %s : %v", oldPath, newPath, err) |
||||
|
return err |
||||
|
} |
||||
|
|
||||
|
} |
||||
|
|
||||
|
return nil |
||||
|
|
||||
|
}) |
||||
|
if err != nil { |
||||
|
glog.V(0).Infof("Link: %v", err) |
||||
|
return |
||||
|
} |
||||
|
|
||||
|
return fuse.OK |
||||
|
|
||||
|
} |
||||
|
|
||||
|
func (wfs *WFS) 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 := wfs.metaCache.AtomicUpdateEntryFromFiler(ctx, "", newEntry); err != nil { |
||||
|
return err |
||||
|
} |
||||
|
|
||||
|
oldParent, newParent := util.FullPath(resp.Directory), util.FullPath(resp.EventNotification.NewParentPath) |
||||
|
oldName, newName := resp.EventNotification.OldEntry.Name, resp.EventNotification.NewEntry.Name |
||||
|
|
||||
|
oldPath := oldParent.Child(oldName) |
||||
|
newPath := newParent.Child(newName) |
||||
|
|
||||
|
wfs.inodeToPath.MovePath(oldPath, newPath) |
||||
|
|
||||
|
} else if resp.EventNotification.OldEntry != nil { |
||||
|
// without new entry, only old entry name exists. This is the second step to delete old entry
|
||||
|
if err := wfs.metaCache.AtomicUpdateEntryFromFiler(ctx, util.NewFullPath(resp.Directory, resp.EventNotification.OldEntry.Name), nil); err != nil { |
||||
|
return err |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
return nil |
||||
|
|
||||
|
} |
||||
@ -0,0 +1,80 @@ |
|||||
|
package mount |
||||
|
|
||||
|
import ( |
||||
|
"context" |
||||
|
"fmt" |
||||
|
"github.com/chrislusf/seaweedfs/weed/glog" |
||||
|
"github.com/chrislusf/seaweedfs/weed/pb/filer_pb" |
||||
|
"github.com/hanwen/go-fuse/v2/fuse" |
||||
|
"math" |
||||
|
"time" |
||||
|
) |
||||
|
|
||||
|
const blockSize = 512 |
||||
|
|
||||
|
type statsCache struct { |
||||
|
filer_pb.StatisticsResponse |
||||
|
lastChecked int64 // unix time in seconds
|
||||
|
} |
||||
|
|
||||
|
func (wfs *WFS) StatFs(cancel <-chan struct{}, in *fuse.InHeader, out *fuse.StatfsOut) (code fuse.Status) { |
||||
|
|
||||
|
glog.V(4).Infof("reading fs stats") |
||||
|
|
||||
|
if wfs.stats.lastChecked < time.Now().Unix()-20 { |
||||
|
|
||||
|
err := wfs.WithFilerClient(false, func(client filer_pb.SeaweedFilerClient) error { |
||||
|
|
||||
|
request := &filer_pb.StatisticsRequest{ |
||||
|
Collection: wfs.option.Collection, |
||||
|
Replication: wfs.option.Replication, |
||||
|
Ttl: fmt.Sprintf("%ds", wfs.option.TtlSec), |
||||
|
DiskType: string(wfs.option.DiskType), |
||||
|
} |
||||
|
|
||||
|
glog.V(4).Infof("reading filer stats: %+v", request) |
||||
|
resp, err := client.Statistics(context.Background(), request) |
||||
|
if err != nil { |
||||
|
glog.V(0).Infof("reading filer stats %v: %v", request, err) |
||||
|
return err |
||||
|
} |
||||
|
glog.V(4).Infof("read filer stats: %+v", resp) |
||||
|
|
||||
|
wfs.stats.TotalSize = resp.TotalSize |
||||
|
wfs.stats.UsedSize = resp.UsedSize |
||||
|
wfs.stats.FileCount = resp.FileCount |
||||
|
wfs.stats.lastChecked = time.Now().Unix() |
||||
|
|
||||
|
return nil |
||||
|
}) |
||||
|
if err != nil { |
||||
|
glog.V(0).Infof("filer Statistics: %v", err) |
||||
|
return fuse.OK |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
totalDiskSize := wfs.stats.TotalSize |
||||
|
usedDiskSize := wfs.stats.UsedSize |
||||
|
actualFileCount := wfs.stats.FileCount |
||||
|
|
||||
|
// Compute the total number of available blocks
|
||||
|
out.Blocks = totalDiskSize / blockSize |
||||
|
|
||||
|
// Compute the number of used blocks
|
||||
|
numBlocks := uint64(usedDiskSize / blockSize) |
||||
|
|
||||
|
// Report the number of free and available blocks for the block size
|
||||
|
out.Bfree = out.Blocks - numBlocks |
||||
|
out.Bavail = out.Blocks - numBlocks |
||||
|
out.Bsize = uint32(blockSize) |
||||
|
|
||||
|
// Report the total number of possible files in the file system (and those free)
|
||||
|
out.Files = math.MaxInt64 |
||||
|
out.Ffree = math.MaxInt64 - actualFileCount |
||||
|
|
||||
|
// Report the maximum length of a name and the minimum fragment size
|
||||
|
out.NameLen = 1024 |
||||
|
out.Frsize = uint32(blockSize) |
||||
|
|
||||
|
return fuse.OK |
||||
|
} |
||||
@ -0,0 +1,78 @@ |
|||||
|
package mount |
||||
|
|
||||
|
import ( |
||||
|
"context" |
||||
|
"fmt" |
||||
|
"github.com/chrislusf/seaweedfs/weed/filer" |
||||
|
"github.com/chrislusf/seaweedfs/weed/glog" |
||||
|
"github.com/chrislusf/seaweedfs/weed/pb/filer_pb" |
||||
|
"github.com/hanwen/go-fuse/v2/fuse" |
||||
|
"os" |
||||
|
"time" |
||||
|
) |
||||
|
|
||||
|
/** Create a symbolic link */ |
||||
|
func (wfs *WFS) Symlink(cancel <-chan struct{}, header *fuse.InHeader, target string, name string, out *fuse.EntryOut) (code fuse.Status) { |
||||
|
|
||||
|
if s := checkName(name); s != fuse.OK { |
||||
|
return s |
||||
|
} |
||||
|
|
||||
|
dirPath := wfs.inodeToPath.GetPath(header.NodeId) |
||||
|
entryFullPath := dirPath.Child(name) |
||||
|
|
||||
|
request := &filer_pb.CreateEntryRequest{ |
||||
|
Directory: string(dirPath), |
||||
|
Entry: &filer_pb.Entry{ |
||||
|
Name: name, |
||||
|
IsDirectory: false, |
||||
|
Attributes: &filer_pb.FuseAttributes{ |
||||
|
Mtime: time.Now().Unix(), |
||||
|
Crtime: time.Now().Unix(), |
||||
|
FileMode: uint32((os.FileMode(0777) | os.ModeSymlink) &^ wfs.option.Umask), |
||||
|
Uid: header.Uid, |
||||
|
Gid: header.Gid, |
||||
|
SymlinkTarget: target, |
||||
|
}, |
||||
|
}, |
||||
|
Signatures: []int32{wfs.signature}, |
||||
|
} |
||||
|
|
||||
|
err := wfs.WithFilerClient(false, func(client filer_pb.SeaweedFilerClient) error { |
||||
|
|
||||
|
wfs.mapPbIdFromLocalToFiler(request.Entry) |
||||
|
defer wfs.mapPbIdFromFilerToLocal(request.Entry) |
||||
|
|
||||
|
if err := filer_pb.CreateEntry(client, request); err != nil { |
||||
|
return fmt.Errorf("symlink %s: %v", entryFullPath, err) |
||||
|
} |
||||
|
|
||||
|
wfs.metaCache.InsertEntry(context.Background(), filer.FromPbEntry(request.Directory, request.Entry)) |
||||
|
|
||||
|
return nil |
||||
|
}) |
||||
|
if err != nil { |
||||
|
glog.V(0).Infof("Symlink %s => %s: %v", entryFullPath, target, err) |
||||
|
return fuse.EIO |
||||
|
} |
||||
|
|
||||
|
inode := wfs.inodeToPath.Lookup(entryFullPath, false) |
||||
|
|
||||
|
wfs.outputPbEntry(out, inode, request.Entry) |
||||
|
|
||||
|
return fuse.OK |
||||
|
} |
||||
|
|
||||
|
func (wfs *WFS) Readlink(cancel <-chan struct{}, header *fuse.InHeader) (out []byte, code fuse.Status) { |
||||
|
entryFullPath := wfs.inodeToPath.GetPath(header.NodeId) |
||||
|
|
||||
|
entry, status := wfs.maybeLoadEntry(entryFullPath) |
||||
|
if status != fuse.OK { |
||||
|
return nil, status |
||||
|
} |
||||
|
if os.FileMode(entry.Attributes.FileMode)&os.ModeSymlink == 0 { |
||||
|
return nil, fuse.EINVAL |
||||
|
} |
||||
|
|
||||
|
return []byte(entry.Attributes.SymlinkTarget), fuse.OK |
||||
|
} |
||||
@ -0,0 +1,65 @@ |
|||||
|
package mount |
||||
|
|
||||
|
import "github.com/hanwen/go-fuse/v2/fuse" |
||||
|
|
||||
|
// https://github.com/libfuse/libfuse/blob/48ae2e72b39b6a31cb2194f6f11786b7ca06aac6/include/fuse.h#L778
|
||||
|
|
||||
|
/** |
||||
|
* Copy a range of data from one file to anotherNiels de Vos, 4 years ago: • libfuse: add copy_file_range() support |
||||
|
* |
||||
|
* Performs an optimized copy between two file descriptors without the |
||||
|
* additional cost of transferring data through the FUSE kernel module |
||||
|
* to user space (glibc) and then back into the FUSE filesystem again. |
||||
|
* |
||||
|
* In case this method is not implemented, applications are expected to |
||||
|
* fall back to a regular file copy. (Some glibc versions did this |
||||
|
* emulation automatically, but the emulation has been removed from all |
||||
|
* glibc release branches.) |
||||
|
*/ |
||||
|
func (wfs *WFS) CopyFileRange(cancel <-chan struct{}, in *fuse.CopyFileRangeIn) (written uint32, code fuse.Status) { |
||||
|
return 0, fuse.ENOSYS |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Allocates space for an open file |
||||
|
* |
||||
|
* This function ensures that required space is allocated for specified |
||||
|
* file. If this function returns success then any subsequent write |
||||
|
* request to specified range is guaranteed not to fail because of lack |
||||
|
* of space on the file system media. |
||||
|
*/ |
||||
|
func (wfs *WFS) Fallocate(cancel <-chan struct{}, in *fuse.FallocateIn) (code fuse.Status) { |
||||
|
return fuse.ENOSYS |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Find next data or hole after the specified offset |
||||
|
*/ |
||||
|
func (wfs *WFS) Lseek(cancel <-chan struct{}, in *fuse.LseekIn, out *fuse.LseekOut) fuse.Status { |
||||
|
return fuse.ENOSYS |
||||
|
} |
||||
|
|
||||
|
func (wfs *WFS) GetLk(cancel <-chan struct{}, in *fuse.LkIn, out *fuse.LkOut) (code fuse.Status) { |
||||
|
return fuse.ENOSYS |
||||
|
} |
||||
|
|
||||
|
func (wfs *WFS) SetLk(cancel <-chan struct{}, in *fuse.LkIn) (code fuse.Status) { |
||||
|
return fuse.ENOSYS |
||||
|
} |
||||
|
|
||||
|
func (wfs *WFS) SetLkw(cancel <-chan struct{}, in *fuse.LkIn) (code fuse.Status) { |
||||
|
return fuse.ENOSYS |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Check file access permissions |
||||
|
* |
||||
|
* This will be called for the access() system call. If the |
||||
|
* 'default_permissions' mount option is given, this method is not |
||||
|
* called. |
||||
|
* |
||||
|
* This method is not called under Linux kernel versions 2.4.x |
||||
|
*/ |
||||
|
func (wfs *WFS) Access(cancel <-chan struct{}, input *fuse.AccessIn) (code fuse.Status) { |
||||
|
return fuse.ENOSYS |
||||
|
} |
||||
@ -0,0 +1,84 @@ |
|||||
|
package mount |
||||
|
|
||||
|
import ( |
||||
|
"context" |
||||
|
"fmt" |
||||
|
"io" |
||||
|
|
||||
|
"github.com/chrislusf/seaweedfs/weed/filer" |
||||
|
"github.com/chrislusf/seaweedfs/weed/glog" |
||||
|
"github.com/chrislusf/seaweedfs/weed/operation" |
||||
|
"github.com/chrislusf/seaweedfs/weed/pb/filer_pb" |
||||
|
"github.com/chrislusf/seaweedfs/weed/security" |
||||
|
"github.com/chrislusf/seaweedfs/weed/util" |
||||
|
) |
||||
|
|
||||
|
func (wfs *WFS) saveDataAsChunk(fullPath util.FullPath) filer.SaveDataAsChunkFunctionType { |
||||
|
|
||||
|
return func(reader io.Reader, filename string, offset int64) (chunk *filer_pb.FileChunk, collection, replication string, err error) { |
||||
|
var fileId, host string |
||||
|
var auth security.EncodedJwt |
||||
|
|
||||
|
if err := wfs.WithFilerClient(false, func(client filer_pb.SeaweedFilerClient) error { |
||||
|
return util.Retry("assignVolume", func() error { |
||||
|
request := &filer_pb.AssignVolumeRequest{ |
||||
|
Count: 1, |
||||
|
Replication: wfs.option.Replication, |
||||
|
Collection: wfs.option.Collection, |
||||
|
TtlSec: wfs.option.TtlSec, |
||||
|
DiskType: string(wfs.option.DiskType), |
||||
|
DataCenter: wfs.option.DataCenter, |
||||
|
Path: string(fullPath), |
||||
|
} |
||||
|
|
||||
|
resp, err := client.AssignVolume(context.Background(), request) |
||||
|
if err != nil { |
||||
|
glog.V(0).Infof("assign volume failure %v: %v", request, err) |
||||
|
return err |
||||
|
} |
||||
|
if resp.Error != "" { |
||||
|
return fmt.Errorf("assign volume failure %v: %v", request, resp.Error) |
||||
|
} |
||||
|
|
||||
|
fileId, auth = resp.FileId, security.EncodedJwt(resp.Auth) |
||||
|
loc := resp.Location |
||||
|
host = wfs.AdjustedUrl(loc) |
||||
|
collection, replication = resp.Collection, resp.Replication |
||||
|
|
||||
|
return nil |
||||
|
}) |
||||
|
}); err != nil { |
||||
|
return nil, "", "", fmt.Errorf("filerGrpcAddress assign volume: %v", err) |
||||
|
} |
||||
|
|
||||
|
fileUrl := fmt.Sprintf("http://%s/%s", host, fileId) |
||||
|
if wfs.option.VolumeServerAccess == "filerProxy" { |
||||
|
fileUrl = fmt.Sprintf("http://%s/?proxyChunkId=%s", wfs.getCurrentFiler(), fileId) |
||||
|
} |
||||
|
uploadOption := &operation.UploadOption{ |
||||
|
UploadUrl: fileUrl, |
||||
|
Filename: filename, |
||||
|
Cipher: wfs.option.Cipher, |
||||
|
IsInputCompressed: false, |
||||
|
MimeType: "", |
||||
|
PairMap: nil, |
||||
|
Jwt: auth, |
||||
|
} |
||||
|
uploadResult, err, data := operation.Upload(reader, uploadOption) |
||||
|
if err != nil { |
||||
|
glog.V(0).Infof("upload data %v to %s: %v", filename, fileUrl, err) |
||||
|
return nil, "", "", fmt.Errorf("upload data: %v", err) |
||||
|
} |
||||
|
if uploadResult.Error != "" { |
||||
|
glog.V(0).Infof("upload failure %v to %s: %v", filename, fileUrl, err) |
||||
|
return nil, "", "", fmt.Errorf("upload result: %v", uploadResult.Error) |
||||
|
} |
||||
|
|
||||
|
if offset == 0 { |
||||
|
wfs.chunkCache.SetChunk(fileId, data) |
||||
|
} |
||||
|
|
||||
|
chunk = uploadResult.ToPbFileChunk(fileId, offset) |
||||
|
return chunk, collection, replication, nil |
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,168 @@ |
|||||
|
package mount |
||||
|
|
||||
|
import ( |
||||
|
"github.com/hanwen/go-fuse/v2/fuse" |
||||
|
sys "golang.org/x/sys/unix" |
||||
|
"runtime" |
||||
|
"strings" |
||||
|
"syscall" |
||||
|
) |
||||
|
|
||||
|
const ( |
||||
|
// https://man7.org/linux/man-pages/man7/xattr.7.html#:~:text=The%20VFS%20imposes%20limitations%20that,in%20listxattr(2)).
|
||||
|
MAX_XATTR_NAME_SIZE = 255 |
||||
|
MAX_XATTR_VALUE_SIZE = 65536 |
||||
|
XATTR_PREFIX = "xattr-" // same as filer
|
||||
|
) |
||||
|
|
||||
|
// GetXAttr reads an extended attribute, and should return the
|
||||
|
// number of bytes. If the buffer is too small, return ERANGE,
|
||||
|
// with the required buffer size.
|
||||
|
func (wfs *WFS) GetXAttr(cancel <-chan struct{}, header *fuse.InHeader, attr string, dest []byte) (size uint32, code fuse.Status) { |
||||
|
|
||||
|
//validate attr name
|
||||
|
if len(attr) > MAX_XATTR_NAME_SIZE { |
||||
|
if runtime.GOOS == "darwin" { |
||||
|
return 0, fuse.EPERM |
||||
|
} else { |
||||
|
return 0, fuse.ERANGE |
||||
|
} |
||||
|
} |
||||
|
if len(attr) == 0 { |
||||
|
return 0, fuse.EINVAL |
||||
|
} |
||||
|
|
||||
|
_, _, entry, status := wfs.maybeReadEntry(header.NodeId) |
||||
|
if status != fuse.OK { |
||||
|
return 0, status |
||||
|
} |
||||
|
if entry == nil { |
||||
|
return 0, fuse.ENOENT |
||||
|
} |
||||
|
if entry.Extended == nil { |
||||
|
return 0, fuse.ENOATTR |
||||
|
} |
||||
|
data, found := entry.Extended[XATTR_PREFIX+attr] |
||||
|
if !found { |
||||
|
return 0, fuse.ENOATTR |
||||
|
} |
||||
|
if len(dest) < len(data) { |
||||
|
return uint32(len(data)), fuse.ERANGE |
||||
|
} |
||||
|
copy(dest, data) |
||||
|
|
||||
|
return uint32(len(data)), fuse.OK |
||||
|
} |
||||
|
|
||||
|
// SetXAttr writes an extended attribute.
|
||||
|
// https://man7.org/linux/man-pages/man2/setxattr.2.html
|
||||
|
// By default (i.e., flags is zero), the extended attribute will be
|
||||
|
// created if it does not exist, or the value will be replaced if
|
||||
|
// the attribute already exists. To modify these semantics, one of
|
||||
|
// the following values can be specified in flags:
|
||||
|
//
|
||||
|
// XATTR_CREATE
|
||||
|
// Perform a pure create, which fails if the named attribute
|
||||
|
// exists already.
|
||||
|
//
|
||||
|
// XATTR_REPLACE
|
||||
|
// Perform a pure replace operation, which fails if the named
|
||||
|
// attribute does not already exist.
|
||||
|
func (wfs *WFS) SetXAttr(cancel <-chan struct{}, input *fuse.SetXAttrIn, attr string, data []byte) fuse.Status { |
||||
|
//validate attr name
|
||||
|
if len(attr) > MAX_XATTR_NAME_SIZE { |
||||
|
if runtime.GOOS == "darwin" { |
||||
|
return fuse.EPERM |
||||
|
} else { |
||||
|
return fuse.ERANGE |
||||
|
} |
||||
|
} |
||||
|
if len(attr) == 0 { |
||||
|
return fuse.EINVAL |
||||
|
} |
||||
|
//validate attr value
|
||||
|
if len(data) > MAX_XATTR_VALUE_SIZE { |
||||
|
if runtime.GOOS == "darwin" { |
||||
|
return fuse.Status(syscall.E2BIG) |
||||
|
} else { |
||||
|
return fuse.ERANGE |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
path, _, entry, status := wfs.maybeReadEntry(input.NodeId) |
||||
|
if status != fuse.OK { |
||||
|
return status |
||||
|
} |
||||
|
if entry.Extended == nil { |
||||
|
entry.Extended = make(map[string][]byte) |
||||
|
} |
||||
|
oldData, _ := entry.Extended[XATTR_PREFIX+attr] |
||||
|
switch input.Flags { |
||||
|
case sys.XATTR_CREATE: |
||||
|
if len(oldData) > 0 { |
||||
|
break |
||||
|
} |
||||
|
fallthrough |
||||
|
case sys.XATTR_REPLACE: |
||||
|
fallthrough |
||||
|
default: |
||||
|
entry.Extended[XATTR_PREFIX+attr] = data |
||||
|
} |
||||
|
|
||||
|
return wfs.saveEntry(path, entry) |
||||
|
|
||||
|
} |
||||
|
|
||||
|
// ListXAttr lists extended attributes as '\0' delimited byte
|
||||
|
// slice, and return the number of bytes. If the buffer is too
|
||||
|
// small, return ERANGE, with the required buffer size.
|
||||
|
func (wfs *WFS) ListXAttr(cancel <-chan struct{}, header *fuse.InHeader, dest []byte) (n uint32, code fuse.Status) { |
||||
|
_, _, entry, status := wfs.maybeReadEntry(header.NodeId) |
||||
|
if status != fuse.OK { |
||||
|
return 0, status |
||||
|
} |
||||
|
if entry == nil { |
||||
|
return 0, fuse.ENOENT |
||||
|
} |
||||
|
if entry.Extended == nil { |
||||
|
return 0, fuse.ENOATTR |
||||
|
} |
||||
|
|
||||
|
var data []byte |
||||
|
for k := range entry.Extended { |
||||
|
if strings.HasPrefix(k, XATTR_PREFIX) { |
||||
|
data = append(data, k[len(XATTR_PREFIX):]...) |
||||
|
data = append(data, 0) |
||||
|
} |
||||
|
} |
||||
|
if len(dest) < len(data) { |
||||
|
return uint32(len(data)), fuse.ERANGE |
||||
|
} |
||||
|
|
||||
|
copy(dest, data) |
||||
|
|
||||
|
return uint32(len(data)), fuse.OK |
||||
|
} |
||||
|
|
||||
|
// RemoveXAttr removes an extended attribute.
|
||||
|
func (wfs *WFS) RemoveXAttr(cancel <-chan struct{}, header *fuse.InHeader, attr string) fuse.Status { |
||||
|
if len(attr) == 0 { |
||||
|
return fuse.EINVAL |
||||
|
} |
||||
|
path, _, entry, status := wfs.maybeReadEntry(header.NodeId) |
||||
|
if status != fuse.OK { |
||||
|
return status |
||||
|
} |
||||
|
if entry.Extended == nil { |
||||
|
return fuse.ENOATTR |
||||
|
} |
||||
|
_, found := entry.Extended[XATTR_PREFIX+attr] |
||||
|
|
||||
|
if !found { |
||||
|
return fuse.ENOATTR |
||||
|
} |
||||
|
|
||||
|
delete(entry.Extended, XATTR_PREFIX+attr) |
||||
|
|
||||
|
return wfs.saveEntry(path, entry) |
||||
|
} |
||||
@ -0,0 +1,51 @@ |
|||||
|
package mount |
||||
|
|
||||
|
import ( |
||||
|
"github.com/chrislusf/seaweedfs/weed/glog" |
||||
|
"github.com/chrislusf/seaweedfs/weed/util" |
||||
|
"google.golang.org/grpc" |
||||
|
|
||||
|
"github.com/chrislusf/seaweedfs/weed/pb" |
||||
|
"github.com/chrislusf/seaweedfs/weed/pb/filer_pb" |
||||
|
) |
||||
|
|
||||
|
var _ = filer_pb.FilerClient(&WFS{}) |
||||
|
|
||||
|
func (wfs *WFS) WithFilerClient(streamingMode bool, fn func(filer_pb.SeaweedFilerClient) error) (err error) { |
||||
|
|
||||
|
return util.Retry("filer grpc", func() error { |
||||
|
|
||||
|
i := wfs.option.filerIndex |
||||
|
n := len(wfs.option.FilerAddresses) |
||||
|
for x := 0; x < n; x++ { |
||||
|
|
||||
|
filerGrpcAddress := wfs.option.FilerAddresses[i].ToGrpcAddress() |
||||
|
err = pb.WithGrpcClient(streamingMode, func(grpcConnection *grpc.ClientConn) error { |
||||
|
client := filer_pb.NewSeaweedFilerClient(grpcConnection) |
||||
|
return fn(client) |
||||
|
}, filerGrpcAddress, wfs.option.GrpcDialOption) |
||||
|
|
||||
|
if err != nil { |
||||
|
glog.V(0).Infof("WithFilerClient %d %v: %v", x, filerGrpcAddress, err) |
||||
|
} else { |
||||
|
wfs.option.filerIndex = i |
||||
|
return nil |
||||
|
} |
||||
|
|
||||
|
i++ |
||||
|
if i >= n { |
||||
|
i = 0 |
||||
|
} |
||||
|
|
||||
|
} |
||||
|
return err |
||||
|
}) |
||||
|
|
||||
|
} |
||||
|
|
||||
|
func (wfs *WFS) AdjustedUrl(location *filer_pb.Location) string { |
||||
|
if wfs.option.VolumeServerAccess == "publicUrl" { |
||||
|
return location.PublicUrl |
||||
|
} |
||||
|
return location.Url |
||||
|
} |
||||
@ -0,0 +1,67 @@ |
|||||
|
package mount |
||||
|
|
||||
|
import ( |
||||
|
"context" |
||||
|
"fmt" |
||||
|
"github.com/chrislusf/seaweedfs/weed/filer" |
||||
|
"github.com/chrislusf/seaweedfs/weed/glog" |
||||
|
"github.com/chrislusf/seaweedfs/weed/pb/filer_pb" |
||||
|
"github.com/chrislusf/seaweedfs/weed/util" |
||||
|
"github.com/hanwen/go-fuse/v2/fuse" |
||||
|
"syscall" |
||||
|
) |
||||
|
|
||||
|
func (wfs *WFS) saveEntry(path util.FullPath, entry *filer_pb.Entry) (code fuse.Status) { |
||||
|
|
||||
|
parentDir, _ := path.DirAndName() |
||||
|
|
||||
|
err := wfs.WithFilerClient(false, func(client filer_pb.SeaweedFilerClient) error { |
||||
|
|
||||
|
wfs.mapPbIdFromLocalToFiler(entry) |
||||
|
defer wfs.mapPbIdFromFilerToLocal(entry) |
||||
|
|
||||
|
request := &filer_pb.UpdateEntryRequest{ |
||||
|
Directory: parentDir, |
||||
|
Entry: entry, |
||||
|
Signatures: []int32{wfs.signature}, |
||||
|
} |
||||
|
|
||||
|
glog.V(1).Infof("save entry: %v", request) |
||||
|
_, err := client.UpdateEntry(context.Background(), request) |
||||
|
if err != nil { |
||||
|
return fmt.Errorf("UpdateEntry dir %s: %v", path, err) |
||||
|
} |
||||
|
|
||||
|
if err := wfs.metaCache.UpdateEntry(context.Background(), filer.FromPbEntry(request.Directory, request.Entry)); err != nil { |
||||
|
return fmt.Errorf("UpdateEntry dir %s: %v", path, err) |
||||
|
} |
||||
|
|
||||
|
return nil |
||||
|
}) |
||||
|
if err != nil { |
||||
|
glog.Errorf("saveEntry %s: %v", path, err) |
||||
|
return fuse.EIO |
||||
|
} |
||||
|
|
||||
|
return fuse.OK |
||||
|
} |
||||
|
|
||||
|
func (wfs *WFS) mapPbIdFromFilerToLocal(entry *filer_pb.Entry) { |
||||
|
if entry.Attributes == nil { |
||||
|
return |
||||
|
} |
||||
|
entry.Attributes.Uid, entry.Attributes.Gid = wfs.option.UidGidMapper.FilerToLocal(entry.Attributes.Uid, entry.Attributes.Gid) |
||||
|
} |
||||
|
func (wfs *WFS) mapPbIdFromLocalToFiler(entry *filer_pb.Entry) { |
||||
|
if entry.Attributes == nil { |
||||
|
return |
||||
|
} |
||||
|
entry.Attributes.Uid, entry.Attributes.Gid = wfs.option.UidGidMapper.LocalToFiler(entry.Attributes.Uid, entry.Attributes.Gid) |
||||
|
} |
||||
|
|
||||
|
func checkName(name string) fuse.Status { |
||||
|
if len(name) >= 256 { |
||||
|
return fuse.Status(syscall.ENAMETOOLONG) |
||||
|
} |
||||
|
return fuse.OK |
||||
|
} |
||||
Write
Preview
Loading…
Cancel
Save
Reference in new issue