It's not a _real_ pyhesiodfs if it's not accessible to everyone else.

[invirt/packages/python-routefs.git] / routefs / __init__.py

diff --git a/routefs/__init__.py b/routefs/__init__.py
old mode 100755 (executable)
new mode 100644 (file)
index 8519a1a..5137256
--- a/routefs/__init__.py
+++ b/routefs/__init__.py
@@ -1,3 +1,16 @@
+"""
+RouteFS is a base class for developing read-only FUSE filesystems that
+lets you focus on the directory tree instead of the system calls.
+
+RouteFS uses the Routes library developed for Pylons. URLs were
+inspired by filesystems, and now you can have filesystems inspired by
+URLs.
+
+When developing a descendent of RouteFS, any methods defined in that
+class are considered "controllers", and receive any other parameters
+specified by the URL as keyword arguments.
+"""
+

 import fuse
 import routes
 import errno
 import fuse
 import routes
 import errno

@@ -6,6 +19,10 @@ import stat
 fuse.fuse_python_api = (0, 2)
 
 class RouteStat(fuse.Stat):
 fuse.fuse_python_api = (0, 2)
 
 class RouteStat(fuse.Stat):

+    """
+    RouteStat is a descendent of fuse.Stat, defined to make sure that
+    all of the necessary attributes are always defined
+    """

     def __init__(self):
         self.st_mode = 0
         self.st_ino = 0
     def __init__(self):
         self.st_mode = 0
         self.st_ino = 0

@@ -19,6 +36,14 @@ class RouteStat(fuse.Stat):
         self.st_ctime = 0
 
 class RouteMeta(type):
         self.st_ctime = 0
 
 class RouteMeta(type):

+    """
+    Metaclass to calculate controller methods
+    
+    Routes needs to be pre-seeded with a list of "controllers". For
+    all descendents of RouteFS, the list of controllers is defined to
+    be any non-private methods of the class that were not in the
+    RouteFS class.
+    """

     def __init__(cls, classname, bases, dict_):
         super(RouteMeta, cls).__init__(classname, bases, dict_)
         if bases != (fuse.Fuse,):
     def __init__(cls, classname, bases, dict_):
         super(RouteMeta, cls).__init__(classname, bases, dict_)
         if bases != (fuse.Fuse,):

@@ -27,6 +52,9 @@ class RouteMeta(type):
                                  if not func.startswith('_')])
 
 class RouteFS(fuse.Fuse):
                                  if not func.startswith('_')])
 
 class RouteFS(fuse.Fuse):

+    """
+    RouteFS: Web 2.0 for filesystems
+    """

     __metaclass__ = RouteMeta
     def __init__(self, *args, **kwargs):
         super(RouteFS, self).__init__(*args, **kwargs)
     __metaclass__ = RouteMeta
     def __init__(self, *args, **kwargs):
         super(RouteFS, self).__init__(*args, **kwargs)

@@ -35,6 +63,10 @@ class RouteFS(fuse.Fuse):
         self.map.create_regs(self.controller_list)
         
     def make_map(self):
         self.map.create_regs(self.controller_list)
         
     def make_map(self):

+        """
+        This method should be overridden by descendents of RouteFS to
+        define the routing for the filesystem
+        """

         m = routes.Mapper()
         
         m.connect(':controller')
         m = routes.Mapper()
         
         m.connect(':controller')

@@ -46,14 +78,25 @@ class RouteFS(fuse.Fuse):
         cls.controller_list = lst
     
     def _get_file(self, path):
         cls.controller_list = lst
     
     def _get_file(self, path):

+        """
+        Find the filesystem entry object for a given path
+        """

         match = self.map.match(path)
         if match is None:
             return
         controller = match.pop('controller')
         result = getattr(self, controller)(**match)
         match = self.map.match(path)
         if match is None:
             return
         controller = match.pop('controller')
         result = getattr(self, controller)(**match)

+        if type(result) is str:
+            result = File(result)
+        if type(result) is list:
+            result = Directory(result)

         return result
     
     def readdir(self, path, offset):
         return result
     
     def readdir(self, path, offset):

