+
−"""custom storages for the system source"""
+
−from os import unlink, path as osp
+
−
+
−from yams.schema import role_name
+
−
+
−from cubicweb import Binary
+
−from cubicweb.server.hook import Operation
+
−
+
−def set_attribute_storage(repo, etype, attr, storage):
+
−    repo.system_source.set_storage(etype, attr, storage)
+
−
+
−def unset_attribute_storage(repo, etype, attr):
+
−    repo.system_source.unset_storage(etype, attr)
+
−
+
−class Storage(object):
+
−    """abstract storage
+
−
+
−    * If `source_callback` is true (by default), the callback will be run during
+
−      query result process of fetched attribute's valu and should have the
+
−      following prototype::
+
−
+
−        callback(self, source, value)
+
−
+
−      where `value` is the value actually stored in the backend. None values
+
−      will be skipped (eg callback won't be called).
+
−
+
−    * if `source_callback` is false, the callback will be run during sql
+
−      generation when some attribute with a custom storage is accessed and
+
−      should have the following prototype::
+
−
+
−        callback(self, generator, relation, linkedvar)
+
−
+
−      where `generator` is the sql generator, `relation` the current rql syntax
+
−      tree relation and linkedvar the principal syntax tree variable holding the
+
−      attribute.
+
−    """
+
−    is_source_callback = True
+
−
+
−    def callback(self, *args):
+
−        """see docstring for prototype, which vary according to is_source_callback
+
−        """
+
−        raise NotImplementedError()
+
−
+
−    def entity_added(self, entity, attr):
+
−        """an entity using this storage for attr has been added"""
+
−        raise NotImplementedError()
+
−    def entity_updated(self, entity, attr):
+
−        """an entity using this storage for attr has been updatded"""
+
−        raise NotImplementedError()
+
−    def entity_deleted(self, entity, attr):
+
−        """an entity using this storage for attr has been deleted"""
+
−        raise NotImplementedError()
+
−
+
−# TODO
+
−# * make it configurable without code
+
−# * better file path attribution
+
−# * handle backup/restore
+
−
+
−def uniquify_path(dirpath, basename):
+
−    """return a unique file name for `basename` in `dirpath`, or None
+
−    if all attemps failed.
+
−
+
−    XXX subject to race condition.
+
−    """
+
−    path = osp.join(dirpath, basename)
+
−    if not osp.isfile(path):
+
−        return path
+
−    base, ext = osp.splitext(path)
+
−    for i in xrange(1, 256):
+
−        path = '%s%s%s' % (base, i, ext)
+
−        if not osp.isfile(path):
+
−            return path
+
−    return None
+
−
+
−class BytesFileSystemStorage(Storage):
+
−    """store Bytes attribute value on the file system"""
+
−    def __init__(self, defaultdir, fsencoding='utf-8'):
+
−        self.default_directory = defaultdir
+
−        self.fsencoding = fsencoding
+
−
+
−    def callback(self, source, value):
+
−        """sql generator callback when some attribute with a custom storage is
+
−        accessed
+
−        """
+
−        fpath = source.binary_to_str(value)
+
−        try:
+
−            return Binary(file(fpath).read())
+
−        except OSError, ex:
+
−            source.critical("can't open %s: %s", value, ex)
+
−            return None
+
−
+
−    def entity_added(self, entity, attr):
+
−        """an entity using this storage for attr has been added"""
+
−        if entity._cw.transaction_data.get('fs_importing'):
+
−            binary = Binary(file(entity[attr].getvalue()).read())
+
−        else:
+
−            binary = entity.pop(attr)
+
−            fpath = self.new_fs_path(entity, attr)
+
−            # bytes storage used to store file's path
+
−            entity[attr] = Binary(fpath)
+
−            file(fpath, 'w').write(binary.getvalue())
+
−            AddFileOp(entity._cw, filepath=fpath)
+
−        return binary
+
−
+
−    def entity_updated(self, entity, attr):
+
−        """an entity using this storage for attr has been updatded"""
+
−        if entity._cw.transaction_data.get('fs_importing'):
+
−            oldpath = self.current_fs_path(entity, attr)
+
−            fpath = entity[attr].getvalue()
+
−            if oldpath != fpath:
+
−                DeleteFileOp(entity._cw, filepath=oldpath)
+
−            binary = Binary(file(fpath).read())
+
−        else:
+
−            binary = entity.pop(attr)
+
−            fpath = self.current_fs_path(entity, attr)
+
−            UpdateFileOp(entity._cw, filepath=fpath, filedata=binary.getvalue())
+
−        return binary
+
−
+
−    def entity_deleted(self, entity, attr):
+
−        """an entity using this storage for attr has been deleted"""
+
−        DeleteFileOp(entity._cw, filepath=self.current_fs_path(entity, attr))
+
−
+
−    def new_fs_path(self, entity, attr):
+
−        # We try to get some hint about how to name the file using attribute's
+
−        # name metadata, so we use the real file name and extension when
+
−        # available. Keeping the extension is useful for example in the case of
+
−        # PIL processing that use filename extension to detect content-type, as
+
−        # well as providing more understandable file names on the fs.
+
−        basename = [str(entity.eid), attr]
+
−        name = entity.attr_metadata(attr, 'name')
+
−        if name is not None:
+
−            basename.append(name.encode(self.fsencoding))
+
−        fspath = uniquify_path(self.default_directory, '_'.join(basename))
+
−        if fspath is None:
+
−            msg = entity._cw._('failed to uniquify path (%s, %s)') % (
+
−                dirpath, '_'.join(basename))
+
−            raise ValidationError(entity.eid, {role_name(attr, 'subject'): msg})
+
−        return fspath
+
−
+
−    def current_fs_path(self, entity, attr):
+
−        sysource = entity._cw.pool.source('system')
+
−        cu = sysource.doexec(entity._cw,
+
−                             'SELECT cw_%s FROM cw_%s WHERE cw_eid=%s' % (
+
−                             attr, entity.__regid__, entity.eid))
+
−        rawvalue = cu.fetchone()[0]
+
−        if rawvalue is None: # no previous value
+
−            return self.new_fs_path(entity, attr)
+
−        return sysource._process_value(rawvalue, cu.description[0],
+
−                                       binarywrap=str)
+
−
+
−
+
−class AddFileOp(Operation):
+
−    def rollback_event(self):
+
−        try:
+
−            unlink(self.filepath)
+
−        except:
+
−            pass
+
−
+
−class DeleteFileOp(Operation):
+
−    def commit_event(self):
+
−        try:
+
−            unlink(self.filepath)
+
−        except:
+
−            pass
+
−
+
−class UpdateFileOp(Operation):
+
−    def precommit_event(self):
+
−        try:
+
−            file(self.filepath, 'w').write(self.filedata)
+
−        except Exception, ex:
+
−            self.exception(str(ex))