cloud-node-discovery 0.2.0

Cloud node discovery library
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

#![cfg(feature = "upcloud")]
use crate::Provider;
use crate::{DiscoveryError, Node};
use upcloud_sdk::client::Client;
use upcloud_sdk::resources::server::ServerOperations;
use upcloud_sdk::types::common::LabelFilter;

use upcloud_sdk::error::Error as UpcloudError;

use std::collections::HashMap;

use async_trait::async_trait;

pub struct UpcloudProvider {
    client: Client,
    zone: String,
    label_key: String,
    label_value: String,
}

impl UpcloudProvider {
    pub async fn new(config: &HashMap<String, String>) -> Result<Self, DiscoveryError> {
        // Extract required configuration
        let zone = config
            .get("zone")
            .ok_or_else(|| DiscoveryError::ConfigError("zone is required".to_string()))?
            .clone();
        let label_key = config
            .get("label_key")
            .ok_or_else(|| DiscoveryError::ConfigError("label_key is required".to_string()))?
            .clone();
        let label_value = config
            .get("label_value")
            .ok_or_else(|| DiscoveryError::ConfigError("label_value is required".to_string()))?
            .clone();

        // Initialize AWS SDK client with region
        let client = Client::new()?;

        Ok(UpcloudProvider {
            client,
            zone,
            label_key,
            label_value,
        })
    }
}

#[async_trait]
impl Provider for UpcloudProvider {
    async fn discover(&self) -> Result<Vec<Node>, DiscoveryError> {
        let label_filter = LabelFilter::new().with(&self.label_key, &self.label_value);
        let servers_by_labels = self.client.list_servers_by_labels(&label_filter).await?;

        // Transform instances into nodes
        let mut nodes = Vec::new();

        for server in servers_by_labels.server {
            let server_details = self.client.get_server(&server.uuid).await?;
            // Skip instances without a private IP
            let mut private_ip: &str = "";
            let mut utility_ip: &str = "";
            let mut public_ip: &str = "";
            for interface_iter in server_details.networking.iter() {
                for interface in interface_iter.interfaces.interface.iter() {
                    if interface.interface_type == "private" {
                        private_ip = interface.ip_addresses.ip_address[0].address.as_ref().unwrap().as_str();
                    }
                    if interface.interface_type == "utility" {
                        utility_ip = interface.ip_addresses.ip_address[0].address.as_ref().unwrap().as_str();
                    }
                    if interface.interface_type == "public" {
                        public_ip = interface.ip_addresses.ip_address[0].address.as_ref().unwrap().as_str();
                    }
                }
            }

            // Collect instance tags into metadata
            let mut metadata = HashMap::new();
            for x in server.labels.iter() {
                for label in x.label.iter() {
                    metadata.insert(label.key.to_string(), label.value.to_string());
                }
            }

            // Add instance ID and region to metadata
            metadata.insert("uuid".to_string(), server.uuid.to_string());
            metadata.insert("zone".to_string(), server.zone.clone());
            metadata.insert("utility_ip".to_string(), utility_ip.to_string());
            metadata.insert("public_ip".to_string(), public_ip.to_string());
            metadata.insert("zone".to_string(), self.zone.clone());

            nodes.push(Node {
                address: private_ip.to_string(),
                meta: metadata,
            });
        }

        Ok(nodes)
    }
}

impl From<UpcloudError> for DiscoveryError {
    fn from(error: UpcloudError) -> Self {
        DiscoveryError::ProviderError(error.to_string())
    }
}