cloud_terrastodon_entrypoint 0.35.1

Main entrypoint for the Cloud Terrastodon CLI
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
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

use super::app_service::AzureAppServiceArgs;
use super::application_gateway::AzureApplicationGatewayArgs;
use super::audit::AzureAuditArgs;
use super::find::AzureFindArgs;
use super::network_interface::AzureNetworkInterfaceArgs;
use super::pim::AzurePimArgs;
use super::policy::AzurePolicyArgs;
use super::private_endpoint::AzurePrivateEndpointArgs;
use super::public_ip::AzurePublicIpArgs;
use super::resource::AzureResourceArgs;
use super::resource_group::AzureResourceGroupArgs;
use super::role::AzureRoleArgs;
use super::subscription::AzureSubscriptionArgs;
use super::tag::AzureTagArgs;
use super::tenant::AzureTenantArgs;
use super::vm::AzureVmArgs;
use crate::cli::azure::entra::AzureEntraArgs;
use crate::cli::azure_devops::AzureDevOpsArgs;
use clap::Subcommand;
use eyre::Result;

/// Azure-specific commands.
#[derive(Subcommand, Debug, Clone)]
pub enum AzureCommand {
    /// Manage Azure App Services.
    #[command(alias = "app")]
    AppService(AzureAppServiceArgs),
    /// Audit Azure resources for configuration issues.
    Audit(AzureAuditArgs),
    /// Manage Azure application gateways.
    #[command(alias = "agw")]
    ApplicationGateway(AzureApplicationGatewayArgs),
    /// Find resources where resource JSON contains the given text.
    Find(AzureFindArgs),
    /// Manage Azure network interfaces.
    #[command(alias = "nic")]
    NetworkInterface(AzureNetworkInterfaceArgs),
    /// Manage Azure resource groups.
    #[command(aliases = ["rg", "group"])]
    ResourceGroup(AzureResourceGroupArgs),
    /// Manage Azure policy resources.
    Policy(AzurePolicyArgs),
    /// Manage Azure private endpoints.
    #[command(aliases = ["pe"])]
    PrivateEndpoint(AzurePrivateEndpointArgs),
    /// Manage Azure public IP addresses.
    PublicIp(AzurePublicIpArgs),
    /// Manage Azure resource tags.
    Tag(AzureTagArgs),
    /// Manage Azure resources.
    #[command(alias = "res")]
    Resource(AzureResourceArgs),
    /// Manage Azure role-based access control.
    Role(AzureRoleArgs),
    /// Manage Azure Privileged Identity Management operations.
    Pim(AzurePimArgs),
    /// Entra (Azure AD) commands.
    #[command(alias = "ad")]
    Entra(AzureEntraArgs),
    /// VM-related commands (images, publishers, sizes, etc.)
    Vm(AzureVmArgs),
    /// Manage subscriptions within the tenant.
    #[command(alias = "sub")]
    Subscription(AzureSubscriptionArgs),
    /// Manage tracked tenants for later login flows.
    Tenant(AzureTenantArgs),
    /// Azure DevOps-specific commands.
    #[command(alias = "devops")]
    DevOps(AzureDevOpsArgs),
}

impl AzureCommand {
    pub async fn invoke(self) -> Result<()> {
        match self {
            AzureCommand::AppService(args) => {
                args.invoke().await?;
            }
            AzureCommand::Audit(args) => {
                args.invoke().await?;
            }
            AzureCommand::ApplicationGateway(args) => {
                args.invoke().await?;
            }
            AzureCommand::Find(args) => {
                args.invoke().await?;
            }
            AzureCommand::NetworkInterface(args) => {
                args.invoke().await?;
            }
            AzureCommand::ResourceGroup(args) => {
                args.invoke().await?;
            }
            AzureCommand::Policy(args) => {
                args.invoke().await?;
            }
            AzureCommand::PrivateEndpoint(args) => {
                args.invoke().await?;
            }
            AzureCommand::PublicIp(args) => {
                args.invoke().await?;
            }
            AzureCommand::Tag(args) => {
                args.invoke().await?;
            }
            AzureCommand::Resource(args) => {
                args.invoke().await?;
            }
            AzureCommand::Role(args) => {
                args.invoke().await?;
            }
            AzureCommand::Pim(args) => {
                args.invoke().await?;
            }
            AzureCommand::Entra(args) => {
                args.invoke().await?;
            }
            AzureCommand::Vm(args) => {
                args.invoke().await?;
            }
            AzureCommand::Subscription(args) => {
                args.invoke().await?;
            }
            AzureCommand::Tenant(args) => {
                args.invoke().await?;
            }
            AzureCommand::DevOps(args) => {
                args.invoke().await?;
            }
        }

        Ok(())
    }
}