model.py

import llfuse
import time
import os
import stat
import copy
import logging

import settings


class FuseIO():
    """Represents a folder or a file.

    The main meaning of this object is to hold a combined class for the
    attribute and inode handling.
    """

    def __init__(self, mode, inode, attr=None):
        """Construct a FuseIO object.

        Arguments:
        mode  -- the mode of the file
        inode -- the inode of the file
        attr  -- a complete set of attributes, overwrite the mode parameter
        """
        self._inode = inode
        if attr:
            self._attr = attr
        else:
            self._attr = self._construct_attr(mode)

    def _construct_attr(self, mode):
        """Returns an EntryAttributes object with defaults and given mode."""
        attr = llfuse.EntryAttributes()
        attr.st_mode = mode
        attr.st_nlink = 1
        attr.st_size = 0

        # attr.generation = 0
        # attr.st_rdev = 0

        # attr.attr_timeout = 300
        # attr.entry_timeout = 300
        attr.st_atime_ns = int(time.time())
        attr.st_mtime_ns = int(time.time())
        attr.st_ctime_ns = int(time.time())

        # attr.st_blksize = 512
        # attr.st_blocks = 1

        attr.st_gid = os.getgid()
        attr.st_uid = os.getuid()

        return attr

    def get_inode(self):
        """Return the inode."""
        if self._inode == -1:
            raise Exception("Special File")
        else:
            return self._inode

    def set_inode(self, inode):
        """Set the inode."""
        self._inode = inode

    def get_attr(self):
        """Return the attributes."""
        if self._inode == -1:
            if hasattr(self, "_name"):
                raise Exception(self._name + ": Special File")
            raise Exception("Special File")
        self._attr.st_ino = self._inode
        return self._attr

    def add_nlink(self):
        """Add an nlink to the attributes."""
        self._attr.st_nlink += 1

    def deepcopy_and_register(self, placeholder, obj):
        """ Make a generic deepcopy and register an inode.

        The placeholder and obj parameter make no sense here and are
        for signature compability with FuseDir.
        """
        if self._inode != -1:
            raise Exception("Cannot create a deep copy of an real file.")
        pcopy = copy.copy(self)
        # TODO
        # https://bitbucket.org/nikratio/python-llfuse/issues/95/copying-of-llfuseentryattributes-fails
        # pcopy._attr = copy.copy(self._attr)
        pcopy._attr = self._construct_attr(self._attr.st_mode)
        self._data.pin_inode(pcopy)
        return pcopy

    def is_special(self):
        """Indicates whether this object is special. Returns always false."""
        return False


class Node:
    """Represents a node in the filesystem tree."""

    def __init__(self, parent, name, data, root=False):
        """Constructs a node.

        Arguments:
        parent -- The parent node.
        name   -- The filename or virtual name of the node.
        data   -- The Data object, that mananges the inodes.

        Keyword arguments:
        root -- Indicates whether the node is the root node. (default: False)
        """
        self._parent = parent
        if root:
            self._parent = self
        self._name = name
        self._data = data
        self._children = {}
        self._specials = []

    def get_parent(self):
        """Returns the parent of the node."""
        return self._parent

    def get_root(self):
        """Returns the root node of the tree/filesystem."""
        parent = self
        while parent is not parent.get_parent():
            parent = parent.get_parent()
        return parent

    def get_name(self):
        """Returns the name of the node."""
        return self._name

    def add_special(self, special):
        """Adds a Special object to the node."""
        self._specials.append(special)
        return special

    def add_fuseio(self, fuseio, filename):
        """Adds a FuseIO object to the node."""
        if filename in self._children:
            raise Exception("File with filename {} already exists".format(
                filename))
        self._children[filename] = fuseio
        return fuseio

    def is_leaf(self):
        """Returns whether the node is a leaf or not."""
        return len(self._children) == 0 and len(self._specials) == 0

    def get_children(self):
        """Returns the FuseIO children objects as dict.

        The dict has the filename as key and the object as value.
        """
        return self._children

    def get_specials(self):
        """Returns the Special children objects as list."""
        return self._specials


