weave-nexus · view

#[async_trait]
pub trait NexusView: Send + Sync {
    /// Append a batch of entries to the persisted view
    async fn append_batch(&self, batch: &[ViewEntry]) -> Result<()>;
}

#[async_trait]
pub trait NexusViewAdapter: Send + Sync {
    async fn open(&self) -> Result<Arc<dyn NexusView>>;
}

pub struct MemoryView;

pub struct StrandView {

}

pub fn new(strand: Arc<tokio::sync::Mutex<Strand>>) -> Self;

pub struct StrandViewAdapter {

}

pub fn new(strand: Arc<tokio::sync::Mutex<Strand>>) -> Self;

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub struct NexusCursor(pub Vec<u8>);

pub fn from_offset(offset: usize) -> Self;

pub fn to_offset(&self) -> usize;

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Page {
pub items: Vec<ViewEntry>,
pub next: Option<NexusCursor>,
pub prev: Option<NexusCursor>,
pub total: usize
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ViewEntry {
/// Which agent produced this entry

pub source_agent: String,
/// Index in the source strand

pub source_index: u64,
/// Entry data

pub data: Vec<u8>,
/// Timestamp from source strand

pub timestamp: SystemTime,
/// Optional metadata

pub metadata: Option<ViewMetadata>
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ViewMetadata {
/// Hash of the entry

pub hash: [u8; 32],
/// Size in bytes

pub size: u64,
/// Custom application metadata

pub app_metadata: Option<Vec<u8>>
}

pub fn from_data(data: &[u8], app_metadata: Option<Vec<u8>>) -> Self;

pub struct ViewManager {

}

pub fn new(ordering: Box<dyn OrderingStrategy>) -> Self;

pub fn attach_view_strand(&self, strand: Arc<Strand>);

pub fn has_view_strand(&self) -> bool;

pub fn set_sink(&self, sink: Arc<dyn NexusView>);

pub fn current_view(&self) -> Vec<ViewEntry>;

pub fn len(&self) -> usize;

pub fn is_empty(&self) -> bool;

pub fn last_update(&self) -> SystemTime;

pub fn add_entries(
        &mut self,
        new_entries: Vec<UnorderedEntry>,
    ) -> Result<Option<PersistBatch>>;

pub fn regenerate_view(
        &mut self,
        all_entries: Vec<UnorderedEntry>,
    ) -> Result<Option<PersistBatch>>;

pub fn get_range(&self, start: usize, end: usize) -> Vec<ViewEntry>;

pub fn paginate(&self, cursor: Option<NexusCursor>, limit: usize) -> Page;

pub fn find_by_agent(&self, agent_did: &str) -> Vec<ViewEntry>;

pub fn metrics(&self) -> ViewMetrics;

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ViewMetrics {
pub applied_batches_total: u64,
pub applied_entries_total: u64,
pub applied_bytes_total: u64,
pub apply_latency_ms_hist: Vec<u64>
}

#[async_trait]
pub trait ViewStrategy: Send + Sync {
    /// Generate view from input strands
    async fn generate_view(&self, entries: Vec<UnorderedEntry>) -> Result<Vec<ViewEntry>>;

    /// Strategy name
    fn name(&self) -> &str;
}