You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

501 lines
13 KiB

7 years ago
5 years ago
7 years ago
7 years ago
6 years ago
5 years ago
5 years ago
5 years ago
5 years ago
6 years ago
5 years ago
5 years ago
6 years ago
5 years ago
6 years ago
4 years ago
4 years ago
5 years ago
4 years ago
4 years ago
5 years ago
5 years ago
4 years ago
5 years ago
5 years ago
4 years ago
5 years ago
5 years ago
5 years ago
5 years ago
5 years ago
5 years ago
5 years ago
5 years ago
5 years ago
5 years ago
5 years ago
5 years ago
5 years ago
5 years ago
5 years ago
5 years ago
5 years ago
5 years ago
5 years ago
5 years ago
4 years ago
  1. package filesys
  2. import (
  3. "bytes"
  4. "context"
  5. "math"
  6. "os"
  7. "strings"
  8. "time"
  9. "github.com/seaweedfs/fuse"
  10. "github.com/seaweedfs/fuse/fs"
  11. "github.com/chrislusf/seaweedfs/weed/filer2"
  12. "github.com/chrislusf/seaweedfs/weed/filesys/meta_cache"
  13. "github.com/chrislusf/seaweedfs/weed/glog"
  14. "github.com/chrislusf/seaweedfs/weed/pb/filer_pb"
  15. "github.com/chrislusf/seaweedfs/weed/util"
  16. )
  17. type Dir struct {
  18. name string
  19. wfs *WFS
  20. entry *filer_pb.Entry
  21. parent *Dir
  22. }
  23. var _ = fs.Node(&Dir{})
  24. var _ = fs.NodeCreater(&Dir{})
  25. var _ = fs.NodeMkdirer(&Dir{})
  26. var _ = fs.NodeFsyncer(&Dir{})
  27. var _ = fs.NodeRequestLookuper(&Dir{})
  28. var _ = fs.HandleReadDirAller(&Dir{})
  29. var _ = fs.NodeRemover(&Dir{})
  30. var _ = fs.NodeRenamer(&Dir{})
  31. var _ = fs.NodeSetattrer(&Dir{})
  32. var _ = fs.NodeGetxattrer(&Dir{})
  33. var _ = fs.NodeSetxattrer(&Dir{})
  34. var _ = fs.NodeRemovexattrer(&Dir{})
  35. var _ = fs.NodeListxattrer(&Dir{})
  36. var _ = fs.NodeForgetter(&Dir{})
  37. func (dir *Dir) Attr(ctx context.Context, attr *fuse.Attr) error {
  38. // https://github.com/bazil/fuse/issues/196
  39. attr.Valid = time.Second
  40. if dir.FullPath() == dir.wfs.option.FilerMountRootPath {
  41. dir.setRootDirAttributes(attr)
  42. glog.V(3).Infof("root dir Attr %s, attr: %+v", dir.FullPath(), attr)
  43. return nil
  44. }
  45. if err := dir.maybeLoadEntry(); err != nil {
  46. glog.V(3).Infof("dir Attr %s,err: %+v", dir.FullPath(), err)
  47. return err
  48. }
  49. attr.Inode = util.FullPath(dir.FullPath()).AsInode()
  50. attr.Mode = os.FileMode(dir.entry.Attributes.FileMode) | os.ModeDir
  51. attr.Mtime = time.Unix(dir.entry.Attributes.Mtime, 0)
  52. attr.Crtime = time.Unix(dir.entry.Attributes.Crtime, 0)
  53. attr.Gid = dir.entry.Attributes.Gid
  54. attr.Uid = dir.entry.Attributes.Uid
  55. glog.V(5).Infof("dir Attr %s, attr: %+v", dir.FullPath(), attr)
  56. return nil
  57. }
  58. func (dir *Dir) Getxattr(ctx context.Context, req *fuse.GetxattrRequest, resp *fuse.GetxattrResponse) error {
  59. glog.V(4).Infof("dir Getxattr %s", dir.FullPath())
  60. if err := dir.maybeLoadEntry(); err != nil {
  61. return err
  62. }
  63. return getxattr(dir.entry, req, resp)
  64. }
  65. func (dir *Dir) setRootDirAttributes(attr *fuse.Attr) {
  66. attr.Inode = 1 // filer2.FullPath(dir.Path).AsInode()
  67. attr.Valid = time.Hour
  68. attr.Uid = dir.wfs.option.MountUid
  69. attr.Gid = dir.wfs.option.MountGid
  70. attr.Mode = dir.wfs.option.MountMode
  71. attr.Crtime = dir.wfs.option.MountCtime
  72. attr.Ctime = dir.wfs.option.MountCtime
  73. attr.Mtime = dir.wfs.option.MountMtime
  74. attr.Atime = dir.wfs.option.MountMtime
  75. attr.BlockSize = 1024 * 1024
  76. }
  77. func (dir *Dir) Fsync(ctx context.Context, req *fuse.FsyncRequest) error {
  78. // fsync works at OS level
  79. // write the file chunks to the filerGrpcAddress
  80. glog.V(3).Infof("dir %s fsync %+v", dir.FullPath(), req)
  81. return nil
  82. }
  83. func (dir *Dir) newFile(name string, entry *filer_pb.Entry) fs.Node {
  84. f := dir.wfs.fsNodeCache.EnsureFsNode(util.NewFullPath(dir.FullPath(), name), func() fs.Node {
  85. return &File{
  86. Name: name,
  87. dir: dir,
  88. wfs: dir.wfs,
  89. entry: entry,
  90. entryViewCache: nil,
  91. }
  92. })
  93. f.(*File).dir = dir // in case dir node was created later
  94. return f
  95. }
  96. func (dir *Dir) newDirectory(fullpath util.FullPath, entry *filer_pb.Entry) fs.Node {
  97. d := dir.wfs.fsNodeCache.EnsureFsNode(fullpath, func() fs.Node {
  98. return &Dir{name: entry.Name, wfs: dir.wfs, entry: entry, parent: dir}
  99. })
  100. d.(*Dir).parent = dir // in case dir node was created later
  101. return d
  102. }
  103. func (dir *Dir) Create(ctx context.Context, req *fuse.CreateRequest,
  104. resp *fuse.CreateResponse) (fs.Node, fs.Handle, error) {
  105. request := &filer_pb.CreateEntryRequest{
  106. Directory: dir.FullPath(),
  107. Entry: &filer_pb.Entry{
  108. Name: req.Name,
  109. IsDirectory: req.Mode&os.ModeDir > 0,
  110. Attributes: &filer_pb.FuseAttributes{
  111. Mtime: time.Now().Unix(),
  112. Crtime: time.Now().Unix(),
  113. FileMode: uint32(req.Mode &^ dir.wfs.option.Umask),
  114. Uid: req.Uid,
  115. Gid: req.Gid,
  116. Collection: dir.wfs.option.Collection,
  117. Replication: dir.wfs.option.Replication,
  118. TtlSec: dir.wfs.option.TtlSec,
  119. },
  120. },
  121. OExcl: req.Flags&fuse.OpenExclusive != 0,
  122. Signatures: []int32{dir.wfs.signature},
  123. }
  124. glog.V(1).Infof("create %s/%s: %v", dir.FullPath(), req.Name, req.Flags)
  125. if err := dir.wfs.WithFilerClient(func(client filer_pb.SeaweedFilerClient) error {
  126. if err := filer_pb.CreateEntry(client, request); err != nil {
  127. if strings.Contains(err.Error(), "EEXIST") {
  128. return fuse.EEXIST
  129. }
  130. return fuse.EIO
  131. }
  132. dir.wfs.metaCache.InsertEntry(context.Background(), filer2.FromPbEntry(request.Directory, request.Entry))
  133. return nil
  134. }); err != nil {
  135. return nil, nil, err
  136. }
  137. var node fs.Node
  138. if request.Entry.IsDirectory {
  139. node = dir.newDirectory(util.NewFullPath(dir.FullPath(), req.Name), request.Entry)
  140. return node, nil, nil
  141. }
  142. node = dir.newFile(req.Name, request.Entry)
  143. file := node.(*File)
  144. fh := dir.wfs.AcquireHandle(file, req.Uid, req.Gid)
  145. return file, fh, nil
  146. }
  147. func (dir *Dir) Mkdir(ctx context.Context, req *fuse.MkdirRequest) (fs.Node, error) {
  148. glog.V(4).Infof("mkdir %s: %s", dir.FullPath(), req.Name)
  149. newEntry := &filer_pb.Entry{
  150. Name: req.Name,
  151. IsDirectory: true,
  152. Attributes: &filer_pb.FuseAttributes{
  153. Mtime: time.Now().Unix(),
  154. Crtime: time.Now().Unix(),
  155. FileMode: uint32(req.Mode &^ dir.wfs.option.Umask),
  156. Uid: req.Uid,
  157. Gid: req.Gid,
  158. },
  159. }
  160. err := dir.wfs.WithFilerClient(func(client filer_pb.SeaweedFilerClient) error {
  161. request := &filer_pb.CreateEntryRequest{
  162. Directory: dir.FullPath(),
  163. Entry: newEntry,
  164. Signatures: []int32{dir.wfs.signature},
  165. }
  166. glog.V(1).Infof("mkdir: %v", request)
  167. if err := filer_pb.CreateEntry(client, request); err != nil {
  168. glog.V(0).Infof("mkdir %s/%s: %v", dir.FullPath(), req.Name, err)
  169. return err
  170. }
  171. dir.wfs.metaCache.InsertEntry(context.Background(), filer2.FromPbEntry(request.Directory, request.Entry))
  172. return nil
  173. })
  174. if err == nil {
  175. node := dir.newDirectory(util.NewFullPath(dir.FullPath(), req.Name), newEntry)
  176. return node, nil
  177. }
  178. glog.V(0).Infof("mkdir %s/%s: %v", dir.FullPath(), req.Name, err)
  179. return nil, fuse.EIO
  180. }
  181. func (dir *Dir) Lookup(ctx context.Context, req *fuse.LookupRequest, resp *fuse.LookupResponse) (node fs.Node, err error) {
  182. glog.V(5).Infof("dir Lookup %s: %s by %s", dir.FullPath(), req.Name, req.Header.String())
  183. fullFilePath := util.NewFullPath(dir.FullPath(), req.Name)
  184. dirPath := util.FullPath(dir.FullPath())
  185. meta_cache.EnsureVisited(dir.wfs.metaCache, dir.wfs, util.FullPath(dirPath))
  186. cachedEntry, cacheErr := dir.wfs.metaCache.FindEntry(context.Background(), fullFilePath)
  187. if cacheErr == filer_pb.ErrNotFound {
  188. return nil, fuse.ENOENT
  189. }
  190. entry := cachedEntry.ToProtoEntry()
  191. if entry == nil {
  192. // glog.V(3).Infof("dir Lookup cache miss %s", fullFilePath)
  193. entry, err = filer_pb.GetEntry(dir.wfs, fullFilePath)
  194. if err != nil {
  195. glog.V(1).Infof("dir GetEntry %s: %v", fullFilePath, err)
  196. return nil, fuse.ENOENT
  197. }
  198. } else {
  199. glog.V(5).Infof("dir Lookup cache hit %s", fullFilePath)
  200. }
  201. if entry != nil {
  202. if entry.IsDirectory {
  203. node = dir.newDirectory(fullFilePath, entry)
  204. } else {
  205. node = dir.newFile(req.Name, entry)
  206. }
  207. // resp.EntryValid = time.Second
  208. resp.Attr.Inode = fullFilePath.AsInode()
  209. resp.Attr.Valid = time.Second
  210. resp.Attr.Mtime = time.Unix(entry.Attributes.Mtime, 0)
  211. resp.Attr.Crtime = time.Unix(entry.Attributes.Crtime, 0)
  212. resp.Attr.Mode = os.FileMode(entry.Attributes.FileMode)
  213. resp.Attr.Gid = entry.Attributes.Gid
  214. resp.Attr.Uid = entry.Attributes.Uid
  215. return node, nil
  216. }
  217. glog.V(4).Infof("not found dir GetEntry %s: %v", fullFilePath, err)
  218. return nil, fuse.ENOENT
  219. }
  220. func (dir *Dir) ReadDirAll(ctx context.Context) (ret []fuse.Dirent, err error) {
  221. glog.V(5).Infof("dir ReadDirAll %s", dir.FullPath())
  222. processEachEntryFn := func(entry *filer_pb.Entry, isLast bool) error {
  223. fullpath := util.NewFullPath(dir.FullPath(), entry.Name)
  224. inode := fullpath.AsInode()
  225. if entry.IsDirectory {
  226. dirent := fuse.Dirent{Inode: inode, Name: entry.Name, Type: fuse.DT_Dir}
  227. ret = append(ret, dirent)
  228. } else {
  229. dirent := fuse.Dirent{Inode: inode, Name: entry.Name, Type: fuse.DT_File}
  230. ret = append(ret, dirent)
  231. }
  232. return nil
  233. }
  234. dirPath := util.FullPath(dir.FullPath())
  235. meta_cache.EnsureVisited(dir.wfs.metaCache, dir.wfs, dirPath)
  236. listedEntries, listErr := dir.wfs.metaCache.ListDirectoryEntries(context.Background(), util.FullPath(dir.FullPath()), "", false, int(math.MaxInt32))
  237. if listErr != nil {
  238. glog.Errorf("list meta cache: %v", listErr)
  239. return nil, fuse.EIO
  240. }
  241. for _, cachedEntry := range listedEntries {
  242. processEachEntryFn(cachedEntry.ToProtoEntry(), false)
  243. }
  244. return
  245. }
  246. func (dir *Dir) Remove(ctx context.Context, req *fuse.RemoveRequest) error {
  247. if !req.Dir {
  248. return dir.removeOneFile(req)
  249. }
  250. return dir.removeFolder(req)
  251. }
  252. func (dir *Dir) removeOneFile(req *fuse.RemoveRequest) error {
  253. filePath := util.NewFullPath(dir.FullPath(), req.Name)
  254. entry, err := filer_pb.GetEntry(dir.wfs, filePath)
  255. if err != nil {
  256. return err
  257. }
  258. if entry == nil {
  259. return nil
  260. }
  261. // first, ensure the filer store can correctly delete
  262. glog.V(3).Infof("remove file: %v", req)
  263. err = filer_pb.Remove(dir.wfs, dir.FullPath(), req.Name, false, false, false, false, dir.wfs.signature)
  264. if err != nil {
  265. glog.V(3).Infof("not found remove file %s/%s: %v", dir.FullPath(), req.Name, err)
  266. return fuse.ENOENT
  267. }
  268. // then, delete meta cache and fsNode cache
  269. dir.wfs.metaCache.DeleteEntry(context.Background(), filePath)
  270. dir.wfs.fsNodeCache.DeleteFsNode(filePath)
  271. // delete the chunks last
  272. dir.wfs.deleteFileChunks(entry.Chunks)
  273. return nil
  274. }
  275. func (dir *Dir) removeFolder(req *fuse.RemoveRequest) error {
  276. glog.V(3).Infof("remove directory entry: %v", req)
  277. err := filer_pb.Remove(dir.wfs, dir.FullPath(), req.Name, true, false, false, false, dir.wfs.signature)
  278. if err != nil {
  279. glog.V(0).Infof("remove %s/%s: %v", dir.FullPath(), req.Name, err)
  280. if strings.Contains(err.Error(), "non-empty") {
  281. return fuse.EEXIST
  282. }
  283. return fuse.ENOENT
  284. }
  285. t := util.NewFullPath(dir.FullPath(), req.Name)
  286. dir.wfs.metaCache.DeleteEntry(context.Background(), t)
  287. dir.wfs.fsNodeCache.DeleteFsNode(t)
  288. return nil
  289. }
  290. func (dir *Dir) Setattr(ctx context.Context, req *fuse.SetattrRequest, resp *fuse.SetattrResponse) error {
  291. glog.V(4).Infof("%v dir setattr %+v", dir.FullPath(), req)
  292. if err := dir.maybeLoadEntry(); err != nil {
  293. return err
  294. }
  295. if req.Valid.Mode() {
  296. dir.entry.Attributes.FileMode = uint32(req.Mode)
  297. }
  298. if req.Valid.Uid() {
  299. dir.entry.Attributes.Uid = req.Uid
  300. }
  301. if req.Valid.Gid() {
  302. dir.entry.Attributes.Gid = req.Gid
  303. }
  304. if req.Valid.Mtime() {
  305. dir.entry.Attributes.Mtime = req.Mtime.Unix()
  306. }
  307. return dir.saveEntry()
  308. }
  309. func (dir *Dir) Setxattr(ctx context.Context, req *fuse.SetxattrRequest) error {
  310. glog.V(4).Infof("dir Setxattr %s: %s", dir.FullPath(), req.Name)
  311. if err := dir.maybeLoadEntry(); err != nil {
  312. return err
  313. }
  314. if err := setxattr(dir.entry, req); err != nil {
  315. return err
  316. }
  317. return dir.saveEntry()
  318. }
  319. func (dir *Dir) Removexattr(ctx context.Context, req *fuse.RemovexattrRequest) error {
  320. glog.V(4).Infof("dir Removexattr %s: %s", dir.FullPath(), req.Name)
  321. if err := dir.maybeLoadEntry(); err != nil {
  322. return err
  323. }
  324. if err := removexattr(dir.entry, req); err != nil {
  325. return err
  326. }
  327. return dir.saveEntry()
  328. }
  329. func (dir *Dir) Listxattr(ctx context.Context, req *fuse.ListxattrRequest, resp *fuse.ListxattrResponse) error {
  330. glog.V(4).Infof("dir Listxattr %s", dir.FullPath())
  331. if err := dir.maybeLoadEntry(); err != nil {
  332. return err
  333. }
  334. if err := listxattr(dir.entry, req, resp); err != nil {
  335. return err
  336. }
  337. return nil
  338. }
  339. func (dir *Dir) Forget() {
  340. glog.V(5).Infof("Forget dir %s", dir.FullPath())
  341. dir.wfs.fsNodeCache.DeleteFsNode(util.FullPath(dir.FullPath()))
  342. }
  343. func (dir *Dir) maybeLoadEntry() error {
  344. if dir.entry == nil {
  345. parentDirPath, name := util.FullPath(dir.FullPath()).DirAndName()
  346. entry, err := dir.wfs.maybeLoadEntry(parentDirPath, name)
  347. if err != nil {
  348. return err
  349. }
  350. dir.entry = entry
  351. }
  352. return nil
  353. }
  354. func (dir *Dir) saveEntry() error {
  355. parentDir, name := util.FullPath(dir.FullPath()).DirAndName()
  356. return dir.wfs.WithFilerClient(func(client filer_pb.SeaweedFilerClient) error {
  357. request := &filer_pb.UpdateEntryRequest{
  358. Directory: parentDir,
  359. Entry: dir.entry,
  360. Signatures: []int32{dir.wfs.signature},
  361. }
  362. glog.V(1).Infof("save dir entry: %v", request)
  363. _, err := client.UpdateEntry(context.Background(), request)
  364. if err != nil {
  365. glog.Errorf("UpdateEntry dir %s/%s: %v", parentDir, name, err)
  366. return fuse.EIO
  367. }
  368. dir.wfs.metaCache.UpdateEntry(context.Background(), filer2.FromPbEntry(request.Directory, request.Entry))
  369. return nil
  370. })
  371. }
  372. func (dir *Dir) FullPath() string {
  373. var parts []string
  374. for p := dir; p != nil; p = p.parent {
  375. if strings.HasPrefix(p.name, "/") {
  376. if len(p.name) > 1 {
  377. parts = append(parts, p.name[1:])
  378. }
  379. } else {
  380. parts = append(parts, p.name)
  381. }
  382. }
  383. if len(parts) == 0 {
  384. return "/"
  385. }
  386. var buf bytes.Buffer
  387. for i := len(parts) - 1; i >= 0; i-- {
  388. buf.WriteString("/")
  389. buf.WriteString(parts[i])
  390. }
  391. return buf.String()
  392. }