Synnefo » Pithos

    LengthRequired, PreconditionFailed, RangeNotSatisfiable, UnprocessableEntity)

from pithos.api.util import (format_meta_key, printable_meta_dict, get_account_meta,

    put_account_meta, get_container_meta, put_container_meta, get_object_meta, put_object_meta,

    validate_matching_preconditions, split_container_object_string, copy_or_move_object,

    get_int_parameter, get_content_length, get_content_range, get_sharing, raw_input_socket,

    socket_read_iterator, object_data_response, put_object_block, hashmap_hash, api_method)

from pithos.backends import backend

logger = logging.getLogger(__name__)

    #                       badRequest (400)

    until = get_int_parameter(request, 'until')

    response = HttpResponse(status=204)

    put_account_meta(response, meta)

    replace = True

    if 'update' in request.GET:

        replace = False

    return HttpResponse(status=202)

@api_method('GET', format_allowed=True)

    #                       badRequest (400)

    until = get_int_parameter(request, 'until')

    validate_modification_preconditions(request, meta)

    try:

        containers = backend.list_containers(request.user, v_account, marker, limit, until)

    except NameError:

        containers = []

            try:

                meta = backend.get_container_meta(request.user, v_account, x[0], until)

                container_meta.append(printable_meta_dict(meta))

            except NameError:

                pass

    if request.serialization == 'xml':

    try:

        meta = backend.get_container_meta(request.user, v_account, v_container, until)

        meta['object_meta'] = backend.list_object_meta(request.user, v_account, v_container, until)

    except NameError:

        raise ItemNotFound('Container does not exist')

    try:

        backend.put_container(request.user, v_account, v_container)

        ret = 201

    except NameError:

        ret = 202

    if len(meta) > 0:

    return HttpResponse(status=ret)

        replace = False

    try:

        backend.update_container_meta(request.user, v_account, v_container, meta, replace)

    except NameError:

        raise ItemNotFound('Container does not exist')

    return HttpResponse(status=202)

    try:

        backend.delete_container(request.user, v_account, v_container)

    except NameError:

        raise ItemNotFound('Container does not exist')

    except IndexError:

    try:

        meta = backend.get_container_meta(request.user, v_account, v_container, until)

        meta['object_meta'] = backend.list_object_meta(request.user, v_account, v_container, until)

    except NameError:

        raise ItemNotFound('Container does not exist')

    try:

        objects = backend.list_objects(request.user, v_account, v_container, prefix, delimiter, marker, limit, virtual, keys, until)

    except NameError:

        raise ItemNotFound('Container does not exist')

                    permissions = backend.get_object_permissions(request.user, v_account, v_container, x[0])

                else:

                    permissions = None

            except NameError:

                pass

            object_meta.append(printable_meta_dict(meta))

    if request.serialization == 'xml':

        data = render_to_string('objects.xml', {'container': v_container, 'objects': object_meta})

            permissions = backend.get_object_permissions(request.user, v_account, v_container, v_object)

        else:

            permissions = None

    except NameError:

        raise ItemNotFound('Object does not exist')

    except IndexError:

        raise ItemNotFound('Version does not exist')

    update_manifest_meta(request, v_account, meta)

    response = HttpResponse(status=200)

    put_object_meta(response, meta)

        if request.serialization == 'text':

            raise BadRequest('No format specified for version list.')

        if request.serialization == 'xml':

            d['object'] = v_object

            data = render_to_string('versions.xml', d)

            permissions = backend.get_object_permissions(request.user, v_account, v_container, v_object)

        else:

            permissions = None

    except NameError:

        raise ItemNotFound('Object does not exist')

    except IndexError:

        raise ItemNotFound('Version does not exist')

    update_manifest_meta(request, v_account, meta)

    # Evaluate conditions.

    validate_modification_preconditions(request, meta)

        try:

            src_container, src_name = split_container_object_string('/' + meta['X-Object-Manifest'])

            objects = backend.list_objects(request.user, v_account, src_container, prefix=src_name, virtual=False)

        except ValueError:

            raise BadRequest('Invalid X-Object-Manifest header')

        except NameError:

                s, h = backend.get_object_hashmap(request.user, v_account, src_container, x[0], x[1])

                sizes.append(s)

                hashmaps.append(h)

        except NameError:

            raise ItemNotFound('Object does not exist')

        except IndexError:

            s, h = backend.get_object_hashmap(request.user, v_account, v_container, v_object, version)

            sizes.append(s)

            hashmaps.append(h)

        except NameError:

            raise ItemNotFound('Object does not exist')

        except IndexError:

    try:

        backend.update_object_hashmap(request.user, v_account, v_container, v_object, size, hashmap, meta, True, permissions)

    except NameError:

        raise ItemNotFound('Container does not exist')

    except ValueError:

    try:

        prev_meta = backend.get_object_meta(request.user, v_account, v_container, v_object)

    except NameError:

        raise ItemNotFound('Object does not exist')

    # If replacing, keep previous values of 'Content-Type' and 'hash'.

    # A Content-Type header indicates data updates.

    if not content_type or content_type != 'application/octet-stream':

            try:

                backend.update_object_permissions(request.user, v_account, v_container, v_object, permissions)

            except NameError:

                raise ItemNotFound('Object does not exist')

            except ValueError:

                raise BadRequest('Invalid sharing header')

            except AttributeError:

                raise Conflict('Sharing already set above or below this path in the hierarchy')

        return HttpResponse(status=202)

    # Single range update. Range must be in Content-Range.

    try:

        size, hashmap = backend.get_object_hashmap(request.user, v_account, v_container, v_object)

    except NameError:

        raise ItemNotFound('Object does not exist')

    meta.update({'hash': hashmap_hash(hashmap)}) # Update ETag.

    try:

        backend.update_object_hashmap(request.user, v_account, v_container, v_object, size, hashmap, meta, replace, permissions)

    except NameError:

        raise ItemNotFound('Container does not exist')

    except ValueError:

    try:

        backend.delete_object(request.user, v_account, v_container, v_object)

    except NameError:

        raise ItemNotFound('Object does not exist')

    return HttpResponse(status=204)

