#!/usr/bin/env python

# Author: Sascha Silbe <sascha-pgp@silbe.org> (PGP signed emails only)

#

# This program is free software: you can redistribute it and/or modify

# it under the terms of the GNU General Public License version 3

# as published by the Free Software Foundation.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

"""datastore-fuse: access the Sugar data store using FUSE

Mounting this "file system" allows "legacy" applications to access the Sugar

data store.

"""

import errno

import fuse

import logging

import os

import os.path

import shutil

import stat

import sys

import tempfile

from sugar.logger import trace

import sugar.logger

import fsemulation

fuse.fuse_python_api = (0, 2)

DS_DBUS_SERVICE = "org.laptop.sugar.DataStore"

DS_DBUS_INTERFACE = "org.laptop.sugar.DataStore"

DS_DBUS_PATH = "/org/laptop/sugar/DataStore"

XATTR_CREATE = 1

XATTR_REPLACE = 2

# DBus still has no way to indicate an infinite timeout :-/

DBUS_TIMEOUT_MAX = 2**31 / 1000

class FSEntryStat(fuse.Stat):

    def __init__(self, fs_entry, inode):

        if isinstance(fs_entry, fsemulation.Directory):

            n_links = 2

        else:

            n_links = 1

        fuse.Stat.__init__(self, st_mode=fs_entry.mode, st_ino=inode,

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

            st_size=fs_entry.get_size(), st_nlink=n_links,

            st_mtime=fs_entry.get_mtime(), st_ctime=fs_entry.get_ctime())

class DataStoreFile(object):

    _ACCESS_MASK = os.O_RDONLY | os.O_RDWR | os.O_WRONLY

    direct_io = False

    keep_cache = False

    @trace()

    def __init__(self, filesystem, path, flags, mode=None):

        self._filesystem = filesystem

        self._flags = flags

        self._read_only = False

        self._is_temporary = False

        self._dirty = False

        self._path = path

        # Contrary to what's documented in the wiki, we'll get passed O_CREAT

        # and mknod() won't get called automatically, so we'll have to take

        # care of all possible cases ourselves.

        if flags & os.O_EXCL:

            filesystem.mknod(path)

            entry = filesystem.resolve(path, follow_links=True)

        else:

            try:

                entry = filesystem.resolve(path, follow_links=True)

            except IOError, exception:

                if exception.errno != errno.ENOENT:

                    raise

                if not flags & os.O_CREAT:

                    raise

                filesystem.mknod(path, flags, mode)

                entry = filesystem.resolve(path, follow_links=True)

        self._entry = entry

        self._read_only = flags & self._ACCESS_MASK == os.O_RDONLY

        if self._filesystem.should_truncate(entry.object_id) or \

           (flags & os.O_TRUNC):

            self._file = self._create()

            self._filesystem.reset_truncate(entry.object_id)

        else:

            self._file = self._checkout()

    def _create(self):

        self._is_temporary = True

        return tempfile.NamedTemporaryFile(prefix='datastore-fuse')

    def _checkout(self):

        name = self._entry.get_data()

        if not name:

            # existing, but empty entry

            return self._create()

        if self._read_only:

            return file(name)

        try:

            copy = self._create()

            shutil.copyfileobj(file(name), copy)

            copy.seek(0)

            return copy

        finally:

            os.remove(name)

    @trace()

    def read(self, length, offset):

        self._file.seek(offset)

        return self._file.read(length)

    @trace()

    def write(self, buf, offset):

        if self._read_only:

            raise IOError(errno.EBADF, os.strerror(errno.EBADF))

        if self._flags & os.O_APPEND:

            self._file.seek(0, os.SEEK_END)

        else:

            self._file.seek(offset)

        self._file.write(buf)

        self._dirty = True

        return len(buf)

    @trace()

    def release(self, flags_):

        self.fsync()

        self._file.close()

        if not self._is_temporary:

            os.remove(self._file.name)

    @trace()

    def fsync(self, isfsyncfile_=None):

        self.flush()

        if self._read_only:

            return

        if self._dirty:

            self._entry.write_data(self._file.name)

    @trace()

    def flush(self):

        self._file.flush()

    @trace()

    def fgetattr(self):

        return self._filesystem.getattr(self._path)

    @trace()

    def ftruncate(self, length):

        self._file.truncate(length)

    @trace()

    def lock(self, cmd_, owner_, **kwargs_):

        raise IOError(errno.EPERM, os.strerror(errno.EPERM))

