Synnefo » ./kamaki

        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)