cloud_terrastodon_azure 0.36.0

Helpers for interacting with Azure for the Cloud Terrastodon project
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
109

use crate::get_resource_group_choices;
use crate::get_role_assignment_choices;
use crate::get_security_group_choices;
use cloud_terrastodon_azure_types::AzureTenantId;
use cloud_terrastodon_azure_types::Scope;
use cloud_terrastodon_hcl_types::HclImportBlock;
use cloud_terrastodon_hcl_types::HclProviderBlock;
use cloud_terrastodon_hcl_types::HclProviderReference;
use cloud_terrastodon_hcl_types::ProviderKind;
use cloud_terrastodon_hcl_types::Sanitizable;
use cloud_terrastodon_hcl_types::edit::structure::Block;
use cloud_terrastodon_hcl_types::edit::structure::Body;
use cloud_terrastodon_user_input::Choice;
use cloud_terrastodon_user_input::PickerTui;
use std::collections::HashSet;
use std::convert::TryFrom;
use strum::VariantArray;
use tracing::info;

#[derive(strum::VariantArray, Debug, Clone, Copy)]
pub enum HclImportable {
    ResourceGroup,
    SecurityGroup,
    RoleAssignment,
}
impl std::fmt::Display for HclImportable {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{self:?}")
    }
}
impl HclImportable {
    pub async fn try_into_import_blocks(
        &self,
        tenant_id: AzureTenantId,
    ) -> eyre::Result<Vec<Choice<(HclImportBlock, Option<HclProviderBlock>)>>> {
        let rtn: Vec<Choice<(HclImportBlock, Option<HclProviderBlock>)>> = match self {
            HclImportable::ResourceGroup => {
                info!("Fetching resource groups");
                get_resource_group_choices(tenant_id)
                    .await?
                    .into_iter()
                    .map(|Choice { key, value: rg }| {
                        let provider_block = Some(HclProviderBlock::AzureRM {
                            alias: Some(rg.subscription_name.sanitize()),
                            subscription_id: Some(rg.id.subscription_id.short_form().to_owned()),
                        });
                        let import_block = {
                            let name = rg.subscription_name.to_string();
                            let mut import_block: HclImportBlock = rg.into();
                            import_block.provider = HclProviderReference::Alias {
                                kind: ProviderKind::AzureRM,
                                name,
                            };
                            import_block
                        };
                        Choice {
                            key,
                            value: (import_block, provider_block),
                        }
                    })
                    .collect()
            }
            HclImportable::SecurityGroup => get_security_group_choices(tenant_id)
                .await?
                .into_iter()
                .map(|choice| Choice {
                    key: choice.key,
                    value: (choice.value.into(), None),
                })
                .collect(),
            HclImportable::RoleAssignment => get_role_assignment_choices(tenant_id)
                .await?
                .into_iter()
                .map(|choice| Choice {
                    key: choice.key,
                    value: (choice.value.into(), None),
                })
                .collect(),
        };
        Ok(rtn)
    }
    pub fn pick() -> eyre::Result<HclImportable> {
        Ok(PickerTui::new()
            .set_header("Pick the kind of thing to import")
            .pick_one(HclImportable::VARIANTS.iter().copied().map(|x| Choice {
                key: x.to_string(),
                value: x,
            }))?)
    }
    pub async fn pick_into_body(self, tenant_id: AzureTenantId) -> eyre::Result<Body> {
        let import_blocks = self.try_into_import_blocks(tenant_id).await?;
        let import_blocks = PickerTui::new()
            .set_header("Pick the resources to import")
            .pick_many(import_blocks)?;
        let providers = import_blocks
            .iter()
            .filter_map(|(_, provider)| provider.clone())
            .collect::<HashSet<_>>();
        let body = Body::builder().blocks(providers).blocks(
            import_blocks
                .into_iter()
                .map(|(import_block, _)| Block::try_from(import_block))
                .collect::<Result<Vec<Block>, _>>()?,
        );

        let body = body.build();
        Ok(body)
    }
}