Merge pull request #875 from input-output-hk/jpraynaud/868-artifact-restorer-trait

Implement Artifact Restorer

Author: jpraynaud

mithril-aggregator/src/artifact_builder/artifact_builder_service.rs

@@ -2,13 +2,11 @@ use std::sync::Arc;
 
 use mithril_common::{
     entities::{Certificate, SignedEntityType},
-    signable_builder::DummyBeacon,
+    signable_builder::{Artifact, DummyBeacon},
     StdResult,
 };
 
-use crate::artifact_builder::{Artifact, DummyArtifactBuilder};
-
-use super::ArtifactBuilder;
+use crate::artifact_builder::{ArtifactBuilder, DummyArtifactBuilder};
 
 /// ArtifactBuilder Service
 // TODO: temporary implementation

mithril-aggregator/src/artifact_builder/dummy_artifact.rs

@@ -1,10 +1,14 @@
 use std::marker::PhantomData;
 
 use async_trait::async_trait;
-use mithril_common::{entities::Certificate, signable_builder::DummyBeacon, StdResult};
+use mithril_common::{
+    entities::Certificate,
+    signable_builder::{Artifact, DummyBeacon},
+    StdResult,
+};
 use serde::{Deserialize, Serialize};
 
-use crate::artifact_builder::{Artifact, ArtifactBuilder};
+use crate::artifact_builder::ArtifactBuilder;
 
 /// Dummy artifact
 #[derive(Serialize, Deserialize, PartialEq, Debug)]

mithril-aggregator/src/artifact_builder/interface.rs

@@ -1,10 +1,9 @@
 use async_trait::async_trait;
-use mithril_common::{entities::Certificate, signable_builder::Beacon, StdResult};
-use serde::{Deserialize, Serialize};
-use std::fmt::Debug;
-
-/// Artifact is a trait for types that represent signed artifacts
-pub trait Artifact<'a>: Serialize + Deserialize<'a> + PartialEq + Debug {}
+use mithril_common::{
+    entities::Certificate,
+    signable_builder::{Artifact, Beacon},
+    StdResult,
+};
 
 /// ArtifactBuilder is trait for building an artifact
 #[async_trait]

mithril-client/src/artifact_restorer/dummy_artifact.rs

@@ -0,0 +1,72 @@
+use std::marker::PhantomData;
+
+use async_trait::async_trait;
+use mithril_common::{
+    entities::Certificate,
+    signable_builder::{DummyBeacon, DummySignable},
+    StdResult,
+};
+use serde::{Deserialize, Serialize};
+
+use crate::artifact_builder::{Artifact, ArtifactRestorer};
+
+/// Dummy artifact
+#[derive(Serialize, Deserialize, PartialEq, Debug)]
+pub struct DummyArtifact<'a> {
+    message: String,
+    beacon: DummyBeacon,
+    phantom: PhantomData<&'a DummyBeacon>,
+}
+
+impl<'a> DummyArtifact<'a> {
+    /// Dummy artifact factory
+    pub fn new(message: String, beacon: DummyBeacon) -> Self {
+        Self {
+            message,
+            beacon,
+            phantom: PhantomData,
+        }
+    }
+}
+
+impl<'a> Artifact<'a> for DummyArtifact<'a> {}
+
+/// A [DummyArtifact] restorer
+pub struct DummyArtifactRestorer {}
+
+impl DummyArtifactRestorer {
+    /// Dummy artifact builder restorer
+    pub fn new() -> Self {
+        Self {}
+    }
+}
+
+impl Default for DummyArtifactRestorer {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+#[async_trait]
+impl<'a> ArtifactRestorer<'a, DummyBeacon, DummyArtifact<'a>> for DummyArtifactRestorer {
+    async fn compute_artifact(
+        &'a self,
+        beacon: DummyBeacon,
+        certificate: &Certificate,
+    ) -> StdResult<DummyArtifact> {
+        Ok(DummyArtifact::new(
+            format!("certificate id is {}", certificate.hash),
+            beacon,
+        ))
+    }
+
+    /// Compute a signable from an artifact
+    async fn compute_signable(&self, artifact: DummyArtifact) -> StdResult<DummySignable> {
+        Ok(DummySignable::new(artifact.message, artifact.beacon))
+    }
+
+    /// Restore an artifact
+    async fn restore_artifact(&'a self, artifact: DummyArtifact) -> StdResult<()> {
+        Ok(())
+    }
+}

mithril-client/src/artifact_restorer/interface.rs

@@ -0,0 +1,18 @@
+use async_trait::async_trait;
+use mithril_common::{entities::Certificate, signable_builder::Beacon, StdResult};
+use serde::{Deserialize, Serialize};
+use std::fmt::Debug;
+
+/// ArtifactRestorer is trait for restoring an artifact
+#[async_trait]
+trait ArtifactRestorer<'a, V, W>
+where
+    V: Signable,
+    W: Artifact<'a>,
+{
+    /// Compute a signable from an artifact
+    async fn compute_signable(&self, artifact: W) -> StdResult<V>;
+
+    /// Restore an artifact
+    async fn restore_artifact(&'a self, artifact: W) -> StdResult<()>;
+}

mithril-client/src/artifact_restorer/mod.rs

@@ -0,0 +1,9 @@
+//! The module used for building artifact
+
+mod artifact_builder_service;
+mod dummy_artifact;
+mod interface;
+
+pub use artifact_builder_service::*;
+pub use dummy_artifact::*;
+pub use interface::*;

mithril-common/src/signable_builder/interface.rs

@@ -1,4 +1,6 @@
 use async_trait::async_trait;
+use serde::{Deserialize, Serialize};
+use std::fmt::Debug;
 
 use crate::{entities::ProtocolMessage, StdResult};
 
@@ -11,6 +13,9 @@ pub trait Signable: Send + Sync {
     fn compute_protocol_message(&self) -> StdResult<ProtocolMessage>;
 }
 
+/// Artifact is a trait for types that represent signed artifacts
+pub trait Artifact<'a>: Serialize + Deserialize<'a> + PartialEq + Debug {}
+
 /// SignableBuilder is trait for building a signable for a beacon
 #[async_trait]
 pub trait SignableBuilder<U, V>