Skip to main content

snix_castore/proto/
grpc_blobstore_wrapper.rs

1use crate::{
2    B3Digest,
3    blobstore::{BlobMeta, BlobStore},
4    proto,
5};
6use tonic::{Request, Response, Status, async_trait};
7use tracing::{Span, instrument, warn};
8
9/// Wraps a [BlobStore] into a gRPC
10/// [proto::blob_store_service_server::BlobStoreService].
11pub struct GRPCBlobStoreWrapper<T> {
12    blob_store: T,
13}
14
15impl<T> GRPCBlobStoreWrapper<T> {
16    /// Constructs a new [GRPCBlobStoreWrapper] from a [BlobStore].
17    pub fn new(blob_store: T) -> Self {
18        Self { blob_store }
19    }
20}
21
22#[async_trait]
23impl<T> proto::blob_store_service_server::BlobStoreService for GRPCBlobStoreWrapper<T>
24where
25    T: BlobStore + 'static,
26{
27    #[instrument(skip_all, fields(blob.digest=tracing::field::Empty))]
28    async fn stat_blob(
29        &self,
30        request: Request<proto::StatBlobRequest>,
31    ) -> Result<Response<proto::StatBlobResponse>, Status> {
32        let digest: B3Digest = request
33            .into_inner()
34            .digest
35            .try_into()
36            .map_err(|_| Status::invalid_argument("invalid digest length"))?;
37
38        let span = Span::current();
39        span.record("blob.digest", digest.to_string());
40
41        match self.blob_store.has(&digest).await {
42            Ok(true) => Ok(Response::new(proto::StatBlobResponse {})),
43            Ok(false) => Err(Status::not_found(format!("blob {digest} not found"))),
44            Err(err) => {
45                warn!(%err, "failed to check for blob");
46                Err(Status::internal(err.to_string()))
47            }
48        }
49    }
50
51    #[instrument(skip_all, fields(blob.digest=tracing::field::Empty))]
52    async fn get_blob(
53        &self,
54        request: Request<proto::GetBlobRequest>,
55    ) -> Result<Response<proto::GetBlobResponse>, Status> {
56        let digest: B3Digest = request
57            .into_inner()
58            .digest
59            .try_into()
60            .map_err(|_| Status::invalid_argument("invalid digest length"))?;
61
62        let span = Span::current();
63        span.record("blob.digest", digest.to_string());
64
65        match self.blob_store.get(&digest).await {
66            Ok(Some(blob_meta)) => Ok(Response::new(proto::GetBlobResponse {
67                blob_meta: Some(blob_meta.into()),
68            })),
69            Ok(None) => Err(Status::not_found(format!("blob {digest} not found"))),
70            Err(e) => {
71                warn!(err = %e, "failed to get blob");
72                Err(Status::internal(e.to_string()))
73            }
74        }
75    }
76
77    #[instrument(skip_all, fields(blob.digest=tracing::field::Empty))]
78    async fn put_blob(
79        &self,
80        request: Request<proto::PutBlobRequest>,
81    ) -> Result<Response<proto::PutBlobResponse>, Status> {
82        let proto::PutBlobRequest { digest, blob_meta } = request.into_inner();
83
84        let digest: B3Digest = digest
85            .try_into()
86            .map_err(|_| Status::invalid_argument("invalid digest length"))?;
87
88        let span = Span::current();
89        span.record("blob.digest", digest.to_string());
90
91        let blob_meta =
92            blob_meta.ok_or_else(|| Status::invalid_argument("no blob_meta provided"))?;
93        let blob_meta =
94            BlobMeta::try_from(blob_meta).map_err(|e| Status::invalid_argument(e.to_string()))?;
95
96        self.blob_store
97            .put(&digest, blob_meta)
98            .await
99            .map_err(|err| {
100                warn!(%err, "failed to put blob");
101                Status::internal(err.to_string())
102            })?;
103
104        Ok(Response::new(proto::PutBlobResponse {}))
105    }
106}