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

use std::path::PathBuf;

use anyhow::Context;

use crate::{
    app::infra::grpc::FluxReleaserGrpcClient,
    grpc::gen::{CommitArtifactRequest, TriggerReleaseRequest},
};

use super::{
    archive::Archive,
    file_reader::FileReader,
    flux_releaser_uploader::FluxReleaserUploader,
    release_manager::models::{ArtifactID, UploadArtifactID},
};

pub struct FluxLocalClusterManager {
    file_reader: FileReader,
    archive: Archive,
    flux_uploader: FluxReleaserUploader,
    flux_releaser_client: FluxReleaserGrpcClient,
}

impl std::fmt::Debug for FluxLocalClusterManager {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        Ok(())
    }
}

impl FluxLocalClusterManager {
    pub fn new(
        file_reader: FileReader,
        archive: Archive,
        flux_uploader: FluxReleaserUploader,
        flux_releaser_client: FluxReleaserGrpcClient,
    ) -> Self {
        Self {
            file_reader,
            archive,
            flux_uploader,
            flux_releaser_client,
        }
    }

    #[tracing::instrument(skip(include))]
    pub async fn package_clusters(
        &self,
        include: impl Into<PathBuf>,
    ) -> anyhow::Result<UploadArtifactID> {
        let include = include.into();

        tracing::debug!("reading files");
        let files = self.file_reader.read_files(include.clone()).await?;
        tracing::debug!("creating archive");
        let archive = self.archive.create_archive(&include, files).await?;
        tracing::debug!("uploading archive");
        let upload_id = self.flux_uploader.upload_archive(archive).await?;

        tracing::debug!("done packaging clusters");

        Ok(upload_id)
    }

    pub async fn commit_artifact(
        &self,
        app: impl Into<String>,
        branch: impl Into<String>,
        upload_id: UploadArtifactID,
    ) -> anyhow::Result<ArtifactID> {
        let artifact_id = self
            .flux_releaser_client
            .lock()
            .await
            .commit_artifact(tonic::Request::new(CommitArtifactRequest {
                app: app.into(),
                branch: branch.into(),
                upload_id: upload_id.to_string(),
            }))
            .await?;

        artifact_id.into_inner().artifact_id.try_into()
    }

    pub async fn trigger_release(
        &self,
        app: impl Into<String>,
        branch: impl Into<String>,
    ) -> anyhow::Result<()> {
        self.flux_releaser_client
            .lock()
            .await
            .trigger_release(tonic::Request::new(TriggerReleaseRequest {
                app: app.into(),
                branch: branch.into(),
            }))
            .await
            .context("failed to trigger release")?;

        // Send release proto to upstream

        // 1. find app by app + branch

        // 2. Unpack latest artifact by app + branch

        // 3. Unpack by cluster

        // 4. Upload

        Ok(())
    }
}

pub mod extensions {
    use crate::{
        app::SharedLocalApp,
        services::{
            archive::extensions::ArchiveExt, file_reader::extensions::FileReaderExt,
            flux_releaser_uploader::extensions::FluxReleaserUploaderExt,
        },
    };

    use super::FluxLocalClusterManager;

    pub trait FluxLocalClusterManagerExt {
        fn flux_local_cluster_manager(&self) -> FluxLocalClusterManager;
    }

    impl FluxLocalClusterManagerExt for SharedLocalApp {
        fn flux_local_cluster_manager(&self) -> FluxLocalClusterManager {
            FluxLocalClusterManager::new(
                self.file_reader(),
                self.archive(),
                self.flux_releaser_uploader(),
                self.grpc_client.clone(),
            )
        }
    }
}