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.

502 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
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
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(4).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. glog.V(0).Infof("create %s/%s: %v", dir.FullPath(), req.Name, err)
  131. return fuse.EIO
  132. }
  133. dir.wfs.metaCache.InsertEntry(context.Background(), filer2.FromPbEntry(request.Directory, request.Entry))
  134. return nil
  135. }); err != nil {
  136. return nil, nil, err
  137. }
  138. var node fs.Node
  139. if request.Entry.IsDirectory {
  140. node = dir.newDirectory(util.NewFullPath(dir.FullPath(), req.Name), request.Entry)
  141. return node, nil, nil
  142. }
  143. node = dir.newFile(req.Name, request.Entry)
  144. file := node.(*File)
  145. fh := dir.wfs.AcquireHandle(file, req.Uid, req.Gid)
  146. return file, fh, nil
  147. }
  148. func (dir *Dir) Mkdir(ctx context.Context, req *fuse.MkdirRequest) (fs.Node, error) {
  149. glog.V(4).Infof("mkdir %s: %s", dir.FullPath(), req.Name)
  150. newEntry := &filer_pb.Entry{
  151. Name: req.Name,
  152. IsDirectory: true,
  153. Attributes: &filer_pb.FuseAttributes{
  154. Mtime: time.Now().Unix(),
  155. Crtime: time.Now().Unix(),
  156. FileMode: uint32(req.Mode &^ dir.wfs.option.Umask),
  157. Uid: req.Uid,
  158. Gid: req.Gid,
  159. },
  160. }
  161. err := dir.wfs.WithFilerClient(func(client filer_pb.SeaweedFilerClient) error {
  162. request := &filer_pb.CreateEntryRequest{
  163. Directory: dir.FullPath(),
  164. Entry: newEntry,
  165. Signatures: []int32{dir.wfs.signature},
  166. }
  167. glog.V(1).Infof("mkdir: %v", request)
  168. if err := filer_pb.CreateEntry(client, request); err != nil {
  169. glog.V(0).Infof("mkdir %s/%s: %v", dir.FullPath(), req.Name, err)
  170. return err
  171. }
  172. dir.wfs.metaCache.InsertEntry(context.Background(), filer2.FromPbEntry(request.Directory, request.Entry))
  173. return nil
  174. })
  175. if err == nil {
  176. node := dir.newDirectory(util.NewFullPath(dir.FullPath(), req.Name), newEntry)
  177. return node, nil
  178. }
  179. glog.V(0).Infof("mkdir %s/%s: %v", dir.FullPath(), req.Name, err)
  180. return nil, fuse.EIO
  181. }
  182. func (dir *Dir) Lookup(ctx context.Context, req *fuse.LookupRequest, resp *fuse.LookupResponse) (node fs.Node, err error) {
  183. glog.V(4).Infof("dir Lookup %s: %s by %s", dir.FullPath(), req.Name, req.Header.String())
  184. fullFilePath := util.NewFullPath(dir.FullPath(), req.Name)
  185. dirPath := util.FullPath(dir.FullPath())
  186. meta_cache.EnsureVisited(dir.wfs.metaCache, dir.wfs, util.FullPath(dirPath))
  187. cachedEntry, cacheErr := dir.wfs.metaCache.FindEntry(context.Background(), fullFilePath)
  188. if cacheErr == filer_pb.ErrNotFound {
  189. return nil, fuse.ENOENT
  190. }
  191. entry := cachedEntry.ToProtoEntry()
  192. if entry == nil {
  193. // glog.V(3).Infof("dir Lookup cache miss %s", fullFilePath)
  194. entry, err = filer_pb.GetEntry(dir.wfs, fullFilePath)
  195. if err != nil {
  196. glog.V(1).Infof("dir GetEntry %s: %v", fullFilePath, err)
  197. return nil, fuse.ENOENT
  198. }
  199. } else {
  200. glog.V(4).Infof("dir Lookup cache hit %s", fullFilePath)
  201. }
  202. if entry != nil {
  203. if entry.IsDirectory {
  204. node = dir.newDirectory(fullFilePath, entry)
  205. } else {
  206. node = dir.newFile(req.Name, entry)
  207. }
  208. // resp.EntryValid = time.Second
  209. resp.Attr.Inode = fullFilePath.AsInode()
  210. resp.Attr.Valid = time.Second
  211. resp.Attr.Mtime = time.Unix(entry.Attributes.Mtime, 0)
  212. resp.Attr.Crtime = time.Unix(entry.Attributes.Crtime, 0)
  213. resp.Attr.Mode = os.FileMode(entry.Attributes.FileMode)
  214. resp.Attr.Gid = entry.Attributes.Gid
  215. resp.Attr.Uid = entry.Attributes.Uid
  216. return node, nil
  217. }
  218. glog.V(4).Infof("not found dir GetEntry %s: %v", fullFilePath, err)
  219. return nil, fuse.ENOENT
  220. }
  221. func (dir *Dir) ReadDirAll(ctx context.Context) (ret []fuse.Dirent, err error) {
  222. glog.V(4).Infof("dir ReadDirAll %s", dir.FullPath())
  223. processEachEntryFn := func(entry *filer_pb.Entry, isLast bool) error {
  224. fullpath := util.NewFullPath(dir.FullPath(), entry.Name)
  225. inode := fullpath.AsInode()
  226. if entry.IsDirectory {
  227. dirent := fuse.Dirent{Inode: inode, Name: entry.Name, Type: fuse.DT_Dir}
  228. ret = append(ret, dirent)
  229. } else {
  230. dirent := fuse.Dirent{Inode: inode, Name: entry.Name, Type: fuse.DT_File}
  231. ret = append(ret, dirent)
  232. }
  233. return nil
  234. }
  235. dirPath := util.FullPath(dir.FullPath())
  236. meta_cache.EnsureVisited(dir.wfs.metaCache, dir.wfs, dirPath)
  237. listedEntries, listErr := dir.wfs.metaCache.ListDirectoryEntries(context.Background(), util.FullPath(dir.FullPath()), "", false, int(math.MaxInt32))
  238. if listErr != nil {
  239. glog.Errorf("list meta cache: %v", listErr)
  240. return nil, fuse.EIO
  241. }
  242. for _, cachedEntry := range listedEntries {
  243. processEachEntryFn(cachedEntry.ToProtoEntry(), false)
  244. }
  245. return
  246. }
  247. func (dir *Dir) Remove(ctx context.Context, req *fuse.RemoveRequest) error {
  248. if !req.Dir {
  249. return dir.removeOneFile(req)
  250. }
  251. return dir.removeFolder(req)
  252. }
  253. func (dir *Dir) removeOneFile(req *fuse.RemoveRequest) error {
  254. filePath := util.NewFullPath(dir.FullPath(), req.Name)
  255. entry, err := filer_pb.GetEntry(dir.wfs, filePath)
  256. if err != nil {
  257. return err
  258. }
  259. if entry == nil {
  260. return nil
  261. }
  262. // first, ensure the filer store can correctly delete
  263. glog.V(3).Infof("remove file: %v", req)
  264. err = filer_pb.Remove(dir.wfs, dir.FullPath(), req.Name, false, false, false, false, dir.wfs.signature)
  265. if err != nil {
  266. glog.V(3).Infof("not found remove file %s/%s: %v", dir.FullPath(), req.Name, err)
  267. return fuse.ENOENT
  268. }
  269. // then, delete meta cache and fsNode cache
  270. dir.wfs.metaCache.DeleteEntry(context.Background(), filePath)
  271. dir.wfs.fsNodeCache.DeleteFsNode(filePath)
  272. // delete the chunks last
  273. dir.wfs.deleteFileChunks(entry.Chunks)
  274. return nil
  275. }
  276. func (dir *Dir) removeFolder(req *fuse.RemoveRequest) error {
  277. glog.V(3).Infof("remove directory entry: %v", req)
  278. err := filer_pb.Remove(dir.wfs, dir.FullPath(), req.Name, true, false, false, false, dir.wfs.signature)
  279. if err != nil {
  280. glog.V(0).Infof("remove %s/%s: %v", dir.FullPath(), req.Name, err)
  281. if strings.Contains(err.Error(), "non-empty") {
  282. return fuse.EEXIST
  283. }
  284. return fuse.ENOENT
  285. }
  286. t := util.NewFullPath(dir.FullPath(), req.Name)
  287. dir.wfs.metaCache.DeleteEntry(context.Background(), t)
  288. dir.wfs.fsNodeCache.DeleteFsNode(t)
  289. return nil
  290. }
  291. func (dir *Dir) Setattr(ctx context.Context, req *fuse.SetattrRequest, resp *fuse.SetattrResponse) error {
  292. glog.V(4).Infof("%v dir setattr %+v", dir.FullPath(), req)
  293. if err := dir.maybeLoadEntry(); err != nil {
  294. return err
  295. }
  296. if req.Valid.Mode() {
  297. dir.entry.Attributes.FileMode = uint32(req.Mode)
  298. }
  299. if req.Valid.Uid() {
  300. dir.entry.Attributes.Uid = req.Uid
  301. }
  302. if req.Valid.Gid() {
  303. dir.entry.Attributes.Gid = req.Gid
  304. }
  305. if req.Valid.Mtime() {
  306. dir.entry.Attributes.Mtime = req.Mtime.Unix()
  307. }
  308. return dir.saveEntry()
  309. }
  310. func (dir *Dir) Setxattr(ctx context.Context, req *fuse.SetxattrRequest) error {
  311. glog.V(4).Infof("dir Setxattr %s: %s", dir.FullPath(), req.Name)
  312. if err := dir.maybeLoadEntry(); err != nil {
  313. return err
  314. }
  315. if err := setxattr(dir.entry, req); err != nil {
  316. return err
  317. }
  318. return dir.saveEntry()
  319. }
  320. func (dir *Dir) Removexattr(ctx context.Context, req *fuse.RemovexattrRequest) error {
  321. glog.V(4).Infof("dir Removexattr %s: %s", dir.FullPath(), req.Name)
  322. if err := dir.maybeLoadEntry(); err != nil {
  323. return err
  324. }
  325. if err := removexattr(dir.entry, req); err != nil {
  326. return err
  327. }
  328. return dir.saveEntry()
  329. }
  330. func (dir *Dir) Listxattr(ctx context.Context, req *fuse.ListxattrRequest, resp *fuse.ListxattrResponse) error {
  331. glog.V(4).Infof("dir Listxattr %s", dir.FullPath())
  332. if err := dir.maybeLoadEntry(); err != nil {
  333. return err
  334. }
  335. if err := listxattr(dir.entry, req, resp); err != nil {
  336. return err
  337. }
  338. return nil
  339. }
  340. func (dir *Dir) Forget() {
  341. glog.V(4).Infof("Forget dir %s", dir.FullPath())
  342. dir.wfs.fsNodeCache.DeleteFsNode(util.FullPath(dir.FullPath()))
  343. }
  344. func (dir *Dir) maybeLoadEntry() error {
  345. if dir.entry == nil {
  346. parentDirPath, name := util.FullPath(dir.FullPath()).DirAndName()
  347. entry, err := dir.wfs.maybeLoadEntry(parentDirPath, name)
  348. if err != nil {
  349. return err
  350. }
  351. dir.entry = entry
  352. }
  353. return nil
  354. }
  355. func (dir *Dir) saveEntry() error {
  356. parentDir, name := util.FullPath(dir.FullPath()).DirAndName()
  357. return dir.wfs.WithFilerClient(func(client filer_pb.SeaweedFilerClient) error {
  358. request := &filer_pb.UpdateEntryRequest{
  359. Directory: parentDir,
  360. Entry: dir.entry,
  361. Signatures: []int32{dir.wfs.signature},
  362. }
  363. glog.V(1).Infof("save dir entry: %v", request)
  364. _, err := client.UpdateEntry(context.Background(), request)
  365. if err != nil {
  366. glog.Errorf("UpdateEntry dir %s/%s: %v", parentDir, name, err)
  367. return fuse.EIO
  368. }
  369. dir.wfs.metaCache.UpdateEntry(context.Background(), filer2.FromPbEntry(request.Directory, request.Entry))
  370. return nil
  371. })
  372. }
  373. func (dir *Dir) FullPath() string {
  374. var parts []string
  375. for p := dir; p != nil; p = p.parent {
  376. if strings.HasPrefix(p.name, "/") {
  377. if len(p.name) > 1 {
  378. parts = append(parts, p.name[1:])
  379. }
  380. } else {
  381. parts = append(parts, p.name)
  382. }
  383. }
  384. if len(parts) == 0 {
  385. return "/"
  386. }
  387. var buf bytes.Buffer
  388. for i := len(parts) - 1; i >= 0; i-- {
  389. buf.WriteString("/")
  390. buf.WriteString(parts[i])
  391. }
  392. return buf.String()
  393. }