Response lifetimes

[haydnv]

I have a situation where I need to return borrowed data in a stream. Ideally Hyper would be able to give me a lifetime like 'hyper_response so that I could use a Stream + 'hyper_response to borrow values within the stream. As far as I can tell this is impossible with hyper 0.14, which requires that the response be 'static (owned). Am I missing something? Is there any plan to implement a specific response lifetime?

[seanmonstar]

What sort of data do you need to borrow? Do you mean a slice of bytes? Could you store those bytes in a hyper::body::Bytes, and then just make clones of for the body? It's a reference counted buffer, so it's cheap for you to do that. Otherwise, I'd need more info to be able to better suggest a solution.

[haydnv]

I have a struct called Table which is a database table that reads from a BTree. The BTree doesn't fit in memory, so each node in the tree must be read from disk. If I had a 'hyper_response lifetime, I could borrow the BTree itself when reading each node, and borrow the contents of the node rather than cloning them as I'm doing now. This means that e.g. when merging results from two BTrees, I have to clone the left BTree for every single row in the right BTree, which feels inefficient even using reference counting.

Another good example is slicing a BTree:

let mut selected: Selection<'a> = FuturesOrdered::new();
for i in l..r {
    let child_id = node.children[i].clone();
    let range_clone = range.clone();

    let this = self.clone();
    let selection = Box::pin(async move {
        let node = this.inner.file.read_block(txn_id, child_id).await?;
        this._slice(txn_id, node, range_clone)
    });
    selected.push(Box::pin(selection));

    if !node.keys[i].deleted {
        let key_at_i = TCResult::Ok(node.keys[i].value.to_vec());
        let key_at_i: TCTryStream<Key> =
            Box::pin(stream::once(future::ready(key_at_i)));

        selected.push(Box::pin(future::ready(Ok(key_at_i))));
    }
}

Any value that needs to live across more than one node-read has to be cloned, but if the response stream was limited to a non-static 'hyper_response lifetime, it could be borrowed.