marina 0.2.7

A dataset manager for robotics to organize, share, and discover datasets and metadata across storage backends.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92

use std::any::Any;
use std::path::Path;

use anyhow::{Result, anyhow};
use async_trait::async_trait;
use serde::{Deserialize, Serialize};

use crate::model::bag_ref::BagRef;

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RemoteDescriptor {
    pub registry_name: String,
    pub bag: BagRef,
    pub original_bytes: u64,
    pub packed_bytes: u64,
}

/// Metadata written alongside the bundle when pushing.
#[derive(Debug, Clone)]
pub struct PushMeta {
    pub original_bytes: u64,
    pub packed_bytes: u64,
    /// Short SHA-256 of the packed bundle (first 12 hex chars).
    pub bundle_hash: String,
    /// Pointcloud encoding: "lossless", "lossy", or "disabled".
    pub pointcloud: String,
    /// MCAP chunk compression: "none", "zstd", or "lz4".
    pub mcap_compression: String,
    /// Unix timestamp (seconds) when this bundle was pushed.
    pub pushed_at: u64,
}

/// Per-bag information readable from a remote registry.
#[derive(Debug, Clone)]
pub struct BagInfo {
    pub bundle_hash: Option<String>,
    pub original_bytes: u64,
    pub packed_bytes: u64,
    pub pointcloud: Option<String>,
    pub mcap_compression: Option<String>,
    pub pushed_at: Option<u64>,
}

#[async_trait]
pub trait RegistryDriver: Send + Sync {
    fn as_any(&self) -> &dyn Any;

    async fn push(
        &self,
        registry_name: &str,
        bag: &BagRef,
        packed_file: &Path,
        meta: &PushMeta,
    ) -> Result<()>;

    async fn pull(&self, bag: &BagRef, out_packed_file: &Path) -> Result<RemoteDescriptor>;

    async fn list(&self, filter: &str) -> Result<Vec<BagRef>>;

    async fn remove(&self, bag: &BagRef) -> Result<()>;

    /// Fetch lightweight metadata for a specific bag. Returns `None` if unsupported.
    async fn bag_info(&self, _bag: &BagRef) -> Result<Option<BagInfo>> {
        Ok(None)
    }

    /// List all matching bags together with their metadata in one operation.
    /// Drivers that can batch this more efficiently should override the default.
    async fn list_with_info(&self, filter: &str) -> Result<Vec<(BagRef, Option<BagInfo>)>> {
        let bags = self.list(filter).await?;
        let mut result = Vec::new();
        for bag in bags {
            let info = self.bag_info(&bag).await.ok().flatten();
            result.push((bag, info));
        }
        Ok(result)
    }

    async fn write_http_index(&self) -> Result<()> {
        Err(anyhow!(
            "http index generation is not supported for this registry type"
        ))
    }

    async fn check_connection(&self) -> Result<()> {
        Ok(())
    }

    async fn check_write_access(&self) -> Result<()> {
        self.check_connection().await
    }
}