class Special(Node):
    """Represent a node that holds a query and can evolve to real nodes."""

    def __init__(self, query, functions, where, session,
                 parent, name, data, fileattr):
        """Construct a special node.

        Arguments:
        query     -- The query that is needed to construct the real nodes.
        functions -- A Functions object to generate and parse filenames.
        where     -- A list of Where objects, to specify the query.
        session   -- A SQLAlchemy session.
        parent    -- Superclass argument, see Node.
        name      -- Superclass argument, see Node.
        data      -- Superclass argument, see Node.
        fileattr  -- A function that extract gid and path for FuseFile
                     generation.
        """

        super().__init__(parent, name, data)
        self._query = query
        self._functions = functions
        self._session = session
        self._where = where
        self._fileattr = fileattr
        self.logger = logging.getLogger('sqlfuse.special')

    def __repr__(self):
        return ''.join(["Special(query=", repr(self._query),
                        ", functions=",   repr(self._functions),
                        ", where=",       repr(self._where),
                        ", session=",     repr(self._session),
                        ", parent=",      self._parent.get_name(),
                        ", name=",        self._name,
                        ", data=",        repr(self._data),
                        ", fileattr=",    repr(self._fileattr),
                        ")"])

    def query_name(self, qname):
        """Execute the query with the given qname.

        The function returns the first result if results exists or None
        otherwise.
        """
        query = self._functions.parse_name(qname, self._query)
        self.logger.debug("query by name '{}': {}".format(qname, str(query)))
        if query is None:
            return None
        return self._session.execute(query).first()

    def query_all(self):
        """Execute the query and return the result."""
        self.logger.debug("query all: {}".format(str(self._query)))
        return self._session.execute(self._query)

    def is_special(self):
        """Indicates whether this object is special. Returns always false."""
        return True

    def get_fileattr(self, row):
        """Return the gid and path attributes of a row."""
        return self._fileattr(row)

    def get_obj_fname(self, row):
        """Return the generated filename out of a row."""
        return self._functions.gen_name(row)

    def apply_where(self, placeholder, obj):
        """Apply a where clause, where placeholder is replaced with object."""
        for pwhere in self._where:
            if pwhere.ph_obj == placeholder:
                if self.logger.isEnabledFor(logging.DEBUG):
                    self.logger.debug("apply where clause with function '{}', \
attribute {}, object items: {}".format('.'.join([str(pwhere.function.__self__),
                                                pwhere.function.__name__]),
                                       pwhere.attribute,
                                       obj.items()))
                try:
                    attr = getattr(obj, pwhere.attribute)
                except AttributeError:
                    raise Exception("Applying where fails: " + str(obj) +
                                    " has not the wanted attribute " +
                                    pwhere.attribute)
                self._query = self._query.where(pwhere.function(attr))


