feat: with release manager

Signed-off-by: kjuulh <contact@kjuulh.io>

crates/flux-releaser/Cargo.toml

@@ -13,6 +13,9 @@ dotenv.workspace = true
 axum.workspace = true
 prost = "0.12.3"
 tonic = "0.11.0"
+uuid = { version = "1.7.0", features = ["v7", "v4"] }
+async-trait = "0.1.77"
+mockall_double = "0.3.1"
 
 [build-dependencies]
 tonic-build = "0.11.0"

crates/flux-releaser/src/cli.rs

@@ -32,10 +32,10 @@ impl Command {
             let app = SharedApp::new();
 
             tokio::select! {
-                res = axum_serve(host, app) => {
+                res = axum_serve(host, app.clone()) => {
                   res?;
                 },
-                res = tonic_serve(grpc_host) => {
+                res = tonic_serve(grpc_host, app.clone()) => {
                   res?;
                 },
             };

crates/flux-releaser/src/grpc.rs

@@ -2,32 +2,57 @@ use std::net::SocketAddr;
 
 use tonic::transport::Server;
 
+use crate::{
+    app::SharedApp,
+    services::release_manager::{
+        extensions::ReleaseManagerExt, models::CommitArtifact, ReleaseManager,
+    },
+};
+
 use self::gen::{greeter_server, HelloReply, HelloRequest};
 
 mod gen {
     tonic::include_proto!("flux_releaser");
 }
 
-#[derive(Debug, Default)]
-pub struct FluxReleaserGrpc {}
+pub struct FluxReleaserGrpc {
+    release_manager: ReleaseManager,
+}
+
+impl FluxReleaserGrpc {
+    pub fn new(app: SharedApp) -> Self {
+        Self {
+            release_manager: app.release_manager(),
+        }
+    }
+}
+
 #[tonic::async_trait]
 impl greeter_server::Greeter for FluxReleaserGrpc {
     async fn say_hello(
         &self,
         request: tonic::Request<HelloRequest>,
     ) -> std::result::Result<tonic::Response<HelloReply>, tonic::Status> {
+        self.release_manager
+            .commit_artifact(CommitArtifact {
+                app: "some-app".into(),
+                branch: "some-branch".into(),
+            })
+            .await
+            .unwrap();
+
         Ok(tonic::Response::new(HelloReply {
             message: "something".into(),
         }))
     }
 }
 
-pub async fn tonic_serve(host: SocketAddr) -> anyhow::Result<()> {
+pub async fn tonic_serve(host: SocketAddr, app: SharedApp) -> anyhow::Result<()> {
     tracing::info!("grpc listening on: {}", host);
     Server::builder()
-        .add_service(greeter_server::GreeterServer::new(
-            FluxReleaserGrpc::default(),
-        ))
+        .add_service(greeter_server::GreeterServer::new(FluxReleaserGrpc::new(
+            app,
+        )))
         .serve(host)
         .await?;
 

crates/flux-releaser/src/services.rs

@@ -1 +1,2 @@
+mod file_store;
 pub mod release_manager;

crates/flux-releaser/src/services/file_store.rs

@@ -0,0 +1,28 @@
+use std::{path::PathBuf, sync::Arc};
+
+use super::release_manager::models::ArtifactID;
+
+pub mod extensions;
+
+#[derive(Clone)]
+pub struct FileStore {}
+
+#[cfg(test)]
+use mockall::{automock, mock, predicate::*};
+
+#[cfg_attr(test, automock)]
+impl FileStore {
+    pub fn new() -> Self {
+        Self {}
+    }
+
+    pub async fn upload_files(
+        &self,
+        artifact_id: ArtifactID,
+        files: Vec<PathBuf>,
+    ) -> anyhow::Result<()> {
+        tracing::trace!("uploading files: {}", artifact_id.to_string());
+
+        Ok(())
+    }
+}

crates/flux-releaser/src/services/file_store/extensions.rs

@@ -0,0 +1,14 @@
+use crate::app::SharedApp;
+
+#[mockall_double::double]
+use super::FileStore;
+
+pub trait FileStoreExt {
+    fn file_store(&self) -> FileStore;
+}
+
+impl FileStoreExt for SharedApp {
+    fn file_store(&self) -> FileStore {
+        FileStore::new()
+    }
+}

crates/flux-releaser/src/services/release_manager.rs

@@ -1,25 +1,57 @@
-mod default;
-pub mod traits;
+#[mockall_double::double]
+use crate::services::file_store::FileStore;
 
-use std::sync::Arc;
+use self::models::{ArtifactID, CommitArtifact};
 
-#[derive(Clone)]
 pub struct ReleaseManager {
-    inner: Arc<dyn traits::ReleaseManager>,
+    file_store: FileStore,
 }
 
 impl ReleaseManager {
-    pub fn get_default() -> Self {
-        Self {
-            inner: Arc::new(default::ReleaseManager::new()),
-        }
+    pub fn new(file_store: FileStore) -> Self {
+        Self { file_store }
+    }
+
+    pub async fn commit_artifact(&self, request: CommitArtifact) -> anyhow::Result<ArtifactID> {
+        tracing::debug!("committing artifact: {:?}", request);
+        let artifact_id = ArtifactID::new();
+
+        self.file_store
+            .upload_files(artifact_id.clone(), Vec::new())
+            .await?;
+
+        // publish domain event that it has been published
+
+        Ok(artifact_id)
     }
 }
 
-impl std::ops::Deref for ReleaseManager {
-    type Target = Arc<dyn traits::ReleaseManager>;
+pub mod extensions;
+pub mod models;
 
-    fn deref(&self) -> &Self::Target {
-        &self.inner
+#[cfg(test)]
+mod test {
+    use crate::services::file_store::MockFileStore;
+
+    use super::*;
+
+    #[tokio::test]
+    async fn generated_artifact_id() -> anyhow::Result<()> {
+        let mut file_store = MockFileStore::new();
+        file_store
+            .expect_upload_files()
+            .times(1)
+            .returning(|_, _| Ok(()));
+
+        let releaser_manager = ReleaseManager::new(file_store);
+
+        releaser_manager
+            .commit_artifact(CommitArtifact {
+                app: "app".into(),
+                branch: "branch".into(),
+            })
+            .await?;
+
+        Ok(())
     }
 }

crates/flux-releaser/src/services/release_manager/default.rs

@@ -1,11 +0,0 @@
-use super::traits;
-
-pub struct ReleaseManager {}
-
-impl ReleaseManager {
-    pub fn new() -> Self {
-        Self {}
-    }
-}
-
-impl traits::ReleaseManager for ReleaseManager {}

crates/flux-releaser/src/services/release_manager/extensions.rs

@@ -0,0 +1,13 @@
+use crate::{app::SharedApp, services::file_store::extensions::FileStoreExt};
+
+use super::ReleaseManager;
+
+pub trait ReleaseManagerExt {
+    fn release_manager(&self) -> ReleaseManager;
+}
+
+impl ReleaseManagerExt for SharedApp {
+    fn release_manager(&self) -> ReleaseManager {
+        ReleaseManager::new(self.file_store())
+    }
+}

crates/flux-releaser/src/services/release_manager/models.rs

@@ -0,0 +1,22 @@
+#[derive(Clone, Debug)]
+pub struct CommitArtifact {
+    pub app: String,
+    pub branch: String,
+}
+
+#[derive(Debug, Clone)]
+pub struct ArtifactID(uuid::Uuid);
+
+impl ArtifactID {
+    pub fn new() -> Self {
+        Self(uuid::Uuid::now_v7())
+    }
+}
+
+impl std::ops::Deref for ArtifactID {
+    type Target = uuid::Uuid;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}

crates/flux-releaser/src/services/release_manager/traits.rs

@@ -1,4 +0,0 @@
-#[cfg(test)]
-use mockall::{automock, mock, predicate::*};
-#[cfg_attr(test, automock)]
-pub trait ReleaseManager {}