use std::sync::Arc;
use std::time::Duration;
use zenoh::qos::{CongestionControl, Priority};
use zenoh::query::ConsolidationMode;
use crate::compress::{ChunkCompression, pack};
use crate::error::{BlobError, Result};
use crate::hash::{Hash, HashAlgo};
use crate::keys::{store_key, tree_key};
use crate::prefix::ServePrefix;
use crate::store::ContentStore;
use crate::tree::TreeIndex;
use crate::wire::{ENC_CHUNK, ENC_INDEX, encode};
async fn publish_chunk(
session: &zenoh::Session,
store_prefix: &ServePrefix,
hash: &Hash,
bytes: &[u8],
compression: ChunkCompression,
) -> Result<()> {
session
.put(
store_key(store_prefix.as_str(), HashAlgo::Blake3, hash),
pack(bytes, compression)?,
)
.encoding(&ENC_CHUNK)
.congestion_control(CongestionControl::Block)
.priority(Priority::DataLow)
.await
.map_err(BlobError::zenoh)
}
async fn publish_snapshot_chunks(
session: &zenoh::Session,
store_prefix: &ServePrefix,
index: &TreeIndex,
store: &Arc<dyn ContentStore>,
compression: ChunkCompression,
) -> Result<u32> {
publish_hashes(
session,
store_prefix,
&index.needed_chunks(),
store,
compression,
)
.await
}
async fn publish_store(
session: &zenoh::Session,
store_prefix: &ServePrefix,
store: &Arc<dyn ContentStore>,
compression: ChunkCompression,
) -> Result<u32> {
let enumerate = store.clone();
let hashes = tokio::task::spawn_blocking(move || enumerate.hashes())
.await
.map_err(BlobError::from)??;
publish_hashes(session, store_prefix, &hashes, store, compression).await
}
const PUBLISH_READ_BATCH: usize = 32;
async fn publish_hashes(
session: &zenoh::Session,
store_prefix: &ServePrefix,
hashes: &[Hash],
store: &Arc<dyn ContentStore>,
compression: ChunkCompression,
) -> Result<u32> {
let mut published = 0u32;
for group in hashes.chunks(PUBLISH_READ_BATCH) {
let store = store.clone();
let wanted = group.to_vec();
let bytes = tokio::task::spawn_blocking(move || store.get_many(&wanted))
.await
.map_err(BlobError::from)??;
for (hash, maybe) in group.iter().zip(bytes) {
let bytes = maybe.ok_or_else(|| BlobError::NotFound(hash.to_string()))?;
publish_chunk(session, store_prefix, hash, &bytes, compression).await?;
published += 1;
}
}
Ok(published)
}
async fn publish_index(
session: &zenoh::Session,
tree_prefix: &ServePrefix,
index: &TreeIndex,
) -> Result<()> {
let payload = encode(index)?;
session
.put(tree_key(tree_prefix.as_str(), &index.id), payload)
.encoding(&ENC_INDEX)
.congestion_control(CongestionControl::Block)
.priority(Priority::DataLow)
.await
.map_err(BlobError::zenoh)
}
fn sample_indices(n: usize, coverage: SettleCoverage) -> Vec<usize> {
debug_assert!(n > 0);
match coverage {
SettleCoverage::All => (0..n).collect(),
SettleCoverage::Sample(k) => {
let k = k.max(1);
let step = (n / k).max(1);
let mut picked: Vec<usize> = (0..n).step_by(step).take(k).collect();
if picked.last() != Some(&(n - 1)) {
if picked.len() >= k {
picked.pop();
}
picked.push(n - 1);
}
picked
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[non_exhaustive]
pub enum SettleCoverage {
Sample(usize),
All,
}
impl Default for SettleCoverage {
fn default() -> Self {
SettleCoverage::Sample(8)
}
}
#[allow(clippy::too_many_arguments)]
async fn publish_snapshot(
session: &zenoh::Session,
store_prefix: &ServePrefix,
tree_prefix: &ServePrefix,
index: &TreeIndex,
store: &Arc<dyn ContentStore>,
compression: ChunkCompression,
coverage: SettleCoverage,
settle: Duration,
) -> Result<()> {
publish_snapshot_chunks(session, store_prefix, index, store, compression).await?;
publish_index(session, tree_prefix, index).await?;
let needed = index.needed_chunks();
let mut probes: Vec<String> = vec![tree_key(tree_prefix.as_str(), &index.id)];
let n = needed.len();
if n > 0 {
probes.extend(
sample_indices(n, coverage)
.into_iter()
.map(|i| store_key(store_prefix.as_str(), HashAlgo::Blake3, &needed[i])),
);
}
let deadline = tokio::time::Instant::now() + settle;
for key in probes {
loop {
if probe_key(session, &key).await? {
break;
}
if tokio::time::Instant::now() >= deadline {
return Err(BlobError::NotSettled(format!(
"storage did not settle within {settle:?}: {key} still unanswered"
)));
}
tokio::time::sleep(Duration::from_millis(100)).await;
}
}
Ok(())
}
async fn probe_key(session: &zenoh::Session, key: &str) -> Result<bool> {
let replies = session
.get(key)
.consolidation(ConsolidationMode::None)
.priority(Priority::DataLow)
.timeout(Duration::from_secs(2))
.await
.map_err(BlobError::zenoh)?;
while let Ok(reply) = replies.recv_async().await {
if reply.result().is_ok() {
return Ok(true);
}
}
Ok(false)
}
#[derive(Debug, Clone)]
pub struct Publisher {
session: zenoh::Session,
store_prefix: ServePrefix,
compression: ChunkCompression,
}
impl Publisher {
#[must_use]
pub fn new(session: &zenoh::Session, store_prefix: ServePrefix) -> Self {
Publisher {
session: session.clone(),
store_prefix,
compression: ChunkCompression::default(),
}
}
#[must_use]
pub fn compression(mut self, compression: ChunkCompression) -> Self {
self.compression = compression;
self
}
#[must_use]
pub fn snapshots(self, tree_prefix: ServePrefix) -> SnapshotPublisher {
SnapshotPublisher {
chunks: self,
tree_prefix,
coverage: SettleCoverage::default(),
settle: Duration::from_secs(10),
}
}
#[must_use]
pub fn store_prefix(&self) -> &ServePrefix {
&self.store_prefix
}
pub async fn chunk(&self, hash: &Hash, bytes: &[u8]) -> Result<()> {
publish_chunk(
&self.session,
&self.store_prefix,
hash,
bytes,
self.compression,
)
.await
}
pub async fn chunks(&self, hashes: &[Hash], store: &Arc<dyn ContentStore>) -> Result<u32> {
publish_hashes(
&self.session,
&self.store_prefix,
hashes,
store,
self.compression,
)
.await
}
pub async fn store(&self, store: &Arc<dyn ContentStore>) -> Result<u32> {
publish_store(&self.session, &self.store_prefix, store, self.compression).await
}
}
#[derive(Debug, Clone)]
pub struct SnapshotPublisher {
chunks: Publisher,
tree_prefix: ServePrefix,
coverage: SettleCoverage,
settle: Duration,
}
impl std::ops::Deref for SnapshotPublisher {
type Target = Publisher;
fn deref(&self) -> &Publisher {
&self.chunks
}
}
impl SnapshotPublisher {
#[must_use]
pub fn coverage(mut self, coverage: SettleCoverage) -> Self {
self.coverage = coverage;
self
}
#[must_use]
pub fn settle(mut self, settle: Duration) -> Self {
self.settle = settle;
self
}
#[must_use]
pub fn tree_prefix(&self) -> &ServePrefix {
&self.tree_prefix
}
pub async fn index(&self, index: &TreeIndex) -> Result<()> {
publish_index(&self.chunks.session, &self.tree_prefix, index).await
}
pub async fn chunks_for(
&self,
index: &TreeIndex,
store: &Arc<dyn ContentStore>,
) -> Result<u32> {
publish_snapshot_chunks(
&self.chunks.session,
&self.chunks.store_prefix,
index,
store,
self.chunks.compression,
)
.await
}
pub async fn publish(&self, index: &TreeIndex, store: &Arc<dyn ContentStore>) -> Result<()> {
publish_snapshot(
&self.chunks.session,
&self.chunks.store_prefix,
&self.tree_prefix,
index,
store,
self.chunks.compression,
self.coverage,
self.settle,
)
.await
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn sampling_always_covers_the_ends_and_respects_its_bound() {
for n in 1..=200usize {
let all = sample_indices(n, SettleCoverage::All);
assert_eq!(all, (0..n).collect::<Vec<_>>(), "All at n={n}");
for k in [1usize, 2, 3, 8, 64, 1000] {
let picked = sample_indices(n, SettleCoverage::Sample(k));
let label = format!("n={n} k={k}");
assert!(!picked.is_empty(), "{label}: sampled nothing");
assert!(picked.len() <= k, "{label}: {} entries", picked.len());
assert!(picked.len() <= n, "{label}: more picks than chunks");
assert!(
picked.windows(2).all(|w| w[0] < w[1]),
"{label}: not strictly ascending: {picked:?}"
);
assert!(picked.iter().all(|i| *i < n), "{label}: index out of range");
assert_eq!(
*picked.last().unwrap(),
n - 1,
"{label}: the last chunk — the one a truncated publish \
loses — must always be probed"
);
if k > 1 || n == 1 {
assert_eq!(picked[0], 0, "{label}: the first chunk must be probed");
}
}
}
}
#[test]
fn a_zero_sample_still_probes() {
let picked = sample_indices(10, SettleCoverage::Sample(0));
assert_eq!(picked, vec![9]);
}
#[test]
fn the_default_coverage_samples() {
assert_eq!(SettleCoverage::default(), SettleCoverage::Sample(8));
assert_eq!(sample_indices(1000, SettleCoverage::default()).len(), 8);
assert_eq!(sample_indices(1000, SettleCoverage::All).len(), 1000);
}
}