Synnefo » ./kamaki

        r = self.container_delete(until=unicode(time()))

        r.release()

        """

        :param obj: (str) remote object path

                import json

                data = json.dumps(json.loads(data))

            except ValueError:

            except SyntaxError:

            f = StringIO(data)

        data = f.read(size) if size is not None else f.read()

            data=data,

            etag=etag,

            content_encoding=content_encoding,

            success=201)

        r.release()

        """

        :param obj: (str) remote object path

        :param public: (bool)

        """

        self._assert_container()

            content_length=0,

            etag=etag,

            content_encoding=content_encoding,

        from random import randint

        if not randint(0, 7):

            raise ClientError('BAD GATEWAY STUFF', 503)

            content_type='application/octet-stream',

            content_length=len(data),

            data=data,

        nblocks = 1 + (size - 1) // blocksize

        return (blocksize, blockhash, size, nblocks)

            format='json',

            hashmap=True,

            content_type=content_type,

            return None

        return r.json

        hash_cb=None):

        offset = 0

        if hash_cb:

            if hash_cb:

                hash_gen.next()

        if offset != size:

    def _upload_missing_blocks(self, missing, hmap, fileobj, upload_gen=None):

        """upload missing blocks asynchronously"""

            for thread in set(flying).difference(unfinished):

                if thread.exception:

                    failures.append(thread)

                elif thread.isAlive():

                    flying.append(thread)

                elif upload_gen:

        return [failure.kwargs['hash'] for failure in failures]

        """Upload an object using multiple connections (threads)

        :param obj: (str) remote object path

        if content_type is None:

            content_type = 'application/octet-stream'

            hashes=hashes,

            hmap=hmap,

            fileobj=f,

            hash_cb=hash_cb)

        hashmap = dict(bytes=size, hashes=hashes)

            content_type=content_type,

            size=size,

            etag=etag,

            map_dict[h] = i

        return (blocksize, blockhash, total_size, hashmap['hashes'], map_dict)

        for blockid, blockhash in enumerate(remote_hashes):

        event.start()

        return event

        h.update(block.strip('\x00'))

        return hexlify(h.digest())

        """write the results of a greenleted rest call to a file

        @offset: the offset of the file up to blocksize

            - e.g. if the range is 10-100, all

        local_file.flush()

        return finished

        file_size = fstat(local_file.fileno()).st_size if resume else 0

        flying = {}

        finished = []

        self._init_thread_limit()

        for block_hash, blockid in remote_hashes.items():

            start = blocksize * blockid

                self._cb_next()

                continue

            self._watch_thread_limit(flying.values())

            thread.join()

        finished += self._thread2file(flying, local_file, offset, **restargs)

        """Download an object using multiple connections (threads) and

            writing to random parts of the file

        :param resume: (bool) if set, preserve already downloaded file parts

        :param if_match: (str)

        :param if_unmodified_since: (str) formated date

        """

            if_match=if_match,

            if_none_match=if_none_match,

            if_modified_since=if_modified_since,

            if_unmodified_since=if_unmodified_since)

            blockhash,

            total_size,

            hash_list,

            self._cb_next()

        if dst.isatty():

                hash_list,

                blocksize,

                total_size,

                dst,

                **restargs)

        else:

                remote_hashes,

                blocksize,

                total_size,

                dst,

                blockhash,

                resume,

                **restargs)

                dst.truncate(total_size)

        self._complete_cb()

            except:

                break

        """

        :param obj: (str) remote object path

        :returns: (list)

        """

        try:

                hashmap=True,

                version=version,

                if_etag_match=if_match,

        """

        :returns: (dict)

        """

            'X-Account-Policy-Quota',

            exactMatch=True)

        """

        :returns: (dict)

        """

            'X-Account-Policy-Versioning',

            exactMatch=True)

            success=(204, 404, 409))

        r.release()

        if r.status_code == 404:

                r.status_code)

        elif r.status_code == 409:

                r.status_code)

    def get_container_versioning(self, container):

        :returns: (dict)

        """

        self.container = container

            'X-Container-Policy-Versioning')

    def get_container_quota(self, container):

        :returns: (dict)

        """

            'X-Container-Meta')

    def get_container_object_meta(self, until=None):

        :returns: (dict)

        """

            'X-Container-Object-Meta')

    def set_container_meta(self, metapairs):

        info = self.get_object_info(obj)

        pref, sep, rest = self.base_url.partition('//')

        base = rest.split('/')[0]

            info['x-object-public'])

        return newurl[1:]

        :returns: (dict)

        """

            'X-Object-Meta')

    def get_object_sharing(self, obj):

        :returns: (dict)

        """

            'X-Object-Sharing',

            exactMatch=True)

        reply = {}

                reply[key] = val

        return reply

        """Give read/write permisions to an object.

        :param obj: (str) remote object path

           permissions will be removed

        """

            write='' if not write_permition else write_permition)

        r = self.object_post(obj, update=True, permissions=perms)

        r.release()

        for i in range(nblocks):

            block = source_file.read(min(blocksize, filesize - offset))

            offset += len(block)

                update=True,

                content_range='bytes */*',

                content_type='application/octet-stream',

        :param upto_bytes: max number of bytes to leave on file

        """

            update=True,

            content_range='bytes 0-%s/*' % upto_bytes,

            content_type='application/octet-stream',

            source_object=path4url(self.container, obj))

        r.release()

        upload_cb=None):

        """Overwrite a part of an object from local source file

            upload_gen = upload_cb(nblocks)

            upload_gen.next()

        for i in range(nblocks):

                update=True,

                content_type='application/octet-stream',

                content_length=len(block),

            if upload_cb:

                upload_gen.next()

        dst_object=False,

        source_version=None,

        public=False,

        self.container = dst_container

        dst_object = dst_object or src_object

        src_path = path4url(src_container, src_object)

            success=201,

            copy_from=src_path,

            content_length=0,

            delimiter=delimiter)

        r.release()

        """

        :param src_container: (str) source container

        self.container = dst_container

        dst_object = dst_object or src_object

        src_path = path4url(src_container, src_object)

            success=201,

            move_from=src_path,

            content_length=0,