class FuseDir(FuseIO, Node):
    """Represents a directory in the filesystem tree."""

    def __init__(self, mode, inode, parent, name, data, root=False):
        """Constructs a directory node.

        Arguments:
        mode   -- The read/write/execute rights of the directory.
        inode  -- Superclass argument, see FuseIO.
        parent -- Superclass argument, see Node.
        name   -- Superclass argument, see Node.
        data   -- Superclass argument, see Node.

        Keyword arguments:
        root -- Superclass argument, see Node
        """
        if mode is None:
            mode = settings.default_mode_dir
        FuseIO.__init__(self, stat.S_IFDIR | mode, inode)
        Node.__init__(self, parent, name, data, root=root)
        self._attr.st_size = 4096
        self._sorted_filenames = []
        if root:
            self._attr.st_nlink = 2

    def __repr__(self):
        return ''.join(["FuseDir(mode=", oct(self._attr.st_mode),
                        ", inode=",      str(self._inode),
                        ", parent=",     self._parent.get_name(),
                        ", name=",       self._name,
                        ")"])

    def construct_from_query(self, special, row):
        """Construct a FuseIO child based on a query result from a
        special object.

        Arguments:
        special -- The special object.
        row     -- The row of the query result.
        """
        name = special.get_obj_fname(row)
        if name in self._children:
            return None, None

        if special.is_leaf():
            (gid, path) = special.get_fileattr(row)
            f = FuseFile(None, -1, self, gid, path, self._data)
        else:
            f = FuseDir(None, -1, self, name, self._data)
            for (fname, child) in special.get_children().items():
                f.add_fuseio(child.deepcopy_and_register(special.get_name(),
                                                         row),
                             fname)
            for s_special in special.get_specials():
                s_special = copy.copy(s_special)
                s_special.apply_where(special.get_name(), row)
                f.add_special(s_special)
        self._data.pin_inode(f)
        self.add_fuseio(f, name)
        return name, f

    def deepcopy_and_register(self, placeholder, obj):
        """Constructs a deepcopy of the directory and assign an inode.

        If the directory or a subdirectory contains special nodes with
        where clauses, this where clause are applied via apply_where().

        Arguments:
        placeholder -- The placeholder argument for apply_where().
        obj         -- The obj argument for apply_where().
        """
        pcopy = FuseIO.deepcopy_and_register(self, placeholder, obj)
        pcopy._children = {}
        pcopy._sorted_filenames = []
        pcopy._specials = []
        for (fname, child) in self._children.items():
            pcopy.add_fuseio(child.deepcopy_and_register(placeholder, obj),
                             fname)
        for special in self._specials:
            special = copy.copy(special)
            special.apply_where(placeholder, obj)
            pcopy.add_special(special)
        return pcopy

    def query_name(self, filename):
        """Query the directory contents after a given filename.

        This models more less the behaviour of the lookup syscall. If the
        directory contains special objects, the relevant queries are executed.

        Arguments:
        filename -- the filename that will be queried.
        """
        if filename == '.':
            return self.get_attr()
        if filename == '..':
            return self.get_parent().get_attr()
        if filename in self._children:
            return self._children[filename].get_attr()
        for special in self._specials:
            res = special.query_name(filename)
            if res is not None:
                name, f = self.construct_from_query(special, res)
                return f.get_attr()

    def add_fuseio(self, fuseio, filename):
        """Adds a FuseIO object with a given filename to the directory."""
        Node.add_fuseio(self, fuseio, filename)
        self._sorted_filenames.append(filename)
        fuseio.add_nlink()
        if isinstance(fuseio, FuseDir):
            self.add_nlink()
        return fuseio

    def opendir(self):
        """Will be called by Operations before readdir(), not function yet."""
        pass

    def readdir(self, offset):
        """Read the contents of the directory up from offset. Yields the
        result.
        """
        for child in self._sorted_filenames[offset:]:
            yield (child, self._children[child].get_attr())
        for special in self._specials:
            nlen = len(self._sorted_filenames)
            res = special.query_all()
            for row in res:
                name, f = self.construct_from_query(special, row)
                if name is not None and offset <= nlen:
                        yield(name, f.get_attr())


class FuseFile(FuseIO, Node):
    """Represents a file node and a leaf in the filesystem tree.

    The file is always linked to a real file in a real directory
    and opens and read this file, if it is requested.
    """

    def __init__(self, mode, inode, parent, gid, path, data):
        """Constructs a file node.

        Arguments:
        mode   -- The read/write/execute rights of the directory.
        inode  -- Superclass argument, see FuseIO.
        parent -- Superclass argument, see Node.
        gid    -- The unique gid of the file.
        path   -- The filepath of the real file.
        data   -- Superclass argument, see Node.
        """
        if mode is None:
            mode = settings.default_mode_file
        FuseIO.__init__(self, stat.S_IFREG | mode, inode)
        Node.__init__(self, parent, None, data)
        self._gid = gid
        self._path = path
        self._attr.st_size = os.path.getsize(path)

    def __repr__(self):
        return ''.join(["FuseFile(mode=", oct(self._attr.st_mode),
                        ", inode=",       str(self._inode),
                        ", parent=",      self._parent.get_name(),
                        ", gid=",         str(self._gid),
                        ", path=",        self._path,
                        ")"])

    def open(self):
        """Opens the file."""
        self._file = open(self._path, 'rb')

    def close(self):
        """Closes the file."""
        self._file.close()

    def get_name(self):
        """Returns the name (gid) of the file."""
        return str(self._gid)

    def read(self, offset, size):
        """Read size bytes up from offset of the file."""
        self._file.seek(offset)
        return self._file.read(size)

    def add_fuseio(self, fuseio, filename):
        """This method should never be called."""
        raise Exception("FuseFile has to be a leaf.")

    def add_special(self, special):
        """This method should never be called."""
        raise Exception("FuseFile has to be a leaf.")