+        """
+        If the path referred to is a directory, return the elements of
+        that diectory
+        """

         obj = self._get_file(path)
         if type(obj) is not Directory:
             return
         obj = self._get_file(path)
         if type(obj) is not Directory:
             return

@@ -62,26 +105,36 @@ class RouteFS(fuse.Fuse):
                 yield fuse.Direntry(str(member))
     
     def getattr(self, path):
                 yield fuse.Direntry(str(member))
     
     def getattr(self, path):

+        """
+        Return the stat information for a path
+        
+        The stat information for a directory, symlink, or file is
+        predetermined based on which it is.
+        """

         obj = self._get_file(path)
         if obj is None:
             return -errno.ENOENT
         
         st = RouteStat()
         if type(obj) is Directory:
         obj = self._get_file(path)
         if obj is None:
             return -errno.ENOENT
         
         st = RouteStat()
         if type(obj) is Directory:

-            st.st_mode = stat.S_IFDIR | 0755
+            st.st_mode = stat.S_IFDIR | obj.mode

             st.st_nlink = 2
         elif type(obj) is Symlink:
             st.st_nlink = 2
         elif type(obj) is Symlink:

-            st.st_mode = stat.S_IFLNK | 0777
+            st.st_mode = stat.S_IFLNK | obj.mode

             st.st_nlink = 1
             st.st_size = len(obj)
         else:
             st.st_nlink = 1
             st.st_size = len(obj)
         else:

-            st.st_mode = stat.S_IFREG | 0444
+            st.st_mode = stat.S_IFREG | obj.mode

             st.st_nlink = 1
             st.st_size = len(obj)
         
         return st
     
     def read(self, path, length, offset):
             st.st_nlink = 1
             st.st_size = len(obj)
         
         return st
     
     def read(self, path, length, offset):

+        """
+        If the path specified is a file, return the requested portion
+        of the file
+        """

         obj = self._get_file(path)
         if obj is None:
             return -errno.ENOENT
         obj = self._get_file(path)
         if obj is None:
             return -errno.ENOENT

@@ -91,28 +144,58 @@ class RouteFS(fuse.Fuse):
             return obj[offset:offset + length]
     
     def readlink(self, path):
             return obj[offset:offset + length]
     
     def readlink(self, path):

+        """
+        If the path specified is a symlink, return the target
+        """

         obj = self._get_file(path)
         if type(obj) is not Symlink:
             return -errno.EINVAL
         else:
             return obj
 
         obj = self._get_file(path)
         if type(obj) is not Symlink:
             return -errno.EINVAL
         else:
             return obj
 

-class Directory(list):
+class TreeEntry(object):
+    default_mode = 0444
+    
+    def __new__(cls, contents, mode=None):
+        return super(TreeEntry, cls).__new__(cls, contents)
+    
+    def __init__(self, contents, mode=None):
+        if mode is None:
+            self.mode = self.default_mode
+        else:
+            self.mode = mode
+        
+        super(TreeEntry, self).__init__(contents)
+
+class Directory(TreeEntry, list):

     """
     A dummy class representing a filesystem entry that should be a
     directory
     """
     """
     A dummy class representing a filesystem entry that should be a
     directory
     """

-    pass
+    default_mode = 0555

 
 

-class Symlink(str):
+class Symlink(TreeEntry, str):

     """
     A dummy class representing something that should be a symlink
     """
     """
     A dummy class representing something that should be a symlink
     """

-    pass
+    default_mode = 0777
+
+class File(TreeEntry, str):
+    """
+    A dummy class representing something that should be a file
+    """
+    default_mode = 0444

 
 def main(cls):
 
 def main(cls):

+    """
+    A convenience function for initializing a RouteFS filesystem
+    """

     server = cls(version="%prog " + fuse.__version__,
                  usage=fuse.Fuse.fusage,
                  dash_s_do='setsingle')
     server.parse(errex=1)
     server.main()
     server = cls(version="%prog " + fuse.__version__,
                  usage=fuse.Fuse.fusage,
                  dash_s_do='setsingle')
     server.parse(errex=1)
     server.main()

+
+from dictfs import DictFS
+
+__all__ = ['RouteFS', 'DictFS', 'Symlink', 'Directory', 'File', 'main']