Synnefo

    update_manifest_meta, format_permissions, validate_modification_preconditions,

    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)

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

            if permissions:

                meta['X-Object-Sharing'] = format_permissions(permissions)

            object_meta.append(printable_meta_dict(meta))

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

    if permissions:

        meta['X-Object-Sharing'] = format_permissions(permissions)

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

    if permissions:

        meta['X-Object-Sharing'] = format_permissions(permissions)

    #                       conflict (409),

    permissions = get_sharing(request)

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

    except ValueError:

        raise BadRequest('Invalid sharing header')

    except AttributeError:

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

    #                       conflict (409),

    permissions = get_sharing(request)

    # Handle permission changes.

    if permissions:

        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')

    # TODO: Merge above functions with updating the hashmap if there is data in the request.

    except ValueError:

        raise BadRequest('Invalid sharing header')

    except AttributeError:

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

        for k in ('Content-Encoding', 'Content-Disposition', 'X-Object-Manifest', 'X-Object-Sharing'):

def format_permissions(permissions):

    ret = []

    if 'public' in permissions:

        ret.append('public')

    if 'private' in permissions:

        ret.append('private')

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

    if r:

        ret.append('read=' + r)

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

    if w:

        ret.append('write=' + w)

    return '; '.join(ret)

    permissions = get_sharing(request)

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

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

    except ValueError:

        raise BadRequest('Invalid sharing header')

    except AttributeError:

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

def get_sharing(request):

    """Parse an X-Object-Sharing header from the request.

    Raises BadRequest on error.

    """

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

    if permissions is None or permissions == '':

        return None

    ret = {}

    for perm in (x.replace(' ','') for x in permissions.split(';')):

        if perm == 'public':

            ret['public'] = True

            continue

        elif perm == 'private':

            ret['private'] = True

            continue

        elif perm.startswith('read='):

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

            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 len(ret['write']) == 0:

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

        else:

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

    return ret

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

        """Return a dictionary with the object permissions.

        The keys are:

            'public': The object is readable by all and available at a public URL

            'private': No permissions set

            '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 {}

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

        """Update the permissions associated with the object.

        Parameters:

            '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\

                is already shared/private by another object higher\

                in the hierarchy, or setting permissions here will\

                invalidate other permissions deeper in the hierarchy

        """

        return

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

        Parameters:

            'dest_meta': Dictionary with metadata to change

            'replace_meta': Replace metadata instead of update

            'permissions': Updated object permissions

            ValueError: Invalid users/groups in permissions

            AttributeError: Can not set permissions

    def copy_object(self, user, account, src_container, src_name, dest_container, dest_name, dest_meta={}, replace_meta=False, permissions={}, src_version=None):

            'dest_meta': Dictionary with metadata to change from source to destination

            'permissions': New object permissions

            'src_version': Copy from the version provided

            ValueError: Invalid users/groups in permissions

            AttributeError: Can not set permissions

    def move_object(self, user, account, src_container, src_name, dest_container, dest_name, dest_meta={}, replace_meta=False, permissions={}):

            'dest_meta': Dictionary with metadata to change from source to destination

            'permissions': New object permissions

            ValueError: Invalid users/groups in permissions

            AttributeError: Can not set permissions

        sql = '''create table if not exists permissions (

                    name text, read text, write text, primary key (name))'''

        self.con.execute(sql)

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

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

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

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

        return self._get_permissions(path)

    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)

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

        if permissions:

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

        if permissions:

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

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

    def copy_object(self, user, account, src_container, src_name, dest_container, dest_name, dest_meta={}, replace_meta=False, permissions={}, src_version=None):

        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)

        if permissions:

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

        if permissions:

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

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

    def move_object(self, user, account, src_container, src_name, dest_container, dest_name, dest_meta={}, replace_meta=False, permissions={}):

        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)

        self.copy_object(user, account, src_container, src_name, dest_container, dest_name, dest_meta, replace_meta, permissions, None)

        sql = 'delete from permissions where name = ?'

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

        self.con.commit()

    def _can_read(self, user, path):

        return True

    def _can_write(self, user, path):

        return True

    def _check_permissions(self, path, permissions):

        # Check for existing permissions.

        sql = '''select name from permissions

                    where name != ? and (name like ? or ? like name || ?)'''

        c = self.con.execute(sql, (path, path + '%', path, '%'))

        if c.fetchall() is not None:

            raise AttributeError('Permissions already set')

        # Format given permissions set.

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

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

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

            raise ValueError('Bad characters in read permissions')

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

            raise ValueError('Bad characters in write permissions')

        r = ','.join(r)

        w = ','.join(w)

        if 'public' in permissions:

            r = '*'

        if 'private' in permissions:

            r = ''

            w = ''

        return r, w

    def _get_permissions(self, path):

        sql = 'select read, write from permissions where name = ?'

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

        row = c.fetchone()

        if not row:

            return {}

        r, w = row

        if r == '' and w == '':

            return {'private': True}

        ret = {}

        if w != '':

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

        if r != '':

            if r == '*':

                ret['public'] = True

            else:

                ret['read'] = r.split(',')        

        return ret

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

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

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

        self.con.commit()

        sql = '''delete from permissions where name like ?'''

        self.con.execute(sql, (path + '%',)) # Redundant.

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

    if 'public' not in permissions:

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

    if 'public' not in permissions: