seaweedfs/weed/filesys/wfs.go

261 lines
7.0 KiB
Go
Raw Normal View History

2018-05-06 13:47:16 +08:00
package filesys
2018-05-08 16:59:43 +08:00
import (
2018-11-23 15:05:22 +08:00
"context"
"fmt"
2018-11-23 15:05:22 +08:00
"math"
"os"
"path"
"strings"
"sync"
"time"
"github.com/chrislusf/seaweedfs/weed/util/grace"
"github.com/karlseguin/ccache"
"google.golang.org/grpc"
"github.com/chrislusf/seaweedfs/weed/filesys/meta_cache"
2018-06-06 17:09:57 +08:00
"github.com/chrislusf/seaweedfs/weed/glog"
2020-03-04 16:39:47 +08:00
"github.com/chrislusf/seaweedfs/weed/pb"
2018-07-22 08:39:10 +08:00
"github.com/chrislusf/seaweedfs/weed/pb/filer_pb"
2020-03-23 15:01:34 +08:00
"github.com/chrislusf/seaweedfs/weed/util"
2020-04-12 03:45:24 +08:00
"github.com/chrislusf/seaweedfs/weed/util/chunk_cache"
2019-01-01 18:33:57 +08:00
"github.com/seaweedfs/fuse"
"github.com/seaweedfs/fuse/fs"
2018-05-08 16:59:43 +08:00
)
2018-05-06 13:47:16 +08:00
2018-07-22 16:14:36 +08:00
type Option struct {
2020-04-12 12:12:41 +08:00
FilerGrpcAddress string
GrpcDialOption grpc.DialOption
FilerMountRootPath string
Collection string
Replication string
TtlSec int32
ChunkSizeLimit int64
CacheDir string
CacheSizeMB int64
DataCenter string
DirListCacheLimit int64
EntryCacheTtl time.Duration
Umask os.FileMode
2019-05-29 12:29:07 +08:00
MountUid uint32
MountGid uint32
MountMode os.FileMode
2019-05-11 06:03:31 +08:00
MountCtime time.Time
MountMtime time.Time
OutsideContainerClusterMode bool // whether the mount runs outside SeaweedFS containers
Cipher bool // whether encrypt data on volume server
AsyncMetaDataCaching bool // whether asynchronously cache meta data
2018-07-22 16:14:36 +08:00
}
2018-11-23 15:05:22 +08:00
var _ = fs.FS(&WFS{})
var _ = fs.FSStatfser(&WFS{})
2018-05-06 13:47:16 +08:00
type WFS struct {
2018-07-22 16:14:36 +08:00
option *Option
listDirectoryEntriesCache *ccache.Cache
2018-06-06 17:09:57 +08:00
// contains all open handles, protected by handlesLock
2020-04-09 03:50:20 +08:00
handlesLock sync.Mutex
handles map[uint64]*FileHandle
bufPool sync.Pool
stats statsCache
2020-03-26 13:19:19 +08:00
root fs.Node
fsNodeCache *FsCache
2020-04-12 03:45:24 +08:00
chunkCache *chunk_cache.ChunkCache
metaCache *meta_cache.MetaCache
}
type statsCache struct {
filer_pb.StatisticsResponse
lastChecked int64 // unix time in seconds
2018-05-06 13:47:16 +08:00
}
2018-07-22 16:14:36 +08:00
func NewSeaweedFileSystem(option *Option) *WFS {
2019-01-01 18:33:57 +08:00
wfs := &WFS{
2018-11-05 03:59:08 +08:00
option: option,
listDirectoryEntriesCache: ccache.New(ccache.Configure().MaxSize(option.DirListCacheLimit * 3).ItemsToPrune(100)),
2020-04-09 03:50:20 +08:00
handles: make(map[uint64]*FileHandle),
2018-12-28 19:27:48 +08:00
bufPool: sync.Pool{
New: func() interface{} {
return make([]byte, option.ChunkSizeLimit)
},
},
2020-04-12 15:52:54 +08:00
}
if option.CacheSizeMB > 0 {
wfs.chunkCache = chunk_cache.NewChunkCache(256, option.CacheDir, option.CacheSizeMB)
grace.OnInterrupt(func() {
2020-04-12 15:52:54 +08:00
wfs.chunkCache.Shutdown()
})
2018-05-06 13:47:16 +08:00
}
if wfs.option.AsyncMetaDataCaching {
wfs.metaCache = meta_cache.NewMetaCache(path.Join(option.CacheDir, "meta"))
startTime := time.Now()
if err := meta_cache.InitMetaCache(wfs.metaCache, wfs, wfs.option.FilerMountRootPath); err != nil {
glog.V(0).Infof("failed to init meta cache: %v", err)
} else {
go meta_cache.SubscribeMetaEvents(wfs.metaCache, wfs, wfs.option.FilerMountRootPath, startTime.UnixNano())
grace.OnInterrupt(func() {
wfs.metaCache.Shutdown()
})
}
}
2019-01-01 18:33:57 +08:00
wfs.root = &Dir{name: wfs.option.FilerMountRootPath, wfs: wfs}
2020-03-26 13:19:19 +08:00
wfs.fsNodeCache = newFsCache(wfs.root)
2019-01-01 18:33:57 +08:00
return wfs
2018-05-06 13:47:16 +08:00
}
func (wfs *WFS) Root() (fs.Node, error) {
return wfs.root, nil
2018-05-06 13:47:16 +08:00
}
2018-05-08 16:59:43 +08:00
2020-04-30 04:26:02 +08:00
var _ = filer_pb.FilerClient(&WFS{})
func (wfs *WFS) WithFilerClient(fn func(filer_pb.SeaweedFilerClient) error) error {
2018-05-08 16:59:43 +08:00
2020-03-04 16:39:47 +08:00
err := pb.WithCachedGrpcClient(func(grpcConnection *grpc.ClientConn) error {
2018-12-07 17:25:01 +08:00
client := filer_pb.NewSeaweedFilerClient(grpcConnection)
return fn(client)
2019-02-19 04:11:52 +08:00
}, wfs.option.FilerGrpcAddress, wfs.option.GrpcDialOption)
2018-05-08 16:59:43 +08:00
2020-01-24 17:40:51 +08:00
if err == nil {
return nil
}
return err
2018-05-08 16:59:43 +08:00
}
2018-06-06 17:09:57 +08:00
2018-07-22 16:14:36 +08:00
func (wfs *WFS) AcquireHandle(file *File, uid, gid uint32) (fileHandle *FileHandle) {
2018-06-06 17:09:57 +08:00
fullpath := file.fullpath()
glog.V(4).Infof("%s AcquireHandle uid=%d gid=%d", fullpath, uid, gid)
2018-06-06 17:09:57 +08:00
wfs.handlesLock.Lock()
defer wfs.handlesLock.Unlock()
2018-06-06 17:09:57 +08:00
2020-04-09 03:50:20 +08:00
inodeId := file.fullpath().AsInode()
existingHandle, found := wfs.handles[inodeId]
if found && existingHandle != nil {
return existingHandle
}
2018-11-15 14:48:54 +08:00
fileHandle = newFileHandle(file, uid, gid)
2020-04-09 03:50:20 +08:00
wfs.handles[inodeId] = fileHandle
fileHandle.handle = inodeId
2020-01-24 17:40:51 +08:00
glog.V(4).Infof("%s new fh %d", fullpath, fileHandle.handle)
2018-06-06 17:09:57 +08:00
return
}
2020-03-23 15:01:34 +08:00
func (wfs *WFS) ReleaseHandle(fullpath util.FullPath, handleId fuse.HandleID) {
wfs.handlesLock.Lock()
defer wfs.handlesLock.Unlock()
2018-06-06 17:09:57 +08:00
glog.V(4).Infof("%s ReleaseHandle id %d current handles length %d", fullpath, handleId, len(wfs.handles))
2020-04-09 03:50:20 +08:00
delete(wfs.handles, fullpath.AsInode())
2018-06-06 17:09:57 +08:00
return
}
2018-11-23 15:05:22 +08: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)
if wfs.stats.lastChecked < time.Now().Unix()-20 {
err := wfs.WithFilerClient(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),
}
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 err
}
}
totalDiskSize := wfs.stats.TotalSize
usedDiskSize := wfs.stats.UsedSize
actualFileCount := wfs.stats.FileCount
2018-11-23 15:05:22 +08:00
// Compute the total number of available blocks
resp.Blocks = totalDiskSize / blockSize
// Compute the number of used blocks
2019-01-17 09:17:19 +08:00
numBlocks := uint64(usedDiskSize / blockSize)
2018-11-23 15:05:22 +08:00
// Report the number of free and available blocks for the block size
2019-01-17 09:17:19 +08:00
resp.Bfree = resp.Blocks - numBlocks
resp.Bavail = resp.Blocks - numBlocks
2018-11-23 15:05:22 +08: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 15:59:46 +08:00
2020-03-23 15:01:34 +08:00
func (wfs *WFS) cacheGet(path util.FullPath) *filer_pb.Entry {
2020-01-20 15:59:46 +08:00
item := wfs.listDirectoryEntriesCache.Get(string(path))
if item != nil && !item.Expired() {
return item.Value().(*filer_pb.Entry)
}
return nil
}
2020-03-23 15:01:34 +08:00
func (wfs *WFS) cacheSet(path util.FullPath, entry *filer_pb.Entry, ttl time.Duration) {
2020-01-20 15:59:46 +08:00
if entry == nil {
wfs.listDirectoryEntriesCache.Delete(string(path))
} else {
2020-01-20 15:59:46 +08:00
wfs.listDirectoryEntriesCache.Set(string(path), entry, ttl)
}
}
2020-03-23 15:01:34 +08:00
func (wfs *WFS) cacheDelete(path util.FullPath) {
2020-01-20 15:59:46 +08:00
wfs.listDirectoryEntriesCache.Delete(string(path))
}
func (wfs *WFS) AdjustedUrl(hostAndPort string) string {
if !wfs.option.OutsideContainerClusterMode {
return hostAndPort
}
commaIndex := strings.Index(hostAndPort, ":")
if commaIndex < 0 {
return hostAndPort
}
filerCommaIndex := strings.Index(wfs.option.FilerGrpcAddress, ":")
return fmt.Sprintf("%s:%s", wfs.option.FilerGrpcAddress[:filerCommaIndex], hostAndPort[commaIndex+1:])
}