from pithos.api.faults import (Fault, NotModified, BadRequest, ItemNotFound, LengthRequired,

                                PreconditionFailed, RangeNotSatisfiable, ServiceUnavailable)

from pithos.backends import backend

import datetime

import logging

        response['X-Object-Version-Timestamp'] = meta['version_timestamp']

        for k in [x for x in meta.keys() if x.startswith('X-Object-Meta-')]:

            response[k.encode('utf-8')] = meta[k].encode('utf-8')

            if k in meta:

                response[k] = meta[k]

    else:

        md5.update(hash)

        meta['hash'] = md5.hexdigest().lower()

    ret = []

    if r:

        ret.append('read=' + r)

    if w:

        ret.append('write=' + w)

def validate_modification_preconditions(request, meta):

    """Check that the modified timestamp conforms with the preconditions set."""

            backend.move_object(request.user, v_account, src_container, src_name, dest_container, dest_name, meta, False, permissions)

        else:

            backend.copy_object(request.user, v_account, src_container, src_name, dest_container, dest_name, meta, False, permissions, src_version)

    except NameError, IndexError:

        raise ItemNotFound('Container or object does not exist')

    except ValueError:

    """

    permissions = request.META.get('HTTP_X_OBJECT_SHARING')

        return None

    ret = {}

            ret['read'] = [v.replace(' ','') for v in perm[5:].split(',')]

            if '*' in ret['read']:

                ret['read'] = ['*']

            if len(ret['read']) == 0:

                raise BadRequest('Bad X-Object-Sharing header value')

        elif perm.startswith('write='):

            ret['write'] = [v.replace(' ','') for v in perm[6:].split(',')]

            if '*' in ret['write']:

                ret['write'] = ['*']

            if len(ret['write']) == 0:

                raise BadRequest('Bad X-Object-Sharing header value')

        else:

            raise BadRequest('Bad X-Object-Sharing header value')

    return ret

def raw_input_socket(request):

# interpreted as representing official policies, either expressed

# or implied, of GRNET S.A.

class BaseBackend(object):

    """Abstract backend class that serves as a reference for actual implementations.

        """Delete the account with the given name.

        Raises:

            IndexError: Account is not empty

        """

        return

            'bytes': The total data size (or 0)

            'modified': Last modification timestamp (overall)

            'until_timestamp': Last modification until the timestamp provided

        """

        return {}

        Parameters:

            'meta': Dictionary with metadata to update

            'replace': Replace instead of update

        """

        return

        Parameters:

            'marker': Start list from the next item after 'marker'

            'limit': Number of containers to return

        """

        return []

        """Create a new container with the given name.

        Raises:

            NameError: Container already exists

        """

        return

        """Delete the container with the given name.

        Raises:

            NameError: Container does not exist

            IndexError: Container is not empty

        """

            'until_timestamp': Last modification until the timestamp provided

        Raises:

            NameError: Container does not exist

        """

        return {}

            'replace': Replace instead of update

        Raises:

            NameError: Container does not exist

        """

        return

            'keys': Include objects that have meta with the keys in the list

        Raises:

            NameError: Container does not exist

        """

        return []

        """Return a list with all the container's object meta keys.

        Raises:

            NameError: Container does not exist

        """

        return []

            'version_timestamp': The version's modification timestamp

        Raises:

            NameError: Container/object does not exist

            IndexError: Version does not exist

        """

            'replace': Replace instead of update

        Raises:

            NameError: Container/object does not exist

        """

        return

    def get_object_permissions(self, user, account, container, name):

        The keys are:

            'read': The object is readable by the users/groups in the list

            'write': The object is writable by the users/groups in the list

        Raises:

            NameError: Container/object does not exist

        """

        return {}

            'permissions': Dictionary with permissions to update

        Raises:

            NameError: Container/object does not exist

            ValueError: Invalid users/groups in permissions

            AttributeError: Can not set permissions, as this object\

        """Return the object's size and a list with partial hashes.

        Raises:

            NameError: Container/object does not exist

            IndexError: Version does not exist

        """

        return 0, []

        """Create/update an object with the specified size and partial hashes.

        Parameters:

            'permissions': Updated object permissions

        Raises:

            NameError: Container does not exist

            ValueError: Invalid users/groups in permissions

            AttributeError: Can not set permissions

        """

        return

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

        Parameters:

            'src_version': Copy from the version provided

        Raises:

            NameError: Container/object does not exist

            IndexError: Version does not exist

            ValueError: Invalid users/groups in permissions

        """

        return

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

        Parameters:

            'permissions': New object permissions

        Raises:

            NameError: Container/object does not exist

            ValueError: Invalid users/groups in permissions

            AttributeError: Can not set permissions

        """Delete an object.

        Raises:

            NameError: Container/object does not exist

        """

        return

    def list_versions(self, user, account, container, name):

        return []

    def get_block(self, hash):

