data.py

import llfuse
from sqlfuse.model import FuseDir, Special
import logging


class Data:
    """Manages the building of the filetree and the allocated inodes"""

    def __init__(self, session, fs):
        """Construct a Data object.

        Arguments:
        session -- a sqlalchemy session
        fs      -- a list of *Path objects, that describe a filesystem
        """

        self.logger = logging.getLogger('sqlfuse.data')
        self._cache = llfuse.ROOT_INODE * [None]
        self._session = session
        self._tree = FuseDir(None, llfuse.ROOT_INODE, None, "/", self,
                             root=True)
        self._cache.append(self._tree)
        self._create_tree(fs)
        self.logger.debug("created tree")
        self.logger.debug(self.print_tree())

    def _create_tree(self, fs):
        """Creates a tree based on the description filesystem 'fs'"""
        dtree = [{}, None]
        # build tree as dict
        for cpath in fs:
            path = cpath.path.split('/')
            t = dtree
            if path[0] == '':
                path = path[1:]
            for f in path:
                if f not in t[0]:
                    t[0][f] = [{}, None]
                t = t[0][f]
            t[1] = cpath

        # build real objects
        queue = [(dtree[0], self._tree)]
        for (dnode, node) in queue:
            for filename in dnode:
                (subdnode, qpath) = dnode[filename]
                nnode = self._create_tree_node(node, qpath, filename)
                if len(subdnode) > 0:
                    queue.append((subdnode, nnode))

    def _create_tree_node(self, node, qpath, filename):
        """Creates an individual node of the filesystem.

        Arguments:
        node     -- the parent node
        qpath    -- the path object that holds the attributes and functions
        filename -- the filename of the new node
        """
        # if self defined
        if qpath is not None:
            if qpath.fuse_io:
                ndir = node.add_fuseio(
                    qpath.get(node, self._session, filename))
            else:
                ndir = node.add_special(
                    Special(qpath.query, qpath.functions, qpath.where,
                            self._session, node, filename, self,
                            qpath.fileattr))
        else:
            ndir = FuseDir(None, -1, node, filename, self)
            if not node.is_special():
                self.pin_inode(ndir)
            node.add_fuseio(ndir, filename)
        return ndir

    def get(self, inode):
        """Returns the FuseIO object that belongs to the given inode."""
        try:
            return self._cache[inode]
        except KeyError:
            return None

    def pin_inode(self, fuseio):
        """Find a free inode and assign it to the FuseIO object."""
        ino = len(self._cache)
        fuseio.set_inode(ino)
        self._cache.append(fuseio)

    def print_tree(self):
        """Returns a string representation of the filesystem tree."""
        res = ''
        queue = [('/', self._tree, 0)]
        while len(queue) > 0:
            (name, elem, indent) = queue.pop()
            res += ''.join([' ' * indent, name, ': ', elem.__repr__(), '\n'])
            for (name, child) in elem.get_children().items():
                queue.append((name, child, indent + 2))
            for special in elem.get_specials():
                queue.append(
                    ('special', special, indent + 2))
        return res