2018-05-06 05:47:16 +00:00
|
|
|
package filesys
|
|
|
|
|
2018-05-08 08:59:43 +00:00
|
|
|
import (
|
2018-11-23 07:05:22 +00:00
|
|
|
"context"
|
2018-11-08 15:37:34 +00:00
|
|
|
"fmt"
|
2018-11-23 07:05:22 +00:00
|
|
|
"math"
|
2018-12-29 07:36:13 +00:00
|
|
|
"os"
|
2020-01-24 09:40:51 +00:00
|
|
|
"strings"
|
2018-11-08 15:37:34 +00:00
|
|
|
"sync"
|
|
|
|
"time"
|
|
|
|
|
2019-12-13 18:05:43 +00:00
|
|
|
"github.com/karlseguin/ccache"
|
|
|
|
"google.golang.org/grpc"
|
|
|
|
|
2020-01-20 07:59:46 +00:00
|
|
|
"github.com/chrislusf/seaweedfs/weed/filer2"
|
2018-06-06 09:09:57 +00:00
|
|
|
"github.com/chrislusf/seaweedfs/weed/glog"
|
2018-07-22 00:39:10 +00:00
|
|
|
"github.com/chrislusf/seaweedfs/weed/pb/filer_pb"
|
2018-07-04 02:07:55 +00:00
|
|
|
"github.com/chrislusf/seaweedfs/weed/util"
|
2019-01-01 10:33:57 +00:00
|
|
|
"github.com/seaweedfs/fuse"
|
|
|
|
"github.com/seaweedfs/fuse/fs"
|
2018-05-08 08:59:43 +00:00
|
|
|
)
|
2018-05-06 05:47:16 +00:00
|
|
|
|
2018-07-22 08:14:36 +00:00
|
|
|
type Option struct {
|
|
|
|
FilerGrpcAddress string
|
2019-02-18 20:11:52 +00:00
|
|
|
GrpcDialOption grpc.DialOption
|
2018-07-22 08:14:36 +00:00
|
|
|
FilerMountRootPath string
|
|
|
|
Collection string
|
|
|
|
Replication string
|
|
|
|
TtlSec int32
|
|
|
|
ChunkSizeLimit int64
|
|
|
|
DataCenter string
|
2019-12-13 18:22:24 +00:00
|
|
|
DirListCacheLimit int64
|
2018-11-08 15:37:34 +00:00
|
|
|
EntryCacheTtl time.Duration
|
2019-07-24 07:03:05 +00:00
|
|
|
Umask os.FileMode
|
2018-12-29 07:36:13 +00:00
|
|
|
|
2019-05-29 04:29:07 +00:00
|
|
|
MountUid uint32
|
|
|
|
MountGid uint32
|
|
|
|
MountMode os.FileMode
|
2019-05-10 22:03:31 +00:00
|
|
|
MountCtime time.Time
|
|
|
|
MountMtime time.Time
|
2018-07-22 08:14:36 +00:00
|
|
|
}
|
|
|
|
|
2018-11-23 07:05:22 +00:00
|
|
|
var _ = fs.FS(&WFS{})
|
|
|
|
var _ = fs.FSStatfser(&WFS{})
|
|
|
|
|
2018-05-06 05:47:16 +00:00
|
|
|
type WFS struct {
|
2018-07-22 08:14:36 +00:00
|
|
|
option *Option
|
2018-05-14 09:02:17 +00:00
|
|
|
listDirectoryEntriesCache *ccache.Cache
|
2018-06-06 09:09:57 +00:00
|
|
|
|
2020-01-21 04:21:01 +00:00
|
|
|
// contains all open handles, protected by handlesLock
|
2020-01-24 09:40:51 +00:00
|
|
|
handlesLock sync.Mutex
|
|
|
|
handles []*FileHandle
|
2020-01-22 21:42:03 +00:00
|
|
|
pathToHandleIndex map[filer2.FullPath]int
|
2020-01-21 04:21:01 +00:00
|
|
|
|
|
|
|
bufPool sync.Pool
|
2018-11-15 07:31:39 +00:00
|
|
|
|
2018-11-23 08:24:51 +00:00
|
|
|
stats statsCache
|
2020-01-21 04:21:01 +00:00
|
|
|
|
|
|
|
// nodes, protected by nodesLock
|
|
|
|
nodesLock sync.Mutex
|
|
|
|
nodes map[uint64]fs.Node
|
|
|
|
root fs.Node
|
2018-11-23 08:24:51 +00:00
|
|
|
}
|
|
|
|
type statsCache struct {
|
|
|
|
filer_pb.StatisticsResponse
|
|
|
|
lastChecked int64 // unix time in seconds
|
2018-05-06 05:47:16 +00:00
|
|
|
}
|
|
|
|
|
2018-07-22 08:14:36 +00:00
|
|
|
func NewSeaweedFileSystem(option *Option) *WFS {
|
2019-01-01 10:33:57 +00:00
|
|
|
wfs := &WFS{
|
2018-11-04 19:59:08 +00:00
|
|
|
option: option,
|
2019-12-13 18:22:24 +00:00
|
|
|
listDirectoryEntriesCache: ccache.New(ccache.Configure().MaxSize(option.DirListCacheLimit * 3).ItemsToPrune(100)),
|
2020-01-22 21:42:03 +00:00
|
|
|
pathToHandleIndex: make(map[filer2.FullPath]int),
|
2018-12-28 11:27:48 +00:00
|
|
|
bufPool: sync.Pool{
|
|
|
|
New: func() interface{} {
|
|
|
|
return make([]byte, option.ChunkSizeLimit)
|
|
|
|
},
|
|
|
|
},
|
2020-01-21 04:21:01 +00:00
|
|
|
nodes: make(map[uint64]fs.Node),
|
2018-05-06 05:47:16 +00:00
|
|
|
}
|
2019-01-01 10:33:57 +00:00
|
|
|
|
2020-01-21 04:21:01 +00:00
|
|
|
wfs.root = &Dir{Path: wfs.option.FilerMountRootPath, wfs: wfs}
|
|
|
|
|
2019-01-01 10:33:57 +00:00
|
|
|
return wfs
|
2018-05-06 05:47:16 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
func (wfs *WFS) Root() (fs.Node, error) {
|
2020-01-21 04:21:01 +00:00
|
|
|
return wfs.root, nil
|
2018-05-06 05:47:16 +00:00
|
|
|
}
|
2018-05-08 08:59:43 +00:00
|
|
|
|
2020-01-26 22:42:11 +00:00
|
|
|
func (wfs *WFS) WithFilerClient(ctx context.Context, fn func(context.Context, filer_pb.SeaweedFilerClient) error) error {
|
2018-05-08 08:59:43 +00:00
|
|
|
|
2020-01-26 22:42:11 +00:00
|
|
|
err := util.WithCachedGrpcClient(ctx, func(ctx2 context.Context, grpcConnection *grpc.ClientConn) error {
|
2018-12-07 09:25:01 +00:00
|
|
|
client := filer_pb.NewSeaweedFilerClient(grpcConnection)
|
2020-01-26 22:42:11 +00:00
|
|
|
return fn(ctx2, client)
|
2019-02-18 20:11:52 +00:00
|
|
|
}, wfs.option.FilerGrpcAddress, wfs.option.GrpcDialOption)
|
2018-05-08 08:59:43 +00:00
|
|
|
|
2020-01-24 09:40:51 +00:00
|
|
|
if err == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
if strings.Contains(err.Error(), "context canceled") {
|
2020-02-26 01:24:08 +00:00
|
|
|
glog.V(0).Infoln("retry context canceled request...")
|
2020-01-26 22:42:11 +00:00
|
|
|
return util.WithCachedGrpcClient(context.Background(), func(ctx2 context.Context, grpcConnection *grpc.ClientConn) error {
|
2020-01-24 09:40:51 +00:00
|
|
|
client := filer_pb.NewSeaweedFilerClient(grpcConnection)
|
2020-01-26 22:42:11 +00:00
|
|
|
return fn(ctx2, client)
|
2020-01-24 09:40:51 +00:00
|
|
|
}, wfs.option.FilerGrpcAddress, wfs.option.GrpcDialOption)
|
|
|
|
}
|
|
|
|
return err
|
|
|
|
|
2018-05-08 08:59:43 +00:00
|
|
|
}
|
2018-06-06 09:09:57 +00:00
|
|
|
|
2018-07-22 08:14:36 +00:00
|
|
|
func (wfs *WFS) AcquireHandle(file *File, uid, gid uint32) (fileHandle *FileHandle) {
|
2018-06-06 09:09:57 +00:00
|
|
|
|
|
|
|
fullpath := file.fullpath()
|
2020-01-21 04:21:01 +00:00
|
|
|
glog.V(4).Infof("%s AcquireHandle uid=%d gid=%d", fullpath, uid, gid)
|
2018-06-06 09:09:57 +00:00
|
|
|
|
2020-01-21 04:21:01 +00:00
|
|
|
wfs.handlesLock.Lock()
|
|
|
|
defer wfs.handlesLock.Unlock()
|
2018-06-06 09:09:57 +00:00
|
|
|
|
2020-01-22 21:42:03 +00:00
|
|
|
index, found := wfs.pathToHandleIndex[fullpath]
|
|
|
|
if found && wfs.handles[index] != nil {
|
|
|
|
glog.V(2).Infoln(fullpath, "found fileHandle id", index)
|
|
|
|
return wfs.handles[index]
|
|
|
|
}
|
|
|
|
|
2018-11-15 06:48:54 +00:00
|
|
|
fileHandle = newFileHandle(file, uid, gid)
|
2018-06-06 09:09:57 +00:00
|
|
|
for i, h := range wfs.handles {
|
|
|
|
if h == nil {
|
2018-07-22 08:14:36 +00:00
|
|
|
wfs.handles[i] = fileHandle
|
|
|
|
fileHandle.handle = uint64(i)
|
2020-01-22 21:42:03 +00:00
|
|
|
wfs.pathToHandleIndex[fullpath] = i
|
2020-01-24 09:40:51 +00:00
|
|
|
glog.V(4).Infof("%s reuse fh %d", fullpath, fileHandle.handle)
|
2018-06-06 09:09:57 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-07-22 08:14:36 +00:00
|
|
|
wfs.handles = append(wfs.handles, fileHandle)
|
|
|
|
fileHandle.handle = uint64(len(wfs.handles) - 1)
|
2020-01-22 21:42:03 +00:00
|
|
|
wfs.pathToHandleIndex[fullpath] = int(fileHandle.handle)
|
2020-01-24 09:40:51 +00:00
|
|
|
glog.V(4).Infof("%s new fh %d", fullpath, fileHandle.handle)
|
2018-06-06 09:09:57 +00:00
|
|
|
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2020-01-20 07:59:46 +00:00
|
|
|
func (wfs *WFS) ReleaseHandle(fullpath filer2.FullPath, handleId fuse.HandleID) {
|
2020-01-21 04:21:01 +00:00
|
|
|
wfs.handlesLock.Lock()
|
|
|
|
defer wfs.handlesLock.Unlock()
|
2018-06-06 09:09:57 +00:00
|
|
|
|
2020-01-21 04:21:01 +00:00
|
|
|
glog.V(4).Infof("%s ReleaseHandle id %d current handles length %d", fullpath, handleId, len(wfs.handles))
|
2020-01-22 21:42:03 +00:00
|
|
|
delete(wfs.pathToHandleIndex, fullpath)
|
2018-06-06 09:09:57 +00:00
|
|
|
if int(handleId) < len(wfs.handles) {
|
|
|
|
wfs.handles[int(handleId)] = nil
|
|
|
|
}
|
|
|
|
|
|
|
|
return
|
|
|
|
}
|
2018-11-23 07:05:22 +00:00
|
|
|
|
|
|
|
// Statfs is called to obtain file system metadata. Implements fuse.FSStatfser
|
|
|
|
func (wfs *WFS) Statfs(ctx context.Context, req *fuse.StatfsRequest, resp *fuse.StatfsResponse) error {
|
|
|
|
|
|
|
|
glog.V(4).Infof("reading fs stats: %+v", req)
|
|
|
|
|
2018-11-23 08:24:51 +00:00
|
|
|
if wfs.stats.lastChecked < time.Now().Unix()-20 {
|
|
|
|
|
2020-01-26 22:42:11 +00:00
|
|
|
err := wfs.WithFilerClient(ctx, func(ctx context.Context, client filer_pb.SeaweedFilerClient) error {
|
2018-11-23 08:24:51 +00:00
|
|
|
|
|
|
|
request := &filer_pb.StatisticsRequest{
|
|
|
|
Collection: wfs.option.Collection,
|
|
|
|
Replication: wfs.option.Replication,
|
|
|
|
Ttl: fmt.Sprintf("%ds", wfs.option.TtlSec),
|
|
|
|
}
|
|
|
|
|
|
|
|
glog.V(4).Infof("reading filer stats: %+v", request)
|
|
|
|
resp, err := client.Statistics(ctx, 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 err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
totalDiskSize := wfs.stats.TotalSize
|
|
|
|
usedDiskSize := wfs.stats.UsedSize
|
|
|
|
actualFileCount := wfs.stats.FileCount
|
2018-11-23 07:05:22 +00:00
|
|
|
|
|
|
|
// Compute the total number of available blocks
|
|
|
|
resp.Blocks = totalDiskSize / blockSize
|
|
|
|
|
|
|
|
// Compute the number of used blocks
|
2019-01-17 01:17:19 +00:00
|
|
|
numBlocks := uint64(usedDiskSize / blockSize)
|
2018-11-23 07:05:22 +00:00
|
|
|
|
|
|
|
// Report the number of free and available blocks for the block size
|
2019-01-17 01:17:19 +00:00
|
|
|
resp.Bfree = resp.Blocks - numBlocks
|
|
|
|
resp.Bavail = resp.Blocks - numBlocks
|
2018-11-23 07:05:22 +00:00
|
|
|
resp.Bsize = uint32(blockSize)
|
|
|
|
|
|
|
|
// Report the total number of possible files in the file system (and those free)
|
|
|
|
resp.Files = math.MaxInt64
|
|
|
|
resp.Ffree = math.MaxInt64 - actualFileCount
|
|
|
|
|
|
|
|
// Report the maximum length of a name and the minimum fragment size
|
|
|
|
resp.Namelen = 1024
|
|
|
|
resp.Frsize = uint32(blockSize)
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
2020-01-20 07:59:46 +00:00
|
|
|
|
|
|
|
func (wfs *WFS) cacheGet(path filer2.FullPath) *filer_pb.Entry {
|
|
|
|
item := wfs.listDirectoryEntriesCache.Get(string(path))
|
|
|
|
if item != nil && !item.Expired() {
|
|
|
|
return item.Value().(*filer_pb.Entry)
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
func (wfs *WFS) cacheSet(path filer2.FullPath, entry *filer_pb.Entry, ttl time.Duration) {
|
|
|
|
if entry == nil {
|
|
|
|
wfs.listDirectoryEntriesCache.Delete(string(path))
|
2020-01-21 04:21:01 +00:00
|
|
|
} else {
|
2020-01-20 07:59:46 +00:00
|
|
|
wfs.listDirectoryEntriesCache.Set(string(path), entry, ttl)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
func (wfs *WFS) cacheDelete(path filer2.FullPath) {
|
|
|
|
wfs.listDirectoryEntriesCache.Delete(string(path))
|
|
|
|
}
|
2020-01-21 04:21:01 +00:00
|
|
|
|
|
|
|
func (wfs *WFS) getNode(fullpath filer2.FullPath, fn func() fs.Node) fs.Node {
|
|
|
|
wfs.nodesLock.Lock()
|
|
|
|
defer wfs.nodesLock.Unlock()
|
|
|
|
|
|
|
|
node, found := wfs.nodes[fullpath.AsInode()]
|
|
|
|
if found {
|
|
|
|
return node
|
|
|
|
}
|
|
|
|
node = fn()
|
|
|
|
if node != nil {
|
|
|
|
wfs.nodes[fullpath.AsInode()] = node
|
|
|
|
}
|
|
|
|
return node
|
|
|
|
}
|
|
|
|
|
|
|
|
func (wfs *WFS) forgetNode(fullpath filer2.FullPath) {
|
|
|
|
wfs.nodesLock.Lock()
|
|
|
|
defer wfs.nodesLock.Unlock()
|
|
|
|
|
|
|
|
delete(wfs.nodes, fullpath.AsInode())
|
|
|
|
|
|
|
|
}
|