URLs.
"""
-import fuse
-import routes
+
import errno
import stat
+import fuse
+import routes
+
+
fuse.fuse_python_api = (0, 2)
+
class RouteStat(fuse.Stat):
"""
RouteStat is a descendent of fuse.Stat, defined to make sure that
self.st_mtime = 0
self.st_ctime = 0
+
class RouteFS(fuse.Fuse):
"""
RouteFS: Web 2.0 for filesystems
-
+
Any method that will be used as the controller in a Routes mapping
(either by explicitly specifying the controller or by using the
':controller' variable) must be added to RouteFS.controllers
controllers = []
def __init__(self, *args, **kwargs):
super(RouteFS, self).__init__(*args, **kwargs)
-
+
self.map = self.make_map()
self.map.create_regs(self.controllers)
-
+
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')
-
+
return m
-
+
def _get_file(self, path):
"""
Find the filesystem entry object for a given path
if type(result) is list:
result = Directory(result)
return result
-
+
def readdir(self, path, offset):
"""
If the path referred to is a directory, return the elements of
that diectory
"""
return self._get_file(path).readdir(offset)
-
+
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.
"""
return self._get_file(path).getattr()
-
+
def read(self, path, length, offset):
"""
If the path specified is a file, return the requested portion
of the file
"""
return self._get_file(path).read(length, offset)
-
+
def readlink(self, path):
"""
If the path specified is a symlink, return the target
"""
return self._get_file(path).readlink()
-
+
def write(self, path, buf, offset):
"""
If the path specified is a file, call the appropriate member
"""
return self._get_file(path).write(buf, offset)
+
class TreeKey(object):
def getattr(self):
return -errno.EINVAL
def write(self, length, offset):
return -errno.EINVAL
+
class NoEntry(TreeKey):
def getattr(self):
return -errno.ENOENT
def write(self, length, offset):
return -errno.ENOENT
+
class TreeEntry(TreeKey):
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
for member in ['.', '..'] + self:
yield fuse.Direntry(str(member))
+
class Symlink(TreeEntry, str):
"""
A dummy class representing something that should be a symlink
def readlink(self):
return self
+
class File(TreeEntry, str):
"""
A dummy class representing something that should be a file
def read(self, length, offset):
return self[offset:offset + length]
+
def main(cls):
"""
A convenience function for initializing a RouteFS filesystem
server.parse(values=server, errex=1)
server.main()
+
from dictfs import DictFS
__all__ = ['RouteFS', 'DictFS', 'Symlink', 'Directory', 'File', 'main']
/home/user is accessed in any way.
"""
+
import pwd
-import routefs
+
from routes import Mapper
+import routefs
+
+
class HomeFS(routefs.RouteFS):
controllers = ['getList', 'getUser']
def __init__(self, *args, **kwargs):
super(HomeFS, self).__init__(*args, **kwargs)
self.cache = {}
-
+
def make_map(self):
m = Mapper()
m.connect('', controller='getList')
m.connect(':action', controller='getUser')
return m
-
+
def getUser(self, action, **kwargs):
try:
if action not in self.cache:
return routefs.Symlink(self.cache[action])
except KeyError:
return
-
+
def getList(self, **kwargs):
return self.cache.keys()
+
if __name__ == '__main__':
routefs.main(HomeFS)
#!/usr/bin/python
+
import hesiod
-import routefs
from routes import Mapper
+import routefs
+
+
class PyHesiodFS(routefs.RouteFS):
controllers = ['getList', 'getReadme', 'getLocker']
def __init__(self, *args, **kwargs):
super(PyHesiodFS, self).__init__(*args, **kwargs)
self.fuse_args.add("allow_other", True)
-
+
self.cache = {}
-
+
def make_map(self):
m = Mapper()
m.connect('', controller='getList')
m.connect('README.txt', controller='getReadme')
m.connect(':action', controller='getLocker')
return m
-
+
def getLocker(self, action, **kwargs):
if action in self.cache:
return routefs.Symlink(self.cache[action])
-
+
try:
filsys = hesiod.FilsysLookup(action).filsys[0]
if filsys['type'] == 'AFS':
return routefs.Symlink(self.cache[action])
except (TypeError, KeyError, IndexError):
return
-
+
def getList(self, **kwargs):
return self.cache.keys() + ['README.txt']
-
+
def getReadme(self, **kwargs):
return """
This is the pyHesiodFS FUSE automounter. To access a Hesiod filsys,
/mit/name
"""
+
if __name__ == '__main__':
routefs.main(PyHesiodFS)