jax-daemon 0.1.16

End-to-end encrypted storage buckets with peer-to-peer synchronization
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
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116

use axum::extract::{Json, State};
use axum::response::{IntoResponse, Response};
use reqwest::{Client, RequestBuilder, Url};
use serde::{Deserialize, Serialize};
use uuid::Uuid;

use common::bucket_log::BucketLogProvider;

use crate::http_server::api::client::ApiRequest;
use crate::ServiceState;

#[derive(Debug, Clone, Serialize, Deserialize, clap::Args)]
pub struct LatestPublishedRequest {
    /// The bucket ID to query
    #[arg(long)]
    pub bucket_id: Uuid,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct LatestPublishedResponse {
    pub bucket_id: Uuid,
    /// The link of the latest published version, if any
    #[serde(skip_serializing_if = "Option::is_none")]
    pub link: Option<String>,
    /// The height of the latest published version, if any
    #[serde(skip_serializing_if = "Option::is_none")]
    pub height: Option<u64>,
}

pub async fn handler(
    State(state): State<ServiceState>,
    Json(req): Json<LatestPublishedRequest>,
) -> Result<impl IntoResponse, LatestPublishedError> {
    tracing::info!(
        "LATEST_PUBLISHED: Querying latest published version for bucket {}",
        req.bucket_id
    );

    // Check if the bucket exists
    let exists = state
        .peer()
        .logs()
        .exists(req.bucket_id)
        .await
        .map_err(|e| LatestPublishedError::Internal(e.to_string()))?;

    if !exists {
        return Err(LatestPublishedError::BucketNotFound(req.bucket_id));
    }

    // Query latest published version
    let result = state
        .peer()
        .logs()
        .latest_published(req.bucket_id)
        .await
        .map_err(|e| LatestPublishedError::Internal(e.to_string()))?;

    let (link, height) = match result {
        Some((link, height)) => (Some(link.to_string()), Some(height)),
        None => (None, None),
    };

    tracing::info!(
        "LATEST_PUBLISHED: Bucket {} latest published: link={:?}, height={:?}",
        req.bucket_id,
        link,
        height
    );

    Ok((
        http::StatusCode::OK,
        Json(LatestPublishedResponse {
            bucket_id: req.bucket_id,
            link,
            height,
        }),
    )
        .into_response())
}

#[derive(Debug, thiserror::Error)]
pub enum LatestPublishedError {
    #[error("Bucket not found: {0}")]
    BucketNotFound(Uuid),
    #[error("Internal error: {0}")]
    Internal(String),
}

impl IntoResponse for LatestPublishedError {
    fn into_response(self) -> Response {
        tracing::error!("LATEST_PUBLISHED ERROR: {:?}", self);
        match self {
            LatestPublishedError::BucketNotFound(id) => (
                http::StatusCode::NOT_FOUND,
                format!("Bucket not found: {}", id),
            )
                .into_response(),
            LatestPublishedError::Internal(msg) => (
                http::StatusCode::INTERNAL_SERVER_ERROR,
                format!("Internal error: {}", msg),
            )
                .into_response(),
        }
    }
}

// Client implementation - builds request for this operation
impl ApiRequest for LatestPublishedRequest {
    type Response = LatestPublishedResponse;

    fn build_request(self, base_url: &Url, client: &Client) -> RequestBuilder {
        let full_url = base_url.join("/api/v0/bucket/latest-published").unwrap();
        client.post(full_url).json(&self)
    }
}