blueprint-remote-providers 0.2.0-alpha.2

Remote service providers for Tangle Blueprints
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108

//! Kubernetes cluster cleanup handlers

use super::super::types::{CleanupHandler, DeploymentRecord};
#[cfg(feature = "aws-eks")]
use crate::core::error::Error;
use crate::core::error::Result;
use blueprint_core::{info, warn};

/// EKS cleanup
pub(crate) struct EksCleanup;

#[async_trait::async_trait]
impl CleanupHandler for EksCleanup {
    async fn cleanup(&self, deployment: &DeploymentRecord) -> Result<()> {
        #[cfg(feature = "aws-eks")]
        {
            let config = aws_config::load_defaults(aws_config::BehaviorVersion::latest()).await;
            let eks = aws_sdk_eks::Client::new(&config);

            if let Some(cluster_name) = deployment.resource_ids.get("cluster_name") {
                info!("Deleting EKS cluster: {}", cluster_name);

                // Delete node groups first
                let nodegroups = eks
                    .list_nodegroups()
                    .cluster_name(cluster_name)
                    .send()
                    .await?;

                if let Some(ngs) = nodegroups.nodegroups {
                    for ng in ngs {
                        let _ = eks
                            .delete_nodegroup()
                            .cluster_name(cluster_name)
                            .nodegroup_name(ng)
                            .send()
                            .await;
                    }
                }

                // Wait for nodegroups to be deleted
                tokio::time::sleep(tokio::time::Duration::from_secs(60)).await;

                // Delete cluster
                eks.delete_cluster()
                    .name(cluster_name)
                    .send()
                    .await
                    .map_err(|e| {
                        Error::ConfigurationError(format!("Failed to delete EKS: {}", e))
                    })?;
            }
        }

        #[cfg(not(feature = "aws-eks"))]
        let _ = deployment;

        Ok(())
    }
}

/// GKE cleanup
pub(crate) struct GkeCleanup;

#[async_trait::async_trait]
impl CleanupHandler for GkeCleanup {
    async fn cleanup(&self, deployment: &DeploymentRecord) -> Result<()> {
        #[cfg(feature = "gcp")]
        {
            use crate::providers::gcp::GcpProvisioner;

            if let (Some(project), Some(region)) = (
                deployment.metadata.get("project_id"),
                deployment.region.as_ref(),
            ) {
                let provisioner = GcpProvisioner::new(project.clone()).await?;

                if let Some(cluster_name) = deployment.resource_ids.get("cluster_name") {
                    info!("Deleting GKE cluster: {}", cluster_name);
                    // GKE cluster deletion requires gcloud SDK or complex API calls
                    warn!("GKE cluster cleanup not implemented - use gcloud CLI");
                }

                let _ = (provisioner, region);
            }
        }

        #[cfg(not(feature = "gcp"))]
        let _ = deployment;

        Ok(())
    }
}

/// AKS cleanup
pub(crate) struct AksCleanup;

#[async_trait::async_trait]
impl CleanupHandler for AksCleanup {
    async fn cleanup(&self, deployment: &DeploymentRecord) -> Result<()> {
        if let Some(cluster_name) = deployment.resource_ids.get("cluster_name") {
            info!("Deleting AKS cluster: {}", cluster_name);
            // AKS cluster deletion requires Azure CLI or complex API calls
            warn!("AKS cluster cleanup not implemented - use az CLI");
        }
        Ok(())
    }
}