fusetoys

metacachefs.py (7019B)

---

 #!/usr/bin/python
 
 """FUSE filesystem to cache all metadata in memory for a hierarchy"""
 
 import fuse
 import errno
 import os
 import sys
 from loopfs import LoopFS
 import traceback
 import logging
 
 fuse.fuse_python_api = (0, 2)
 
 class MissingNode:
     def __init__(self):
         self.access = -errno.ENOENT
         self.getattr = -errno.ENOENT
         self.readlink = -errno.ENOENT
         self.readdir = -errno.ENOENT
 
 class Node:
     def __init__(self):
         self.flush()
         self.potentialChildren = set()
 
     def flush(self):
         self.access = None
         self.getattr = None
         self.readlink = None
         self.flushFolder()
 
     def flushFolder(self):
         self.readdir = None
 
     def registerChild(self, path):
         self.potentialChildren.add(path)
 
 
 class MetaCacheFS(LoopFS):
     def __init__(self, *args, **kw):
         LoopFS.__init__(self, *args, **kw)
         self.files = {}
 
     def flushIfPresent(self, path):
         if path in self.files.keys():
             self.doFlushFolder(path)
             self.files[path].flush()
     def deleteIfPresent(self, path):
         if path in self.files.keys():
             del self.files[path]
     def getFolder(self, path):
         head, tail = os.path.split(path)
         return head
 
     def flushFolder(self, path):
         logging.debug("flushing %s" % (self.getFolder(path)))
         if self.getFolder(path) in self.files.keys():
             return self.doFlushFolder(self.getFolder(path))
 
     def doFlushFolder(self, path):
         d = self.files[path]
         if d.readdir != None:
             for x in d.readdir:
                 logging.debug("flushing descendent %s" % (os.path.join(path, x.name)))
                 self.flushIfPresent(os.path.join(path, x.name))
         for x in d.potentialChildren:
             logging.debug("flushing potential descendent %s" % x)
             self.flushIfPresent(x)
         d.flushFolder()
 
     def exceptionToStatus(self, e):
         if isinstance(e, OSError):
             return -e.errno
         else:
             return -errno.ENOENT
 
     def getOrCreate(self, path):
         if path not in self.files.keys():
             head, tail = os.path.split(path)
             if head in self.files.keys():
                 d = self.files[head]
                 logging.debug("might get missingfile from %s, index is %s" % (
                   head, d.readdir))
                 if d.readdir != None and tail not in [x.name for x in
                         d.readdir]:
                     return MissingNode() # we know it can't exist
             logging.debug("created fresh node for %s" % path)
             self.files[path] = Node()
             if (head != path):
                 headFile = self.getOrCreate(head)
                 headFile.registerChild(path)
         return self.files[path]
 
     def access(self, path, mode):
         pathh = os.path.normpath(path)
         f = self.getOrCreate(pathh)
         if f.access == None:
             f.access = super(MetaCacheFS, self).access(path, mode)
         return f.access
 
     def chmod(self, path, mode):
         pathh = os.path.normpath(path)
         self.flushIfPresent(pathh)
         return super(MetaCacheFS, self).chmod(path, mode)
 
     def chown(self, path, mode):
         pathh = os.path.normpath(path)
         self.flushIfPresent(pathh)
         return super(MetaCacheFS, self).chown(path, mode)
 
     def create(self, path, flags, mode):
         pathh = os.path.normpath(path)
         self.flushFolder(pathh)
         return super(MetaCacheFS, self).create(path, flags, mode)
 
     def getattr(self, path):
         pathh = os.path.normpath(path)
         logging.debug("pathh is %s in cache" % "" if pathh in self.files.keys() else " not")
         f = self.getOrCreate(pathh)
         logging.debug("my file has %s" % f.getattr)
         if f.getattr == None:
             try:
                 x = super(MetaCacheFS, self).getattr(path)
             except Exception as e:
                 x = self.exceptionToStatus(e)
             f.getattr = x
         return f.getattr
 
     def link(self, target, source):
         target2 = os.path.normpath(target)
         self.flushFolder(target2)
 
         return super(MetaCacheFS, self).link(target, source)
 
     def mkdir(self, path, mode):
         pathh = os.path.normpath(path)
         self.flushFolder(pathh)
         return super(MetaCacheFS, self).mkdir(path, mode)
 
     def mknod(self, path, mode, rdev):
         pathh = os.path.normpath(path)
         self.flushFolder(pathh)
         return super(MetaCacheFS, self).mknod(path, mode, rdev)
 
     def open(self, path, flags):
         return super(MetaCacheFS, self).open(path, flags)
 
     def read(self, path, size, offset):
         return super(MetaCacheFS, self).read(path, size, offset)
 
     def readdir(self, path, offset):
         pathh = os.path.normpath(path)
         f = self.getOrCreate(pathh)
         if f.readdir == None:
             f.readdir = list(super(MetaCacheFS, self).readdir(path, offset))
         return f.readdir
 
     def readlink(self, path):
         pathh = os.path.normpath(path)
         f = self.getOrCreate(pathh)
         if f.readlink == None:
             try:
                 x = super(MetaCacheFS, self).readlink(path)
             except Exception as e:
                 x = self.except_to_status(e)
             f.readlink = x
         return f.readlink
 
     def rename(self, old, new):
         old2 = os.path.normpath(old)
         new2 = os.path.normpath(new)
         self.flushIfPresent(old2)
         self.flushIfPresent(new2)
         self.flushFolder(new2)
         self.flushFolder(old2)
         return super(MetaCacheFS, self).rename(old, new)
 
     def rmdir(self, path):
         pathh = os.path.normpath(path)
         self.deleteIfPresent(pathh)
         self.flushFolder(pathh)
         return super(MetaCacheFS, self).rmdir(path)
 
     def statfs(self):
         return super(MetaCacheFS, self).statfs()
 
     def symlink(self, target, source):
         target2 = os.path.normpath(target)
         self.flushFolder(target2)
 
         return super(MetaCacheFS, self).symlink(target, source)
 
     def truncate(self, path, length):
         pathh = os.path.normpath(path)
         self.flushIfPresent(pathh)
         return super(MetaCacheFS, self).truncate(path, length)
 
     def unlink(self, path):
         pathh = os.path.normpath(path)
         self.deleteIfPresent(pathh)
         self.flushFolder(pathh)
         return super(MetaCacheFS, self).unlink(path)
 
     def utimens(self, path, ts_acc, ts_mod):
         pathh = os.path.normpath(path)
         self.flushIfPresent(pathh)
         return super(MetaCacheFS, self).utimens(path, ts_acc, ts_mod)
 
     def write(self, path, data, offset):
         pathh = os.path.normpath(path)
         self.flushIfPresent(pathh)
         return super(MetaCacheFS, self).write(path, data, offset)
 
 
 if __name__ == "__main__":
     logging.basicConfig(level=logging.DEBUG)
     metacachefs = MetaCacheFS()
     fuse_opts = metacachefs.parse(['-o', 'fsname=metacachefs'] + sys.argv[1:])
     metacachefs.main()