import shutil

import pickle

logger = logging.getLogger(__name__)

        """Delete the account with the given name."""

        logger.debug("delete_account: %s", account)

        count, bytes, tstamp = self._get_pathstats(account)

        if count > 0:

            raise IndexError('Account is not empty')

        """Return a dictionary with the account metadata."""

        logger.debug("get_account_meta: %s %s", account, until)

        try:

            version_id, mtime = self._get_accountinfo(account, until)

        except NameError:

        """Update the metadata associated with the account."""

        logger.debug("update_account_meta: %s %s %s", account, meta, replace)

        self._put_metadata(account, meta, replace)

    def list_containers(self, user, account, marker=None, limit=10000, until=None):

        """Return a list of containers existing under an account."""

        logger.debug("list_containers: %s %s %s %s", account, marker, limit, until)

        return self._list_objects(account, '', '/', marker, limit, False, [], until)

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

        """Create a new container with the given name."""

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

        try:

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

        except NameError:

        """Delete the container with the given name."""

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

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

        count, bytes, tstamp = self._get_pathstats(path)

        if count > 0:

        """Return a dictionary with the container metadata."""

        logger.debug("get_container_meta: %s %s %s", account, container, until)

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

        count, bytes, tstamp = self._get_pathstats(path, until)

        if mtime > tstamp:

        """Update the metadata associated with the container."""

        logger.debug("update_container_meta: %s %s %s %s", account, container, meta, replace)

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

        self._put_metadata(path, meta, replace)

        """Return a list of objects existing under a container."""

        logger.debug("list_objects: %s %s %s %s %s %s %s", account, container, prefix, delimiter, marker, limit, until)

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

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

        """Return a list with all the container's object meta keys."""

        logger.debug("list_object_meta: %s %s %s", account, container, until)

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

        sql = '''select distinct m.key from (%s) o, metadata m

                    where m.version_id = o.version_id and o.name like ?'''

        """Return a dictionary with the object metadata."""

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

        path, version_id, mtime, size = self._get_objectinfo(account, container, name, version)

        if version is None:

            modified = mtime

        """Update the metadata associated with the object."""

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

        path, version_id, mtime, size = self._get_objectinfo(account, container, name)

        self._put_metadata(path, meta, replace)

    def get_object_permissions(self, user, account, container, name):

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

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

    def update_object_permissions(self, user, account, container, name, permissions):

        """Update the permissions associated with the object."""

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

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

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

        self._put_permissions(path, r, w)

        """Return the object's size and a list with partial hashes."""

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

        path, version_id, mtime, size = self._get_objectinfo(account, container, name, version)

        sql = 'select block_id from hashmaps where version_id = ? order by pos asc'

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

        hashmap = [x[0] for x in c.fetchall()]

        return size, hashmap

        """Create/update an object with the specified size and partial hashes."""

        logger.debug("update_object_hashmap: %s %s %s %s %s", account, container, name, size, hashmap)

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

        path = os.path.join(path, name)

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

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

        sql = 'update versions set size = ? where version_id = ?'

        for k, v in meta.iteritems():

            sql = 'insert or replace into metadata (version_id, key, value) values (?, ?, ?)'

            self.con.execute(sql, (dest_version_id, k, v))

            sql = 'insert or replace into permissions (name, read, write) values (?, ?, ?)'

            self.con.execute(sql, (path, r, w))

        self.con.commit()

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

        logger.debug("copy_object: %s %s %s %s %s %s %s %s %s", account, src_container, src_name, dest_container, dest_name, dest_meta, replace_meta, permissions, src_version)

        self._get_containerinfo(account, src_container)

        if src_version is None:

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

            src_path = os.path.join(account, src_container, src_name)

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

        dest_path = os.path.join(dest_path, dest_name)

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

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

        for k, v in dest_meta.iteritems():

            sql = 'insert or replace into metadata (version_id, key, value) values (?, ?, ?)'

            self.con.execute(sql, (dest_version_id, k, v))

            sql = 'insert or replace into permissions (name, read, write) values (?, ?, ?)'

            self.con.execute(sql, (dest_path, r, w))

        self.con.commit()

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

        logger.debug("move_object: %s %s %s %s %s %s %s %s", account, src_container, src_name, dest_container, dest_name, dest_meta, replace_meta, permissions)

        """Delete an object."""

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

        path, version_id, mtime, size = self._get_objectinfo(account, container, name)

        self._put_version(path, 0, 1)

        sql = 'delete from permissions where name = ?'

        """Return a list of all (version, version_timestamp) tuples for an object."""

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

        # This will even show deleted versions.

        path = os.path.join(account, container, name)

        sql = '''select distinct version_id, strftime('%s', tstamp) from versions where name = ? and hide = 0'''

                self.con.execute(sql, (dest_version_id, k, v))

        self.con.commit()

    def _check_permissions(self, path, permissions):

        # Check for existing permissions.

        if rows:

            raise AttributeError('Permissions already set')

        r = permissions.get('read', [])

        w = permissions.get('write', [])

        if True in [False or ',' in x for x in r]:

            raise ValueError('Bad characters in read permissions')

        if True in [False or ',' in x for x in w]:

            raise ValueError('Bad characters in write permissions')

    def _get_permissions(self, path):

        # Check for permissions at path or above.

            return path, {}

        name, r, w = row

        ret = {}

        if w != '':

            ret['write'] = w.split(',')

        if r != '':

        return name, ret

    def _put_permissions(self, path, r, w):

        self.con.commit()

    def _list_objects(self, path, prefix='', delimiter=None, marker=None, limit=10000, virtual=True, keys=[], until=None):

    try:

        meta = backend.get_object_meta(request.user, v_account, v_container, v_object)

        permissions = backend.get_object_permissions(request.user, v_account, v_container, v_object)

        raise ItemNotFound('Object does not exist')

    if 'public' not in permissions:

        raise ItemNotFound('Object does not exist')

    update_manifest_meta(request, v_account, meta)

    try:

        meta = backend.get_object_meta(request.user, v_account, v_container, v_object)

        permissions = backend.get_object_permissions(request.user, v_account, v_container, v_object)

        raise ItemNotFound('Object does not exist')

    if 'public' not in permissions:

        raise ItemNotFound('Object does not exist')

    update_manifest_meta(request, v_account, meta)

        try:

            src_container, src_name = split_container_object_string('/' + meta['X-Object-Manifest'])

            objects = backend.list_objects(request.user, v_account, src_container, prefix=src_name, virtual=False)

            raise ItemNotFound('Object does not exist')

        try:

                s, h = backend.get_object_hashmap(request.user, v_account, src_container, x[0], x[1])

                sizes.append(s)

                hashmaps.append(h)

            raise ItemNotFound('Object does not exist')

    else:

        try:

            s, h = backend.get_object_hashmap(request.user, v_account, v_container, v_object, version)

            sizes.append(s)

            hashmaps.append(h)

            raise ItemNotFound('Object does not exist')

    return object_data_response(request, sizes, hashmaps, meta, True)