root/fuse/HttpDirFS.py

#!/usr/bin/env python
#
# Copyright 2011 Martin Collins <martin@hatchlane.com>
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#   http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
# usage: ./HttpDirFs.py -o remote=http://www.exampe.com/tree <mountpoint> 
#
# for fstab:
# symlink/copy HttpDirFs.py to /usr/bin/httpdirfs
# httpdirfs /mnt/point fuse remote=http://localhost/simpleindex,allow_other 0 0

import fuse
import errno
import time
import stat
import sys
import pycurl 
import curl

fuse.fuse_python_api = (0, 2)

class HttpDirLookup:
  def __init__(self, path, head):
    self.dirs     = dict()
    self.files    = dict()
    self.ctype    = ""
    self.status   = ""
    self.content  = ""

    try:
      c = pycurl.Curl();
      c.setopt(c.URL, path)
      c.setopt(c.FAILONERROR, True);
      c.setopt(c.FOLLOWLOCATION, True);
      if head:
        c.setopt(c.NOBODY, True)
      else:
        c.setopt(c.WRITEFUNCTION, self.body_callback)
      c.perform()
      self.ctype  = c.getinfo(pycurl.CONTENT_TYPE);
      self.status = c.getinfo(pycurl.HTTP_CODE);
      c.close()
    except:
      return 

    if self.ctype == "text/simpleindex":
      self.filter_content();

  def filter_content(self):
    while True:
      pos = self.content.find("\n");

      if pos == -1:
        break

      fn = self.content[:pos]
      self.content = self.content[pos+1:]

      if fn == '':
        break

      if fn[-1] == '/':
        self.dirs[fn[:-1]] = 1
      else:
        self.files[fn] = 1

  def body_callback(self, buf):
    self.content += buf;
    
class HttpDirFS(fuse.Fuse):

  def __init__(self, *args, **kw):
    fuse.Fuse.__init__(self, *args, **kw)
    self.remote   = ""
    self.scratch  = ""
    self.lookups  = dict()

  def getattr(self, path):
  
    lookup = HttpDirLookup(self.remote + path, True);
    
    if lookup.status != 200:
      return -errno.ENOENT

    st = fuse.Stat();

    if lookup.ctype == 'text/simpleindex':
      st.st_mode = stat.S_IFDIR | 0555
    else:
      st.st_mode = stat.S_IFREG | 0444

    st.st_atime = int(time.time())
    st.st_mtime = st.st_atime
    st.st_ctime = st.st_atime
    st.st_nlink = 2
    st.st_size  = 4096

    return st;

  def readdir(self, path, offset):

    lookup = HttpDirLookup(self.remote + path, False);
    
    if lookup.status != 200:
      return

    for d in lookup.dirs:
      yield fuse.Direntry(d)
    for f in lookup.files:
      yield fuse.Direntry(f)
    
  def read(self, path, size, offset):
    if path not in self.lookups:
      return -errno.ENOENT

    return self.lookups[path].content[offset:size+offset]

  def open(self, path, flags):
    if path not in self.lookups:
      lookup = HttpDirLookup(self.remote + path, False);
      if lookup.status != 200:
        return -errno.ENOENT
      self.lookups[path] = lookup;
    else:
      lookup = self.lookups[path]

  def release(self, path, flags):
    if path not in self.lookups:
      return -errno.ENOENT

    del self.lookups[path]

  def statfs ( self ):
    st = fuse.StatVfs();
    st.f_blocks = 1
    st.f_bsize  = 1
    st.f_bfree  = 0
    return st;

  # and all the read only stuff

  def readlink ( self, path ):
    return -errno.ENOSYS

  def getdir(self, path):
    return -errno.ENOSYS

  def symlink ( self, targetPath, linkPath ):
    return -errno.EROFS

  def fsync ( self, path, isFsyncFile ):
    return -errno.EROFS

  def rmdir ( self, path ):
    return -errno.EROFS
  
  def mkdir ( self, path, mode ):
    return -errno.EROFS

  def rename ( self, oldPath, newPath ):
    return -errno.EROFS

  def mknod(self, path, mode, dev ):
    return -errno.EROFS

  def write(self, buf, offset):
    return -errno.EROFS

  def truncate(self, path, len):
    return -errno.EROFS

  def unlink ( self, path ):
    return -errno.EROFS

  def chmod ( self, path, mode ):
    return -errno.EROFS

  def chown ( self, path, uid, gid ):
    return -errno.EROFS

  def utime ( self, path, times ):
    return -errno.EROFS
  

def main():

  usage = """
HttpDirFS: A filesystem to allow navigating a WebServer that 
           uses SimpleIndexes (see mod_simpleindex)
""" + fuse.Fuse.fusage

  server = HttpDirFS(version="%prog " + fuse.__version__,
                     usage=usage)

  server.parser.add_option(mountopt="remote", metavar="PATH", help="base URL")
  server.parse(values=server, errex=1)

  if server.remote[:7] != "http://":
    print >> sys.stderr, "Sorry, I only understand http:// sites"
    sys.exit(1)

  server.main()


if __name__ == '__main__':
  main()