Synnefo » Pithos

        execute(""" create table if not exists attributes

                          ( serial integer,

                            key    text,

                            value  text,

                            foreign key (serial)

                            references versions(serial)

                            on update cascade

        self.execute(q, (serial,))

        return hash

        """Return a list of (key, value) pairs of the version specified by serial.

           If keys is empty, return all attributes.

           Othwerise, return only those specified.

        if keys:

            marks = ','.join('?' for k in keys)

            q = ("select key, value from attributes "

        else:

            q = "select key, value from attributes where serial = ?"

            execute(q, (serial,))

        return self.fetchall()

        """Set the attributes of the version specified by serial.

           Receive attributes as an iterable of (key, value) pairs.

        """

        """Delete attributes of the version specified by serial.

           If keys is empty, delete all attributes.

           Otherwise delete those specified.

        """

        if keys:

        else:

    def attribute_copy(self, source, dest):

        q = ("insert or replace into attributes "

             "where serial = ?")

        self.execute(q, (dest, source))

            return None, None

        subqlist = []

        append = subqlist.append

        args = []

        if included:

            t = (("(a.key = ? and a.value %s ?)" % (o,)) for k, o, v in opers)

            subq = "(" + ' or '.join(t) + ")"

            for k, o, v in opers:

            append(subq)

        if not subqlist:

            return None, None

        return subq, args

        return subq, args

        """Return a list with all keys pairs defined

           for all latest versions under parent that

           do not belong to the cluster.

                           "from nodes "

                           "where parent = ?) "

             "and a.serial = v.serial "

             "and n.node = v.node")

        subq, subargs = self._construct_paths(pathq)

        if subq is not None:

            q += subq

    def latest_version_list(self, parent, prefix='', delimiter=None,

                            start='', limit=10000, before=inf,

        """Return a (list of (path, serial) tuples, list of common prefixes)

           for the current versions of the paths with the given parent,

           matching the following criteria.

        if subq is not None:

            q += subq

            args += subargs

        if subq is not None:

            q += subq

            args += subargs

        else:

            meta = {}

            if props is not None:

            if until is not None:

                meta.update({'until_timestamp': tstamp})

            meta.update({'name': account, 'count': count, 'bytes': bytes})

        if user != account:

            raise NotAllowedError

        path, node = self._lookup_account(account, True)

    @backend_method

    def get_account_groups(self, user, account):

            start, limit = self._list_limits(allowed, marker, limit)

            return allowed[start:start + limit]

        node = self.node.node_lookup(account)

    @backend_method

    def get_container_meta(self, user, account, container, domain, until=None):

        if user != account:

            meta = {'name': container}

        else:

            if until is not None:

                meta.update({'until_timestamp': tstamp})

            meta.update({'name': container, 'count': count, 'bytes': bytes})

        if user != account:

            raise NotAllowedError

        path, node = self._lookup_container(account, container)

    @backend_method

    def get_container_policy(self, user, account, container):

                if not allowed:

                    return []

        path, node = self._lookup_container(account, container)

    @backend_method

    def list_object_meta(self, user, account, container, domain, until=None):

                raise NotAllowedError

        path, node = self._lookup_container(account, container)

        before = until if until is not None else inf

    @backend_method

    def get_object_meta(self, user, account, container, name, domain, version=None):

                    raise NameError('Object does not exist')

                modified = del_props[self.MTIME]

        meta.update({'name': name, 'bytes': props[self.SIZE], 'hash':props[self.HASH]})

        meta.update({'version': props[self.SERIAL], 'version_timestamp': props[self.MTIME]})

        meta.update({'modified': modified, 'modified_by': props[self.MUSER]})

        logger.debug("update_object_meta: %s %s %s %s %s %s", account, container, name, domain, meta, replace)

        self._can_write(user, account, container, name)

        path, node = self._lookup_object(account, container, name)

        self._apply_versioning(account, container, src_version_id)

        return dest_version_id

        hashmap = self.store.map_get(binascii.unhexlify(props[self.HASH]))

        return props[self.SIZE], [binascii.hexlify(x) for x in hashmap]

        if permissions is not None and user != account:

            raise NotAllowedError

        self._can_write(user, account, container, name)

                # This must be executed in a transaction, so the version is never created if it fails.

                raise QuotaError

        if permissions is not None:

            self.permissions.access_set(path, permissions)

        self._apply_versioning(account, container, src_version_id)

    @backend_method

    def update_object_hashmap(self, user, account, container, name, size, hashmap, domain, meta={}, replace_meta=False, permissions=None):

            raise ie

        hash = map.hash()

        self.store.map_put(hash, map)

        return dest_version_id

        self._can_read(user, src_account, src_container, src_name)

        path, node = self._lookup_object(src_account, src_container, src_name)

        props = self._get_version(node, src_version)

        hash = props[self.HASH]

        size = props[self.SIZE]

        return dest_version_id

    @backend_method

        """Copy an object's data and metadata."""

        logger.debug("copy_object: %s %s %s %s %s %s %s %s %s %s %s", src_account, src_container, src_name, dest_account, dest_container, dest_name, domain, meta, replace_meta, permissions, src_version)

    @backend_method

    def move_object(self, user, src_account, src_container, src_name, dest_account, dest_container, dest_name, domain, meta={}, replace_meta=False, permissions=None):

        logger.debug("move_object: %s %s %s %s %s %s %s %s %s %s", src_account, src_container, src_name, dest_account, dest_container, dest_name, domain, meta, replace_meta, permissions)

        if user != src_account:

            raise NotAllowedError

        if (src_account, src_container, src_name) != (dest_account, dest_container, dest_name):

            self._delete_object(user, src_account, src_container, src_name)

        return dest_version_id

        dest_version_id, mtime = self.node.version_create(node, hash, size, src_version_id, user, cluster)

        return src_version_id, dest_version_id

        """Create a new version and store metadata."""

        src_version_id, dest_version_id = self._put_version_duplicate(user, node)

        return src_version_id, dest_version_id

    def _list_limits(self, listing, marker, limit):

            limit = 10000

        return start, limit

        cont_prefix = path + '/'

        prefix = cont_prefix + prefix

        start = cont_prefix + marker if marker else None

        before = until if until is not None else inf

        objects.extend([(p, None) for p in prefixes] if virtual else [])

        objects.sort(key=lambda x: x[0])

        objects = [(x[0][len(cont_prefix):], x[1]) for x in objects]

import re

def parse_filters(terms):