class DataStoreFS(fuse.Fuse):

    # FUSE API

    def __init__(self_fs, *args, **kw):

        # pylint: disable-msg=E0213

        class WrappedDataStoreFile(DataStoreFile):

            def __init__(self_file, *args, **kwargs):

                # pylint: disable-msg=E0213

                DataStoreFile.__init__(self_file, self_fs, *args, **kwargs)

        self_fs.file_class = WrappedDataStoreFile

        self_fs._truncate_object_ids = set()

        self_fs._max_inode_number = 1

        self_fs._object_id_to_inode_number = {}

        fuse.Fuse.__init__(self_fs, *args, **kw)

        self_fs._fs_emu = fsemulation.FSEmulation()

        # TODO: listen to DS signals to update name mapping

    @trace()

    def getattr(self, path):

        entry = self.resolve(path)

        return FSEntryStat(entry, self._get_inode_number(path))

    def readdir(self, path, offset=None):

        logging.debug('readdir(): begin')

        for name_unicode, entry in self.resolve(path).readdir():

            logging.debug('readdir(): name_unicode=%r, entry=%r', name_unicode, entry)

            name_utf8 = name_unicode.encode('utf-8')

            entry_path = os.path.join(path, name_utf8)

            if isinstance(entry, fsemulation.Directory):

                yield fuse.Direntry(name_utf8, type=stat.S_IFDIR,

                    ino=self._get_inode_number(entry_path))

            elif isinstance(entry, fsemulation.Symlink):

                yield fuse.Direntry(name_utf8, type=stat.S_IFLNK,

                    ino=self._get_inode_number(entry_path))

            elif isinstance(entry, fsemulation.DSObject):

                yield fuse.Direntry(name_utf8, type=stat.S_IFREG,

                    ino=self._get_inode_number(entry_path))

            else:

                logging.error('readdir(): FS object of unknown type: %r',

                              entry)

        logging.debug('readdir(): end')

    def readlink(self, path):

        return self.resolve(path).readlink().encode('utf-8')

    def mknod(self, path, mode_=None, dev_=None):

        # called by FUSE for open(O_CREAT) before instantiating the file

        directory, name = os.path.split(path)

        return self.resolve(directory).mknod(unicode(name, 'utf-8'))

    def truncate(self, path, mode_=None, dev_=None):

        # Documented to be called by FUSE when opening files with O_TRUNC,

        # unless -o o_trunc_atomic is passed as a CLI option

        entry = self.resolve(path, follow_links=True)

        if isinstance(entry, fsemulation.Directory):

            raise IOError(errno.EISDIR, os.strerror(errno.EISDIR))

        elif not isinstance(entry, fsemulation.DSObject):

            logging.error('Trying to truncate an object of unknown type: %r',

                          entry)

            raise IOError(errno.EINVAL, os.strerror(errno.EINVAL))

        self._truncate_object_ids.add(entry.object_id)

    @trace()

    def unlink(self, path):

        entry = self.resolve(path)

        if isinstance(entry, fsemulation.Directory):

            raise IOError(errno.EISDIR, os.strerror(errno.EISDIR))

        entry.remove()

    @trace()

    def utime(self, path_, times_):

        # TODO: update timestamp property

        return

    def mkdir(self, path, mode_):

        directory, name = os.path.split(path)

        return self.resolve(directory).mkdir(unicode(name, 'utf-8'))

    @trace()

    def rmdir(self, path):

        entry = self.resolve(path)

        if not isinstance(entry, fsemulation.Directory):

            raise IOError(errno.ENOTDIR, os.strerror(errno.ENOTDIR))

        entry.remove()

    def rename(self, pathfrom, pathto):

        # FIXME

        raise IOError(errno.EPERM, os.strerror(errno.EPERM))

        #self._delegate(pathfrom, 'rename', pathto)

    @trace()

    def symlink(self, destination_, path_):

        # TODO for tags?

        raise IOError(errno.EPERM, os.strerror(errno.EPERM))

    @trace()

    def link(self, destination_, path_):

        raise IOError(errno.EPERM, os.strerror(errno.EPERM))

    @trace()

    def chmod(self, path_, mode_):

        raise IOError(errno.EPERM, os.strerror(errno.EPERM))

    @trace()

    def chown(self, path_, user, group):

        if (user != os.getuid()) or (group != os.getgid()):

            raise IOError(errno.EPERM, os.strerror(errno.EPERM))

    def getxattr(self, path, name, size):

        if not name.startswith('user.'):

            raise IOError(errno.ENODATA, os.strerror(errno.ENODATA))

        attr_name_unicode = unicode(name[5:], 'utf-8')

        props = self.resolve(path).get_properties([attr_name_unicode])

        #log.debug('getxattr(): props=%r', props)

        if attr_name_unicode not in props:

            raise IOError(errno.ENODATA, os.strerror(errno.ENODATA))

        value_unicode = props[attr_name_unicode]

        if isinstance(value_unicode, unicode):

            value_utf8 = value_unicode.encode('utf-8')

        else:

            # binary data

            value_utf8 = str(value_unicode)

        if not size:

            # We are asked for size of the value.

            return len(value_utf8)

        return value_utf8

    def listxattr(self, path, size):

        props = self.resolve(path).list_properties()

        attribute_names = ['user.' + name.encode('utf-8') for name in props]

        if not size:

            # We are asked for the size of the \0-separated list.

            return sum([len(name) + 1 for name in attribute_names])

        return attribute_names

    def setxattr(self, path, name, value, flags):

        if not name.startswith('user.'):

            raise IOError(errno.EOPNOTSUPP, os.strerror(errno.EOPNOTSUPP))

        attr_name_unicode = unicode(name[5:], 'utf-8')

        value_unicode = unicode(value, 'utf-8')

        entry = self.resolve(path)

        if flags & XATTR_CREATE:

            entry.create_property(name, value_unicode)

        elif flags & XATTR_REPLACE:

            entry.replace_property(name, value_unicode)

        else:

            entry.set_properties({name: value_unicode})

    # internal API (for DataStoreFile)

    def should_truncate(self, object_id):

        return object_id in self._truncate_object_ids

    def reset_truncate(self, object_id):

        self._truncate_object_ids.discard(object_id)

    def resolve(self, path, follow_links=False):

        """Look up emulated FS object located at path (UTF-8 encoded string)

        """

        return self._fs_emu.resolve(unicode(path, 'utf-8'),

                                    follow_links=follow_links)

    # private methods

    def _get_inode_number(self, key):

        if key not in self._object_id_to_inode_number:

            inode_number = self._max_inode_number

            self._max_inode_number += 1

            self._object_id_to_inode_number[key] = inode_number

        return self._object_id_to_inode_number[key]

def main():

    usage = "datastore-fuse: access the Sugar data store using FUSE\n"

    usage += fuse.Fuse.fusage

    sugar.logger.start()

    # FIXME: figure out how to force options to on, properly.

    sys.argv += ['-o', 'use_ino']

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

        dash_s_do='setsingle')

    server.parse(errex=1)

    server.main()

if __name__ == '__main__':

    main()