cli: massive code refactor

Modularize the code to get rid of the massive types module, hopefully
making the code much easier to read.

Also removes dead code and crates that were not being used.

Author: nrdxp

nix/cli/packages/cli/Cargo.lock

@@ -20,8 +20,6 @@ anyhow = "^1.0.0"
 deploy-rs = { git = "https://github.com/input-output-hk/deploy-rs" }
 uuid = { version = "^1", features = ["serde"] }
 reqwest = { version = "^0.11.0", features = ["json", "gzip"] }
-thiserror = "^1.0.0"
-netrc-rs = "0.1.2"
 enum-utils = "^0"
 clap_complete = "^3"
 aws-config = "^0"

nix/cli/packages/cli/Cargo.toml

@@ -0,0 +1,124 @@
+pub mod node;
+pub mod provider;
+
+use super::nomad::{alloc::NomadAlloc, client::NomadClient};
+use anyhow::Result;
+use clap::ArgMatches;
+use node::BitteNode;
+use node::BitteNodes;
+pub use provider::BitteProvider;
+use reqwest::{
+    header::{HeaderMap, HeaderValue},
+    Client,
+};
+use serde::{Deserialize, Serialize};
+use std::sync::Arc;
+use std::time::Duration;
+use std::time::SystemTime;
+use tokio::task::JoinHandle;
+use uuid::Uuid;
+
+pub type ClusterHandle = JoinHandle<Result<BitteCluster>>;
+
+pub trait BitteFind
+where
+    Self: IntoIterator,
+{
+    fn find_needle(self, needle: &str) -> Result<Self::Item>;
+    fn find_needles(self, needles: Vec<&str>) -> Self;
+    fn find_clients(self, node_class: Option<String>) -> Self;
+    fn find_with_job(
+        self,
+        name: &str,
+        group: &str,
+        index: &str,
+        namespace: &str,
+    ) -> Result<(Self::Item, NomadAlloc)>;
+}
+
+/// A description of a Bitte cluster and its nodes
+#[derive(Debug, Serialize, Deserialize)]
+pub struct BitteCluster {
+    pub name: String,
+    pub nodes: BitteNodes,
+    pub domain: String,
+    pub provider: BitteProvider,
+    #[serde(skip)]
+    pub nomad_api_client: Option<Arc<Client>>,
+    pub ttl: SystemTime,
+}
+
+impl BitteCluster {
+    pub async fn new(args: &ArgMatches, token: Option<Uuid>) -> Result<Self> {
+        let name = args.get_one::<String>("name").unwrap().to_owned();
+        let domain = args.get_one::<String>("domain").unwrap().to_owned();
+        let provider: BitteProvider = args
+            .get_one::<BitteProvider>("provider")
+            .unwrap()
+            .to_owned();
+
+        let nomad_api_client = match token {
+            Some(token) => {
+                let mut token = HeaderValue::from_str(&token.to_string())?;
+                token.set_sensitive(true);
+                let mut headers = HeaderMap::new();
+                headers.insert("X-Nomad-Token", token);
+                Some(Arc::new(
+                    Client::builder()
+                        .default_headers(headers)
+                        .gzip(true)
+                        .build()?,
+                ))
+            }
+            None => None,
+        };
+
+        let nodes = if let Some(client) = &nomad_api_client {
+            let allocs = tokio::spawn(NomadAlloc::find_allocs(
+                Arc::clone(client),
+                domain.to_owned(),
+            ));
+
+            let client_nodes = tokio::spawn(NomadClient::find_nomad_nodes(
+                Arc::clone(client),
+                domain.to_owned(),
+            ));
+
+            tokio::spawn(BitteNode::find_nodes(
+                provider,
+                name.to_owned(),
+                Some(allocs),
+                Some(client_nodes),
+                args.clone(),
+            ))
+            .await??
+        } else {
+            tokio::spawn(BitteNode::find_nodes(
+                provider,
+                name.to_owned(),
+                None,
+                None,
+                args.clone(),
+            ))
+            .await??
+        };
+
+        let cluster = Self {
+            name,
+            domain,
+            provider,
+            nomad_api_client,
+            nodes,
+            ttl: SystemTime::now()
+                .checked_add(Duration::from_secs(300))
+                .unwrap(),
+        };
+
+        Ok(cluster)
+    }
+
+    #[inline(always)]
+    pub fn init(args: ArgMatches, token: Option<Uuid>) -> ClusterHandle {
+        tokio::spawn(async move { BitteCluster::new(&args, token).await })
+    }
+}

nix/cli/packages/cli/src/bitte/mod.rs

