Synnefo

        logger.debug("update_object_meta: %s %s %s %s %s %s %s",

                     user, account, container, name, domain, meta, replace)

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

        src_version_id, dest_version_id = self._put_metadata(

            user, node, domain, meta, replace,

            update_statistics_ancestors_depth=1)

                     user, account, container, name, permissions)

        if user != account:

            raise NotAllowedError

        self._check_permissions(path, permissions)

        self.permissions.access_set(path, permissions)

        self._report_sharing_change(user, account, path, {'members':

        logger.debug("update_object_public: %s %s %s %s %s", user,

                     account, container, name, public)

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

        if not public:

            self.permissions.public_unset(path)

        else:

            raise ie

        hash = map.hash()

        dest_version_id = self._update_object_hash(user, account, container, name, size, type, binascii.hexlify(hash), checksum, domain, meta, replace_meta, permissions)

        self.store.map_put(hash, map)

        return dest_version_id

                     user, account, container, name, version, checksum)

        # Update objects with greater version and same hashmap and size (fix metadata updates).

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

        props = self._get_version(node, version)

        versions = self.node.node_get_versions(node)

        for x in versions:

        dest_meta = dest_meta or {}

        dest_version_ids = []

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

        # TODO: Will do another fetch of the properties in duplicate version...

        props = self._get_version(

            node, src_version)  # Check to see if source exists.

        size = props[self.SIZE]

        is_copy = not is_move and (src_account, src_container, src_name) != (

            dest_account, dest_container, dest_name)  # New uuid.

        dest_version_ids.append(self._update_object_hash(user, dest_account, dest_container, dest_name, size, type, hash, None, dest_domain, dest_meta, replace_meta, permissions, src_node=node, src_version_id=src_version_id, is_copy=is_copy))

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

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

                dest_prefix = dest_name + delimiter if not dest_name.endswith(

                    delimiter) else dest_name

                vdest_name = path.replace(prefix, dest_prefix, 1)

                dest_version_ids.append(self._update_object_hash(user, dest_account, dest_container, vdest_name, size, vtype, hash, None, dest_domain, meta={}, replace_meta=False, permissions=None, src_node=node, src_version_id=src_version_id, is_copy=is_copy))

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

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

        if user != account:

            raise NotAllowedError

        if until is not None:

            path = '/'.join((account, container, name))

            node = self.node.node_lookup(path)

            )

            return

        src_version_id, dest_version_id = self._put_version_duplicate(

            user, node, size=0, type='', hash=None, checksum='',

            cluster=CLUSTER_DELETED, update_statistics_ancestors_depth=1)

            raise ItemNotExists('Container does not exist')

        return path, node

        path = '/'.join((account, container, name))

        node = self.node.node_lookup(path)

        if node is None: