seaweedfs/weed/filesys/wfs.go

319 lines
8.6 KiB
Go
Raw Normal View History

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"
"fmt"
"github.com/chrislusf/seaweedfs/weed/pb"
2018-11-23 07:05:22 +00:00
"math"
2021-05-21 08:41:34 +00:00
"math/rand"
"os"
"path"
"sync"
"time"
2021-06-02 17:30:55 +00:00
"github.com/chrislusf/seaweedfs/weed/filer"
"github.com/chrislusf/seaweedfs/weed/storage/types"
"github.com/chrislusf/seaweedfs/weed/wdclient"
2020-06-28 17:14:17 +00:00
"google.golang.org/grpc"
2020-06-11 08:50:00 +00:00
2020-06-28 17:18:32 +00:00
"github.com/chrislusf/seaweedfs/weed/util/grace"
"github.com/seaweedfs/fuse"
"github.com/seaweedfs/fuse/fs"
"github.com/chrislusf/seaweedfs/weed/filesys/meta_cache"
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"
2020-03-23 07:01:34 +00:00
"github.com/chrislusf/seaweedfs/weed/util"
2020-04-11 19:45:24 +00:00
"github.com/chrislusf/seaweedfs/weed/util/chunk_cache"
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 {
MountDirectory string
FilerAddresses []pb.ServerAddress
filerIndex int
2020-04-12 04:12:41 +00:00
GrpcDialOption grpc.DialOption
FilerMountRootPath string
Collection string
Replication string
TtlSec int32
2021-02-16 10:47:02 +00:00
DiskType types.DiskType
2020-04-12 04:12:41 +00:00
ChunkSizeLimit int64
ConcurrentWriters int
2020-04-12 04:12:41 +00:00
CacheDir string
CacheSizeMB int64
DataCenter string
Umask os.FileMode
2021-06-02 17:30:55 +00:00
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
2022-02-16 08:37:24 +00:00
uniqueCacheDir string
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 {
2020-07-11 13:16:17 +00:00
option *Option
2018-06-06 09:09:57 +00:00
// contains all open handles, protected by handlesLock
2020-04-08 19:50:20 +00:00
handlesLock sync.Mutex
handles map[uint64]*FileHandle
bufPool sync.Pool
stats statsCache
2020-03-26 05:19:19 +00:00
root fs.Node
2020-08-10 04:56:09 +00:00
fsNodeCache *FsCache
2020-08-18 03:15:53 +00:00
chunkCache *chunk_cache.TieredChunkCache
metaCache *meta_cache.MetaCache
signature int32
// throttle writers
concurrentWriters *util.LimitedConcurrentExecutor
Server *fs.Server
}
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{
2020-07-11 13:16:17 +00:00
option: option,
handles: make(map[uint64]*FileHandle),
2018-12-28 11:27:48 +00:00
bufPool: sync.Pool{
New: func() interface{} {
return make([]byte, option.ChunkSizeLimit)
},
},
signature: util.RandomInt32(),
2020-04-12 07:52:54 +00:00
}
2021-05-21 08:41:34 +00:00
wfs.option.filerIndex = rand.Intn(len(option.FilerAddresses))
wfs.option.setupUniqueCacheDirectory()
2020-04-12 07:52:54 +00:00
if option.CacheSizeMB > 0 {
wfs.chunkCache = chunk_cache.NewTieredChunkCache(256, option.getUniqueCacheDir(), option.CacheSizeMB, 1024*1024)
2018-05-06 05:47:16 +00:00
}
2020-06-28 17:18:32 +00:00
wfs.metaCache = meta_cache.NewMetaCache(path.Join(option.getUniqueCacheDir(), "meta"), util.FullPath(option.FilerMountRootPath), option.UidGidMapper, func(filePath util.FullPath, entry *filer_pb.Entry) {
2021-04-17 17:48:22 +00:00
fsNode := NodeWithId(filePath.AsInode(entry.FileMode()))
if err := wfs.Server.InvalidateNodeData(fsNode); err != nil {
glog.V(4).Infof("InvalidateNodeData %s : %v", filePath, err)
}
dir, name := filePath.DirAndName()
parent := NodeWithId(util.FullPath(dir).AsInode(os.ModeDir))
if dir == option.FilerMountRootPath {
parent = NodeWithId(1)
}
if err := wfs.Server.InvalidateEntry(parent, name); err != nil {
glog.V(4).Infof("InvalidateEntry %s : %v", filePath, err)
}
})
2020-07-11 06:03:22 +00:00
grace.OnInterrupt(func() {
wfs.metaCache.Shutdown()
2022-02-16 08:39:21 +00:00
os.RemoveAll(option.getUniqueCacheDir())
2020-07-11 06:03:22 +00:00
})
2019-01-01 10:33:57 +00:00
wfs.root = &Dir{name: wfs.option.FilerMountRootPath, wfs: wfs, id: 1}
2020-08-10 04:56:09 +00:00
wfs.fsNodeCache = newFsCache(wfs.root)
if wfs.option.ConcurrentWriters > 0 {
wfs.concurrentWriters = util.NewLimitedConcurrentExecutor(wfs.option.ConcurrentWriters)
}
2019-01-01 10:33:57 +00:00
return wfs
2018-05-06 05:47:16 +00:00
}
func (wfs *WFS) StartBackgroundTasks() {
startTime := time.Now()
go meta_cache.SubscribeMetaEvents(wfs.metaCache, wfs.signature, wfs, wfs.option.FilerMountRootPath, startTime.UnixNano())
}
2018-05-06 05:47:16 +00:00
func (wfs *WFS) Root() (fs.Node, error) {
return wfs.root, nil
2018-05-06 05:47:16 +00:00
}
2018-05-08 08:59:43 +00:00
2021-12-20 09:11:43 +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-08-16 02:55:28 +00:00
glog.V(4).Infof("AcquireHandle %s uid=%d gid=%d", fullpath, uid, gid)
2018-06-06 09:09:57 +00:00
2021-04-17 17:48:22 +00:00
inodeId := file.Id()
2018-06-06 09:09:57 +00:00
2021-04-17 17:48:22 +00:00
wfs.handlesLock.Lock()
existingHandle, found := wfs.handles[inodeId]
2021-08-11 13:58:35 +00:00
if found && existingHandle != nil && existingHandle.f.isOpen > 0 {
2021-04-17 17:48:22 +00:00
existingHandle.f.isOpen++
2021-08-11 13:58:35 +00:00
wfs.handlesLock.Unlock()
glog.V(4).Infof("Reuse AcquiredHandle %s open %d", fullpath, existingHandle.f.isOpen)
2021-04-17 17:48:22 +00:00
return existingHandle
}
2021-08-11 13:58:35 +00:00
wfs.handlesLock.Unlock()
entry, _ := file.maybeLoadEntry(context.Background())
file.entry = entry
2021-12-20 09:11:43 +00:00
fileHandle = newFileHandle(file, uid, gid)
2021-04-17 17:48:22 +00:00
wfs.handlesLock.Lock()
2021-08-11 13:58:35 +00:00
file.isOpen++
2020-04-08 19:50:20 +00:00
wfs.handles[inodeId] = fileHandle
2021-04-17 17:48:22 +00:00
wfs.handlesLock.Unlock()
2020-04-08 19:50:20 +00:00
fileHandle.handle = inodeId
2018-06-06 09:09:57 +00:00
2021-04-17 17:48:22 +00:00
glog.V(4).Infof("Acquired new Handle %s open %d", fullpath, file.isOpen)
2018-06-06 09:09:57 +00:00
return
}
func (wfs *WFS) Fsync(file *File, header fuse.Header) error {
inodeId := file.Id()
wfs.handlesLock.Lock()
existingHandle, found := wfs.handles[inodeId]
wfs.handlesLock.Unlock()
2022-01-15 13:45:29 +00:00
if found && existingHandle != nil {
existingHandle.Lock()
defer existingHandle.Unlock()
2022-01-15 13:45:29 +00:00
if existingHandle.f.isOpen > 0 {
return existingHandle.doFlush(context.Background(), header)
}
}
return nil
}
2020-03-23 07:01:34 +00:00
func (wfs *WFS) ReleaseHandle(fullpath util.FullPath, handleId fuse.HandleID) {
wfs.handlesLock.Lock()
defer wfs.handlesLock.Unlock()
2018-06-06 09:09:57 +00:00
2021-04-17 17:48:22 +00:00
glog.V(4).Infof("ReleaseHandle %s id %d current handles length %d", fullpath, handleId, len(wfs.handles))
2020-04-08 19:50:20 +00:00
2021-04-17 17:48:22 +00:00
delete(wfs.handles, uint64(handleId))
2018-06-06 09:09:57 +00:00
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 {
2020-08-31 03:12:04 +00:00
glog.V(4).Infof("reading fs stats: %+v", req)
2018-11-23 07:05:22 +00:00
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),
2020-12-16 17:14:05 +00:00
DiskType: string(wfs.option.DiskType),
}
2020-08-31 03:12:04 +00:00
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
}
2020-08-31 03:12:04 +00:00
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
}
func (wfs *WFS) mapPbIdFromFilerToLocal(entry *filer_pb.Entry) {
2020-09-24 10:06:44 +00:00
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) {
2020-09-24 10:06:44 +00:00
if entry.Attributes == nil {
return
}
entry.Attributes.Uid, entry.Attributes.Gid = wfs.option.UidGidMapper.LocalToFiler(entry.Attributes.Uid, entry.Attributes.Gid)
}
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)
}
func (option *Option) getUniqueCacheDir() string {
return option.uniqueCacheDir
}
type NodeWithId uint64
2021-05-06 10:37:51 +00:00
func (n NodeWithId) Id() uint64 {
return uint64(n)
}
func (n NodeWithId) Attr(ctx context.Context, attr *fuse.Attr) error {
return nil
}