feat: Introduce a streaming way to encode BodyChunkIpld. Fixes #498

[jsantell]

• Introduce streaming BodyChunkIpld::encode and BodyChunkIpld::decode methods.
• Streaming mechanisms store data in memory until a threshold is hit, which then stores to disk.
• Mark non-streaming functions BodyChunkIpld::load_all_bytes and BodyChunkIpld::store_bytes as deprecated.
• Remove BodyChunkDecoder (now implemented as BodyChunkIpld::decode.

Also bytes has been moved to a workspace dep

[cdata]

At a high level this looks like the right approach. I think we should revise it to leverage a impl Store that is provided by [caller who wants to do the encoding] that is considered a persistence scratch space; that way the solution can address the problem of finite resources for any environment where we have some implementation for storage persistence.

[jsantell]

Updates:

• NativeStorage's scratch space cleans up on drop
• WebStorage's scratch space is partitioned under SCRATCH_STORE and wiped on storage instantiation. (If we could easily async-drop, other solutions are available)
• Storage now must implement Scratch -- we could roll these together (e.g. Storage::get_scratch_store), keep them independent (at the cost of Storage + Scratch everywhere), or keep this current middle ground.

[jsantell]

The tests were timing out the wasm bindgen test runner (20s per crate) due to large size; decreased the size of unit tests (with customizable memory limit) and started work on a benchmark for future improvements in the encoding time

[cdata]

Excited for this

[cdata]

Shouldn't this just be usize?

[cdata]

Again, why not usize?

[cdata]

I think I would like to see this re-imagined as a generic container-like thing. Let's call it StorageBuffer for the sake of me writing this comment, but it could be called something else.

StorageBuffer for the most part is implemented the same way, with a high-level distinction: it is not a Store/BlockStore itself. It wraps any S: Storage that it is given, and gives you a buffer you can push on to and stream in either direction.

My rationale is: this sort of tool should be chosen at the point where it is needed, by the code that needs it. BodyChunkIpld should always encode using a mechanism like this. It should not be a matter for the calling code to decide. And, while it makes use of storage, I don't know if we would ever want to think of it as storage itself (like, we would never want all of Noosphere storage to be some kind of SphereDb<ReversableStorage<_>>).

[cdata]

Does this overlap at all with the benchmarking work done in #623 ?

[jsantell]

Yes, similar constructs here; haven't updated this PR within that context, but some scaffolding can be shared here

[cdata]

Same comment re: implied bound; this is probably redundant.

[cdata]

Same comment re: implied bound; this is probably redundant.

[cdata]

Nit: Temporary preferred over Temp. Alternatively, I also like Ephemeral.

[cdata]

I would like us to think of ways that we might be able to drop the scratch space as it is no longer needed. For example: what if scratch storage could be dropped cooperatively by the user?

[cdata]

I wonder if we could better enforce this "storage disappears when dropped" aspect by saying something like:

pub trait DroppableStore {
  async fn drop_store(&mut self);
}

pub struct TemporaryStore where T: Store + DroppableStore {
  inner: OnceCell<T>
};

impl Store for TemporaryStore { /* ... */ }

impl Drop for TemporaryStore {
  fn drop(&mut self) {
    if let Some(mut store) = self.0.take() {
      noosphere_common::spawn(store.drop_store());
    }
  }
}

And later we can implement async drop for IndexedDbStore. Then, we also do a clean up check for droppable stores on every initialization of all storage layers, to cover the possibility that the application exited before async work could be scheduled.

[jsantell]

edit: excellent!