use std::time::Duration;
use zenoh::qos::Priority;
use zenoh::query::ConsolidationMode;
use crate::compress::{MAX_UNPACKED, unpack};
use crate::error::{BlobError, Result};
use crate::hash::{Hash, HashAlgo};
use crate::keys::store_key;
use crate::prefix::QueryPrefix;
use crate::tree::ChunkRef;
use crate::wire::ENC_CHUNK;
use crate::wire::{HaveBits, WantList};
#[derive(Debug, Clone)]
pub(crate) struct StoreClientConfig {
pub(crate) query_timeout: Duration,
pub(crate) priority: Priority,
pub(crate) max_chunk_bytes: usize,
}
impl Default for StoreClientConfig {
fn default() -> Self {
StoreClientConfig {
query_timeout: Duration::from_secs(30),
priority: Priority::DataLow,
max_chunk_bytes: MAX_UNPACKED,
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ChunkProbe {
pub origin: QueryPrefix,
pub held: Vec<Hash>,
}
#[derive(Debug)]
pub struct StoreClient {
session: zenoh::Session,
prefix: QueryPrefix,
cfg: StoreClientConfig,
}
#[derive(Debug)]
pub struct StoreClientBuilder {
session: zenoh::Session,
prefix: QueryPrefix,
cfg: StoreClientConfig,
}
impl StoreClientBuilder {
#[must_use]
pub fn query_timeout(mut self, t: Duration) -> Self {
self.cfg.query_timeout = t;
self
}
#[must_use]
pub fn priority(mut self, priority: Priority) -> Self {
self.cfg.priority = priority;
self
}
#[must_use]
pub fn max_chunk_bytes(mut self, n: usize) -> Self {
self.cfg.max_chunk_bytes = n.min(MAX_UNPACKED);
self
}
pub fn build(self) -> StoreClient {
StoreClient {
session: self.session,
prefix: self.prefix,
cfg: self.cfg,
}
}
}
impl StoreClient {
pub fn builder(session: &zenoh::Session, store_prefix: QueryPrefix) -> StoreClientBuilder {
StoreClientBuilder {
session: session.clone(),
prefix: store_prefix,
cfg: StoreClientConfig::default(),
}
}
pub fn new(session: &zenoh::Session, store_prefix: QueryPrefix) -> Self {
Self::builder(session, store_prefix).build()
}
pub fn prefix(&self) -> &QueryPrefix {
&self.prefix
}
pub async fn fetch_chunk(&self, hash: &Hash) -> Result<Vec<u8>> {
let key = store_key(self.prefix.as_str(), HashAlgo::Blake3, hash);
let (bytes, _) = fetch_one_chunk(
&self.session,
&key,
hash,
None,
self.cfg.max_chunk_bytes,
self.cfg.query_timeout,
self.cfg.priority,
)
.await?;
Ok(bytes)
}
pub async fn fetch_many(&self, wanted: &[ChunkRef]) -> Result<Vec<(Hash, Vec<u8>)>> {
let mut out = Vec::new();
for group in wanted.chunks(crate::wire::MAX_WANT_LIST) {
let (replies, expected) = batch_query(
&self.session,
self.prefix.as_str(),
group,
self.cfg.query_timeout,
self.cfg.priority,
)
.await?;
let mut seen = std::collections::HashSet::new();
while let Ok(reply) = replies.recv_async().await {
let Ok(sample) = reply.result() else { continue };
if let Some((hash, bytes)) =
accept_batch_reply(self.prefix.as_str(), sample, &expected)
&& seen.insert(hash)
{
out.push((hash, bytes));
}
}
}
Ok(out)
}
pub async fn probe(&self, hashes: &[Hash]) -> Result<Vec<ChunkProbe>> {
let mut out = Vec::new();
for group in hashes.chunks(crate::wire::MAX_WANT_LIST) {
for (key, bits) in probe_chunks(
&self.session,
self.prefix.as_str(),
group,
self.cfg.query_timeout,
self.cfg.priority,
)
.await?
{
let Some(origin) = key
.strip_suffix(crate::keys::STORE_HAVE)
.and_then(|k| k.strip_suffix('/'))
.and_then(|k| k.strip_suffix(Hash::ALGO))
.and_then(|k| k.strip_suffix('/'))
else {
continue;
};
let Ok(origin) = QueryPrefix::new(origin) else {
continue;
};
let held = group
.iter()
.enumerate()
.filter(|(i, _)| bits.is_set(*i as u32))
.map(|(_, h)| *h)
.collect::<Vec<_>>();
match out
.iter_mut()
.find(|p: &&mut ChunkProbe| p.origin == origin)
{
Some(existing) => existing.held.extend(held),
None => out.push(ChunkProbe { origin, held }),
}
}
}
Ok(out)
}
pub async fn fetch_chunk_sized(&self, hash: &Hash, len: u32) -> Result<Vec<u8>> {
let key = store_key(self.prefix.as_str(), HashAlgo::Blake3, hash);
let (bytes, _) = fetch_one_chunk(
&self.session,
&key,
hash,
Some(len),
self.cfg.max_chunk_bytes,
self.cfg.query_timeout,
self.cfg.priority,
)
.await?;
Ok(bytes)
}
}
pub(crate) async fn batch_query(
session: &zenoh::Session,
store_prefix: &str,
wanted: &[ChunkRef],
timeout: Duration,
priority: Priority,
) -> Result<(
zenoh::handlers::FifoChannelHandler<zenoh::query::Reply>,
std::collections::HashMap<Hash, u32>,
)> {
let expected: std::collections::HashMap<Hash, u32> =
wanted.iter().map(|c| (c.hash, c.len)).collect();
let want = WantList::new(wanted.iter().map(|c| c.hash).collect());
let replies = session
.get(crate::keys::store_batch_key(store_prefix, HashAlgo::Blake3))
.payload(crate::wire::encode(&want)?)
.accept_replies(zenoh::query::ReplyKeyExpr::Any)
.consolidation(ConsolidationMode::None)
.priority(priority)
.timeout(timeout)
.await
.map_err(BlobError::zenoh)?;
Ok((replies, expected))
}
pub(crate) fn accept_batch_reply(
store_prefix: &str,
sample: &zenoh::sample::Sample,
expected: &std::collections::HashMap<Hash, u32>,
) -> Option<(Hash, Vec<u8>)> {
if !ENC_CHUNK.matches(sample.encoding()) {
return None;
}
let crate::keys::Tier2Tail::Two(algo, hex) =
crate::keys::parse_tier2_tail(store_prefix, sample.key_expr().as_str())?
else {
return None;
};
if algo != Hash::ALGO {
return None;
}
let hash: Hash = hex.parse().ok()?;
let len = *expected.get(&hash)?;
let payload = sample.payload().to_bytes();
if payload.len() > len as usize + 1 + 4 {
return None; }
let bytes = unpack(&payload).ok()?;
if bytes.len() as u32 != len || Hash::of(&bytes) != hash {
return None;
}
Some((hash, bytes))
}
pub(crate) async fn probe_chunks(
session: &zenoh::Session,
store_prefix: &str,
hashes: &[Hash],
timeout: Duration,
priority: Priority,
) -> Result<Vec<(String, HaveBits)>> {
if hashes.is_empty() {
return Ok(Vec::new());
}
let want = WantList::new(hashes.to_vec());
let replies = session
.get(crate::keys::store_have_key(store_prefix, HashAlgo::Blake3))
.payload(crate::wire::encode(&want)?)
.consolidation(ConsolidationMode::None)
.priority(priority)
.timeout(timeout)
.await
.map_err(BlobError::zenoh)?;
let mut out = Vec::new();
while let Ok(reply) = replies.recv_async().await {
let Ok(sample) = reply.result() else { continue };
if !crate::wire::ENC_HAVEBITS.matches(sample.encoding()) {
continue;
}
let Ok(bits) = crate::wire::decode::<HaveBits>(&sample.payload().to_bytes()) else {
continue;
};
if bits.validate(hashes.len()).is_err() {
continue;
}
out.push((sample.key_expr().as_str().to_string(), bits));
}
Ok(out)
}
#[allow(clippy::too_many_arguments)]
pub(crate) async fn fetch_one_chunk(
session: &zenoh::Session,
key: &str,
hash: &Hash,
expected_len: Option<u32>,
max_bytes: usize,
timeout: Duration,
priority: Priority,
) -> Result<(Vec<u8>, u32)> {
let max_frame = expected_len.map_or(max_bytes, |n| n as usize) + 1 + 4;
let mut rejected = 0u32;
let replies = session
.get(key)
.consolidation(ConsolidationMode::None)
.priority(priority)
.timeout(timeout)
.await
.map_err(BlobError::zenoh)?;
while let Ok(reply) = replies.recv_async().await {
let Ok(sample) = reply.result() else { continue };
if !ENC_CHUNK.matches(sample.encoding()) {
continue;
}
let payload = sample.payload().to_bytes();
if payload.len() > max_frame {
rejected += 1;
continue; }
let Ok(bytes) = unpack(&payload) else {
rejected += 1;
continue; };
if expected_len.is_some_and(|n| bytes.len() as u32 != n) || Hash::of(&bytes) != *hash {
rejected += 1;
continue; }
return Ok((bytes, rejected));
}
Err(BlobError::NotFound(hash.to_string()))
}