Merge pull request #124 from bloock/feature/hot-fix

Author: edutomesco

Cargo.lock

@@ -1 +1 @@
-2.9.2
+2.9.3

VERSION

@@ -1,6 +1,6 @@
 [package]
 name = "bloock_bridge"
-version = "2.9.2"
+version = "2.9.3"
 edition = "2021"
 
 [lib]

bloock-bridge/Cargo.toml

@@ -5,17 +5,22 @@ package bloock;
 option go_package = "github.com/bloock/bloock-sdk-go/v2/internal/bridge/proto";
 option java_package = "com.bloock.sdk.bridge.proto";
 
+import "bloock_keys_entities.proto";
+
 enum DataAvailabilityType {
     HOSTED = 0;
     IPFS = 1;
+    IPNS = 2;
 }
 
 message Publisher {
     DataAvailabilityType type = 1;
     PublisherArgs args = 2;
 }
 
-message PublisherArgs {}
+message PublisherArgs {
+    optional IpnsKey ipns_key = 1;
+}
 
 message Loader {
     DataAvailabilityType type = 1;
@@ -24,4 +29,9 @@ message Loader {
 
 message LoaderArgs {
     string id = 1;
+}
+
+message IpnsKey {
+    optional ManagedKey managed_key = 1;
+    optional ManagedCertificate managed_certificate = 2;
 }

bloock-bridge/proto/bloock_availability_entities.proto

@@ -1,13 +1,13 @@
 use crate::{
     error::BridgeError,
     items::{
-        AvailabilityServiceHandler, DataAvailabilityType, Loader, LoaderArgs, PublishRequest,
-        PublishResponse, Publisher, Record, RetrieveRequest, RetrieveResponse,
+        AvailabilityServiceHandler, DataAvailabilityType, IpnsKey, Loader, LoaderArgs, PublishRequest, PublishResponse, Publisher, PublisherArgs, Record, RetrieveRequest, RetrieveResponse
     },
     server::response_types::RequestConfigData,
 };
 use async_trait::async_trait;
 use bloock_core::record::entity::record::Record as RecordCore;
+use bloock_keys::keys::managed::ManagedKey as ManagedKeyCore;
 
 pub struct AvailabilityServer {}
 
@@ -35,6 +35,25 @@ impl AvailabilityServiceHandler for AvailabilityServer {
         let result = match DataAvailabilityType::from_i32(req_publisher.r#type) {
             Some(DataAvailabilityType::Hosted) => service.publish_hosted(record).await,
             Some(DataAvailabilityType::Ipfs) => service.publish_ipfs(record).await,
+            Some(DataAvailabilityType::Ipns) => {
+                let publisher_args: PublisherArgs = req_publisher
+                .args
+                .ok_or_else(|| "invalid publisher provided".to_string())?;
+
+                let ipns_key: IpnsKey = publisher_args
+                .ipns_key
+                .ok_or_else(|| "invalid IPNS key provided".to_string())?;
+
+                let key_id: String = if let Some(managed_key) = ipns_key.managed_key.clone() {
+                    let managed_key_core: ManagedKeyCore = managed_key.into();
+                    managed_key_core.id
+                } else if let Some(_) = ipns_key.managed_certificate.clone() {
+                    return Err("managed certificate not enabled".to_string());
+                } else {
+                    return Err("invalid managed key or certificate provided".to_string());
+                };
+                service.publish_ipns(record, key_id).await
+            },
             None => return Err("invalid publisher provided".to_string()),
         };
 
@@ -60,6 +79,7 @@ impl AvailabilityServiceHandler for AvailabilityServer {
         let result = match DataAvailabilityType::from_i32(req_loader.r#type) {
             Some(DataAvailabilityType::Hosted) => service.retrieve_hosted(loader_args.id).await,
             Some(DataAvailabilityType::Ipfs) => service.retrieve_ipfs(loader_args.id).await,
+            Some(DataAvailabilityType::Ipns) => service.retrieve_ipns(loader_args.id).await,
             None => return Err("invalid loader provided".to_string()),
         };
 

bloock-bridge/src/server/availability/server.rs

@@ -215,6 +215,7 @@ impl RecordServiceHandler for RecordServer {
         let result = match DataAvailabilityType::from_i32(req_loader.r#type) {
             Some(DataAvailabilityType::Hosted) => service.retrieve_hosted(loader_args.id).await,
             Some(DataAvailabilityType::Ipfs) => service.retrieve_ipfs(loader_args.id).await,
+            Some(DataAvailabilityType::Ipns) => service.retrieve_ipns(loader_args.id).await,
             None => return Err("invalid loader provided".to_string()),
         };
 

bloock-bridge/src/server/record/server.rs

@@ -1,6 +1,6 @@
 [package]
 name = "bloock-core"
-version = "2.9.2"
+version = "2.9.3"
 edition = "2021"
 
 [lib]

bloock-core/Cargo.toml

@@ -1,2 +1,3 @@
 pub mod publish_hosted_response;
 pub mod publish_ipfs_response;
+pub mod publish_ipns_response;

bloock-core/src/availability/entity/mod.rs

@@ -0,0 +1,6 @@
+use serde::Deserialize;
+
+#[derive(Clone, Deserialize)]
+pub struct PublishIpnsResponse {
+    pub id: String,
+}

bloock-core/src/availability/entity/publish_ipns_response.rs

@@ -1,6 +1,6 @@
 use super::{
     entity::{
-        publish_hosted_response::PublishHostedResponse, publish_ipfs_response::PublishIpfsResponse,
+        publish_hosted_response::PublishHostedResponse, publish_ipfs_response::PublishIpfsResponse, publish_ipns_response::PublishIpnsResponse,
     },
     AvailabilityError,
 };
@@ -79,6 +79,40 @@ impl<H: Client> AvailabilityService<H> {
             .await
             .map_err(|e| AvailabilityError::RetrieveError(e.to_string()).into())
     }
+
+    pub async fn publish_ipns(&self, record: Record, key_id: String) -> BloockResult<String> {
+        let url = format!(
+            "{}/hosting/v1/ipns/upload?key={}",
+            self.config_service.get_api_base_url(),
+            key_id,
+        );
+
+        let response: PublishIpnsResponse = self
+            .http
+            .post_file(
+                url,
+                vec![("payload".to_owned(), record.serialize()?.to_vec())],
+                vec![],
+                None,
+                None,
+            )
+            .await
+            .map_err(|e| AvailabilityError::PublishError(e.to_string()))?;
+        Ok(response.id)
+    }
+
+    pub async fn retrieve_ipns(&self, id: String) -> BloockResult<Vec<u8>> {
+        let url = format!(
+            "{}/hosting/v1/ipns/{}",
+            self.config_service.get_cdn_base_url(),
+            id
+        );
+
+        self.http
+            .get(url, None)
+            .await
+            .map_err(|e| AvailabilityError::RetrieveError(e.to_string()).into())
+    }
 }
 
 #[cfg(test)]
@@ -88,6 +122,7 @@ mod tests {
     use std::sync::Arc;
 
     use crate::availability::entity::publish_ipfs_response::PublishIpfsResponse;
+    use crate::availability::entity::publish_ipns_response::PublishIpnsResponse;
     use crate::availability::{self, entity::publish_hosted_response::PublishHostedResponse};
     use crate::record::document::Document;
     use crate::record::entity::record::Record;
@@ -217,4 +252,69 @@ mod tests {
             "Retrieved payload should match expected"
         )
     }
+
+    #[tokio::test]
+    async fn ipns_publish_file() {
+        let payload: Vec<u8> = vec![1, 2, 3, 4, 5];
+        let response = PublishIpnsResponse {
+            id: "bafzbeigkhrj52va6uud2eeavfnfsr7zgo6sf7wg6bq76iqf37c274q2dy4".to_owned(),
+        };
+        let key_id: String = "b012eaf2-e2ed-4196-8a68-172238852a5f".to_owned();
+
+        let mut http = MockClient::default();
+        let url = format!("https://api.bloock.com/hosting/v1/ipns/upload?key={}", key_id);
+        http.expect_post_file::<String, PublishIpnsResponse>()
+            .with(
+                eq(url.to_owned()),
+                eq(vec![("payload".to_owned(), payload.to_vec())]),
+                eq(vec![]),
+                eq(None),
+                eq(None),
+            )
+            .return_once(|_, _, _, _, _| Ok(response));
+
+        let service = availability::configure_test(Arc::new(http));
+
+        let record = Record::new(
+            Document::new(
+                &payload,
+                service.config_service.get_api_base_url(),
+                service.config_service.get_api_key(),
+            )
+            .unwrap(),
+        );
+
+        let result = service.publish_ipns(record.unwrap(), key_id).await.unwrap();
+
+        assert_eq!(
+            &result, "bafzbeigkhrj52va6uud2eeavfnfsr7zgo6sf7wg6bq76iqf37c274q2dy4",
+            "Should not return an empty result"
+        )
+    }
+
+    #[tokio::test]
+    async fn ipns_retrieve_file() {
+        let payload = [1, 2, 3, 4, 5];
+        let id = "bafzbeigkhrj52va6uud2eeavfnfsr7zgo6sf7wg6bq76iqf37c274q2dy4";
+
+        let mut http = MockClient::default();
+        http.expect_get::<String>()
+            .with(
+                eq(format!("https://cdn.bloock.com/hosting/v1/ipns/{id}")),
+                eq(None),
+            )
+            .return_once(move |_, _| Ok(payload.to_vec()));
+
+        let service = availability::configure_test(Arc::new(http));
+        let result = service
+            .retrieve_ipns("bafzbeigkhrj52va6uud2eeavfnfsr7zgo6sf7wg6bq76iqf37c274q2dy4".to_owned())
+            .await
+            .unwrap();
+
+        assert_eq!(
+            payload,
+            result.as_slice(),
+            "Retrieved payload should match expected"
+        )
+    }
 }