operations.py

import llfuse, errno
import sys

fse = sys.getfilesystemencoding()

def bytes2str(s):
    return s.decode(fse, 'surrogateescape')

def str2bytes(s):
    return s.encode(fse, 'surrogateescape')

class Operations(llfuse.Operations):
    def __init__(self, root):
        super(llfuse.Operations, self).__init__()
        self._cache = {llfuse.ROOT_INODE: root}

    def getattr(self, inode):
        file = self._get_file(inode)
        return file.get_attr()

    def lookup(self, parent_inode, name):
        for filename, file in self._get_file(parent_inode).get_files():
            if filename == bytes2str(name):
                self._fill_in_file(file)
                return file.get_attr()
        raise llfuse.FUSEError(errno.ENOENT)

    def opendir(self, inode):
        if self._get_file(inode) is None:
            raise llfuse.FUSEError(errno.ENOENT)
        return inode

    def readdir(self, fh, off):
        files = list(self._get_file(fh).get_files())
        for i in range(off, len(files)):
            yield (str2bytes(files[i][0]), files[i][1].get_attr(), i+1)

    def open(self, inode, flags):
        self._get_file(inode).open()
        return inode

    def flush(self, fh):
        self._get_file(fh).close()

    def read(self, fh, off, size):
        file = self._get_file(fh)
        file.seek(off)
        return file.read(size)

    def _get_file(self, inode):
        if inode in self._cache:
            return self._cache[inode]
        raise llfuse.FUSEError(errno.ENOENT)

    def _fill_in_file(self, file):
        self._cache[file.get_inode()] = file