Synnefo » ./kamaki

    def set_default_header(self, name, value):

        self.http_client.headers.setdefault(name, value)

        try:

            success = kwargs.pop('success', 200)

            data = kwargs.pop('data', None)

            self.set_default_header('X-Auth-Token', self.token)

                self.set_default_header('Content-Length', unicode(len(data)))

            self.http_client.url = self.base_url + path

            req = self.http_client

            sendlog.info('%s %s', method, req.url)

            recvlog.info('%d %s', r.status_code, r.status)

            for key, val in r.headers.items():

                recvlog.info('%s: %s', key, val)

            if success is not None:

                # Success can either be an in or a collection

    def set_method(self, method):

    	self.method = method

		"""

		@return an HTTPResponse (also in self.response of this object)

		named args offer the ability to reset a request or a part of the request

        for k,v in r.getheaders():

            headers.update({k:v})

        self.headers = headers

        self.status_code = r.status

        self.status = r.reason

        self.request.close()

class KamakiHTTPConnection(HTTPConnection):

        """ return (scheme, netloc, url?with&params) """

        url = self.url

            param_str = ('?' if i == 0 else '&') + unicode(key) 

            if val is not None:

                param_str+= '='+unicode(val)

        self.url = url

        return (parsed.scheme, parsed.netloc)

        #get connection from pool

        conn = get_http_connection(netloc=netloc, scheme=scheme)

        try:

        except:

            conn.close()

            raise

        return KamakiHTTPResponse(conn)

        file_hashmap = HashMap(blocksize, blockhash)

        file_hashmap.load(local_file, hasattr(self, 'progress_bar_gen'))

        for i, x in enumerate(file_hashmap):

            local_hash = hexlify(x)

            if local_hash in remote_hashes:

                    gevent.Greenlet._report_error(self, exc_info)

                finally:

                    sys.stderr = _stderr

        if self.async_pool is None:

            self.async_pool = gevent.pool.Pool(size=self.POOL_SIZE)

        g = SilentGreenlet(self.object_get, obj, success=(200, 206), **restargs)

    def _greenlet2file(self, flying_greenlets, local_file, broken={}, **restargs):

        finished = []

        for start, g in flying_greenlets.items():

            if g.ready():

                if g.exception:

                    raise g.exception

                try:

                    block = g.value.content

                except AttributeError:

                    broken[start] = flying_greenlets.pop(start)

                    continue

                local_file.seek(start)

                local_file.write(block)

                #local_file.flush()

                self._cb_next()

        return finished

    def _dump_blocks_async(self, obj, remote_hashes, blocksize, total_size, local_file, **restargs):

        flying_greenlets = {}

        finished_greenlets = []

        broken = {}

        for block_hash, blockid in remote_hashes.items():

            start = blocksize*blockid

            end = total_size-1 if start+blocksize > total_size else start+blocksize-1

            flying_greenlets[start] = self._get_block_async(obj, **restargs)

        #check the greenlets

        while len(flying_greenlets) > 0:

            hash_list, 

            remote_hashes) = self._get_remote_blocks_info(obj, **restargs)

        assert total_size >= 0

        if download_cb:

            self.progress_bar_gen = download_cb(len(remote_hashes)+1)

        success = kwargs.pop('success', 200)

        return self.head(path, *args, success=success, **kwargs)

        data_range=None, if_range=False, if_etag_match=None, if_etag_not_match = None,

        if_modified_since = None, if_unmodified_since = None, *args, **kwargs):

        """ Full Pithos+ GET at object level

        path=path4url(self.account, self.container, object)

        success = kwargs.pop('success', 200)

        return self.get(path, *args, success=success, **kwargs)

    def object_put(self, object, format='json', hashmap=False, delimiter = None, if_etag_match=None,