def start_retrieve_slice_tests(state):
    """
    start a deferred request for retrieve of slices
    """
    global _pending_retrieve_slice_test_count

    for key in state["slice-data"].keys():
        log.msg("retrieving slice '%s' (%s, %s)" % (
                key, 
                state["slice-data"][key]["offset"],
                state["slice-data"][key]["size"], ), 
                logLevel=logging.DEBUG)

        consumer = BufferedConsumer()

        path = compute_retrieve_path(key)
        range_header_tuple = \
            compute_range_header_tuple(state["slice-data"][key]["offset"],
                                       state["slice-data"][key]["size"])
        headers = dict([range_header_tuple])
        expected_status = frozenset([httplib.PARTIAL_CONTENT, ])

        deferred = start_collection_request(state["identity"],
                                            "GET", 
                                            state["collection-name"],
                                            path,
                                            response_consumer=consumer,
                                            additional_headers=headers,
                                            valid_http_status=expected_status)
        deferred.addCallback(_retrieve_slice_data, state, key, consumer)
        deferred.addErrback(_retrieve_slice_error, state, key)

        _pending_retrieve_slice_test_count += 1
def start_retrieve_stream_tests(state):
    """
    start a deferred request for retrieve
    """
    global _pending_retrieve_stream_test_count

    for key in state["key-data"].keys():
        log.msg("retrieving key '%s'" % (key, ), logLevel=logging.DEBUG)

        consumer = TestStreamConsumer()

        path = compute_retrieve_path(key)
        deferred = start_collection_request(state["identity"],
                                            "GET", 
                                            state["collection-name"],
                                            path,
                                            response_consumer=consumer)
        deferred.addCallback(_retrieve_data, state, key, consumer)
        deferred.addErrback(_retrieve_error, state, key)

        _pending_retrieve_stream_test_count += 1