Synnefo

# interpreted as representing official policies, either expressed

# or implied, of GRNET S.A.

import logging

import hashlib

    if not x_auth_user or not x_auth_key:

        raise BadRequest('Missing X-Auth-User or X-Auth-Key header')

    response = HttpResponse(status=204)

    inv_auth_tokens = dict((v, k) for k, v in settings.AUTH_TOKENS.items())

    response['X-Auth-Token'] = inv_auth_tokens.get(x_auth_user, '0000')

    return response

@api_method('GET', format_allowed=True)

    def test_move(self):

        #perform move

        meta = {'test':'testcopy'}

        status = self.client.move_object(self.containers[0], self.obj['name'],

                                         self.containers[0], 'testcopy',

                                         meta)[0]

           'photos/me.jpg']

if __name__ == "__main__":

            raise NameError('Container already exists')

        if policy:

            self._check_policy(policy)

        version_id = self._put_version(path, user)[0]

        for k, v in self.default_policy.iteritems():

            if k not in policy:

        if user != account:

            if until:

                raise NotAllowedError

            if not allowed:

                raise NotAllowedError

        else:

            if shared:

        path, version_id, mtime = self._get_containerinfo(account, container, until)

        return self._list_objects(path, prefix, delimiter, marker, limit, virtual, keys, until, allowed)

        if user != account:

            if until:

                raise NotAllowedError

            if not allowed:

                raise NotAllowedError

        path, version_id, mtime = self._get_containerinfo(account, container, until)

            ie.data = missing

            raise ie

        path = self._get_containerinfo(account, container)[0]

        if permissions is not None:

            r, w = self._check_permissions(path, permissions)

        src_version_id, dest_version_id = self._copy_version(user, path, path, not replace_meta, False)

        if src_version is None:

            src_path = self._get_objectinfo(account, src_container, src_name)[0]

        else:

        dest_path = self._get_containerinfo(account, dest_container)[0]

        if permissions is not None:

            r, w = self._check_permissions(dest_path, permissions)

        src_version_id, dest_version_id = self._copy_version(user, src_path, dest_path, not replace_meta, True, src_version)

            raise NotAllowedError

        if until is not None:

            sql = '''select version_id from versions where name = ? and tstamp <= ?'''

            c = self.con.execute(sql, (path, until))

            for v in [x[0] in c.fetchall()]:

        logger.debug("list_versions: %s %s %s", account, container, name)

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

        # This will even show deleted versions.

        sql = '''select distinct version_id, tstamp from versions where name = ? and hide = 0'''

        c = self.con.execute(sql, (path,))

        return [(int(x[0]), int(x[1])) for x in c.fetchall()]

            p = p[:p.index(None)]

        except ValueError:

            pass

        sql = '''select version_id, tstamp, size from (%s) where name = ?'''

        sql = sql % self._sql_until(until)

        c = self.con.execute(sql, (path,))

            raise NameError('Container does not exist')

    def _get_objectinfo(self, account, container, name, version=None):

        version_id, muser, mtime, size = self._get_version(path, version)

        return path, version_id, muser, mtime, size

    def _is_allowed(self, user, account, container, name, op='read'):

        if user == account:

            return True

        if op == 'read' and self._get_public(path):

            return True

        perm_path, perms = self._get_permissions(path)

            "modificationDate": 1223372769275,

            "lastLogin": 1223372769275}

        self.b.update_account_meta('test', self.account, meta)

        db_meta = self.b.get_account_meta('test', self.account)

        for k,v in meta.iteritems():