@@ -0,0 +1,119 @@
+use super::BitteFind;
+use crate::nomad::alloc::NomadAlloc;
+use anyhow::{Context, Result};
+use std::net::IpAddr;
+
+impl BitteFind for super::BitteNodes {
+    fn find_with_job(
+        self,
+        name: &str,
+        group: &str,
+        index: &str,
+        namespace: &str,
+    ) -> Result<(Self::Item, NomadAlloc)> {
+        let node = self
+            .into_iter()
+            .find(|node| {
+                let client = &node.nomad_client;
+                if client.is_none() {
+                    return false;
+                };
+
+                let allocs = &client.as_ref().unwrap().allocs;
+                if allocs.is_none() || allocs.as_ref().unwrap().is_empty() {
+                    return false;
+                };
+
+                allocs.as_ref().unwrap().iter().any(|alloc| {
+                    alloc.namespace == namespace
+                        && alloc.job_id == name
+                        && alloc.task_group == group
+                        && alloc.index.get() == index.parse().ok()
+                        && alloc.status == "running"
+                })
+            })
+            .with_context(|| {
+                format!(
+                    "{}, {}, {} does not match any running nomad allocations in namespace {}",
+                    name, group, index, namespace
+                )
+            })?;
+        let alloc = node
+            .nomad_client
+            .as_ref()
+            .unwrap()
+            .allocs
+            .as_ref()
+            .unwrap()
+            .iter()
+            .find(|alloc| {
+                alloc.namespace == namespace
+                    && alloc.job_id == name
+                    && alloc.task_group == group
+                    && alloc.index.get() == index.parse().ok()
+                    && alloc.status == "running"
+            })
+            .unwrap()
+            .clone();
+        Ok((node, alloc))
+    }
+
+    fn find_needle(self, needle: &str) -> Result<Self::Item> {
+        self.into_iter()
+            .find(|node| {
+                let ip = needle.parse::<IpAddr>().ok();
+
+                node.id == needle
+                    || node.name == needle
+                    || node
+                        .nomad_client
+                        .as_ref()
+                        .unwrap_or(&Default::default())
+                        .id
+                        .hyphenated()
+                        .to_string()
+                        == needle
+                    || Some(node.priv_ip) == ip
+                    || Some(node.pub_ip) == ip
+            })
+            .with_context(|| format!("{} does not match any nodes", needle))
+    }
+
+    fn find_clients(self, node_class: Option<String>) -> Self {
+        match node_class {
+            Some(class) => self
+                .into_iter()
+                .filter(|node| match &node.nomad_client {
+                    Some(client) => client.node_class.clone().unwrap_or_default() == class,
+                    None => false,
+                })
+                .collect(),
+            None => self.into_iter().filter(|node| node.asg.is_some()).collect(),
+        }
+    }
+
+    fn find_needles(self, needles: Vec<&str>) -> Self {
+        self.into_iter()
+            .filter(|node| {
+                let ips: Vec<Option<IpAddr>> = needles
+                    .iter()
+                    .map(|needle| needle.parse::<IpAddr>().ok())
+                    .collect();
+
+                needles.contains(&&*node.id)
+                    || needles.contains(&&*node.name)
+                    || needles.contains(
+                        &&*node
+                            .nomad_client
+                            .as_ref()
+                            .unwrap_or(&Default::default())
+                            .id
+                            .hyphenated()
+                            .to_string(),
+                    )
+                    || ips.contains(&Some(node.priv_ip))
+                    || ips.contains(&Some(node.pub_ip))
+            })
+            .collect()
+    }
+}

nix/cli/packages/cli/src/bitte/node/find.rs

@@ -0,0 +1,60 @@
+use crate::bitte::BitteNode;
+use aws_sdk_ec2::model::{Instance, Tag};
+use std::net::{IpAddr, Ipv4Addr};
+use std::str::FromStr;
+
+impl From<Instance> for BitteNode {
+    fn from(instance: Instance) -> Self {
+        let tags = instance.tags.unwrap_or_default();
+        let empty_tag = Tag::builder().build();
+
+        let nixos = tags
+            .iter()
+            .find(|tag| tag.key == Some("UID".into()))
+            .unwrap_or(&empty_tag)
+            .value
+            .as_ref();
+
+        let name = tags
+            .iter()
+            .find(|tag| tag.key == Some("Name".into()))
+            .unwrap_or(&empty_tag)
+            .value
+            .as_ref();
+
+        let asg = tags
+            .iter()
+            .find(|tag| tag.key == Some("aws:autoscaling:groupName".into()))
+            .unwrap_or(&empty_tag)
+            .value
+            .as_ref();
+
+        let no_ip = IpAddr::V4(Ipv4Addr::new(0, 0, 0, 0));
+
+        let zone = if let Some(p) = instance.placement {
+            p.availability_zone
+        } else {
+            None
+        };
+
+        Self {
+            id: instance.instance_id.unwrap_or_default(),
+            name: match name {
+                Some(name) => name.to_owned(),
+                None => "".into(),
+            },
+            priv_ip: IpAddr::from_str(&instance.private_ip_address.unwrap_or_default())
+                .unwrap_or(no_ip),
+            pub_ip: IpAddr::from_str(&instance.public_ip_address.unwrap_or_default())
+                .unwrap_or(no_ip),
+            nomad_client: None,
+            nixos: match nixos {
+                Some(nixos) => nixos.to_owned(),
+                None => "".into(),
+            },
+            node_type: instance.instance_type.map(|s| s.as_str().to_owned()),
+            zone,
+            asg: asg.map(|asg| asg.to_owned()),
+        }
+    }
+}