Merge pull request #99 from kurrent-io/brock/add-shared-clusters

add support for creating and deleting shared clusters

Author: bshelton

.github/workflows/ci.yml

@@ -8,7 +8,7 @@ jobs:
     name: Build
     strategy:
       matrix:
-        os: [ubuntu-20.04, windows-2019, macos-11]
+        os: [ubuntu-22.04, windows-2019, macos-13]
 
     runs-on: ${{ matrix.os }}
 

.github/workflows/release.yml

@@ -10,7 +10,7 @@ jobs:
     name: Release
     strategy:
       matrix:
-        os: [ubuntu-20.04, windows-2019, macos-11]
+        os: [ubuntu-22.04, windows-2019, macos-13]
 
     runs-on: ${{ matrix.os }}
 

README.md

@@ -70,6 +70,7 @@ esc profiles set --profile my_profile --name fmt --value api
 ```
 
 ## JSON commands output rendering
+
 You can render any read command output in JSON by using the `--json` flag.
 
 ```
@@ -80,9 +81,9 @@ esc resources organizations list --json
 
 You can generate shell completion script by using the `generate-{shell}-completion` command. Currently supported:
 
-* Bash
-* Zsh
-* Powershell
+- Bash
+- Zsh
+- Powershell
 
 Additional shells can be supported, please open a feature request.
 
@@ -139,13 +140,17 @@ esc mesdb clusters create --help
 esc mesdb clusters stop --org-id <org-id> --project-id <project-id> --id <cluster-id>
 ```
 
-
 ### Start a cluster
 
 ```
 esc mesdb clusters start --org-id <org-id> --project-id <project-id> --id <cluster-id>
 ```
 
+### Create a shared cluster
+
+```
+esc mesdb shared-clusters create --deployment-tier s0 --name <name> --projection-level <projection-level> --provider <provider> --region <region> --server-version <server-version> --topology <topology> --acl-id <acl-id>
+```
 
 ### Create a refresh token.
 
@@ -167,7 +172,6 @@ esc access tokens display
 escp resources organizations update-mfa-status --enabled=true
 ```
 
-
 ### List members of an organization.
 
 ```

cli/src/main.rs

@@ -14,6 +14,7 @@ mod v1;
 
 use cidr::Cidr;
 use esc_api::resources::MfaStatus;
+
 use esc_api::{GroupId, MemberId, OrgId};
 use output::OutputFormat;
 use serde::Serialize;
@@ -1013,6 +1014,7 @@ struct Mesdb {
 enum MesdbCommand {
     Clusters(Clusters),
     Backups(Backups),
+    SharedClusters(SharedClusters),
 }
 
 #[derive(Debug, StructOpt)]
@@ -1074,7 +1076,7 @@ struct CreateCluster {
 
     #[structopt(
         long,
-        help = "Type of disk. For example, if you are using AWS as a provider, it could be GP2"
+        help = "Type of disk. For example, if you are using AWS as a provider, it could be GP2"
     )]
     disk_type: String,
 
@@ -1102,6 +1104,12 @@ struct CreateCluster {
 
     #[structopt(long, help = "The protected flag prevents from accidental deletion")]
     protected: Option<bool>,
+
+    #[structopt(long, help = "The provider of the cluster")]
+    provider: Option<String>,
+
+    #[structopt(long, help = "The region of the cluster")]
+    region: Option<String>,
 }
 
 #[derive(Debug, StructOpt)]
@@ -1248,6 +1256,97 @@ struct UpgradeCluster {
     target_tag: String,
 }
 
+#[derive(Debug, StructOpt)]
+#[structopt(about = "Gathers shared cluster management commands")]
+struct SharedClusters {
+    #[structopt(subcommand)]
+    shared_clusters_command: SharedClustersCommand,
+}
+
+#[derive(Debug, StructOpt)]
+enum SharedClustersCommand {
+    Create(CreateSharedCluster),
+    List(ListSharedClusters),
+    Delete(DeleteSharedCluster),
+    Get(GetSharedCluster),
+}
+
+#[derive(Debug, StructOpt)]
+struct CreateSharedCluster {
+    #[structopt(long, parse(try_from_str = parse_org_id), default_value = "", help = "The organization id the cluster relates to")]
+    org_id: OrgId,
+
+    #[structopt(long, parse(try_from_str = parse_project_id), default_value = "", help = "The project id the cluster relates to")]
+    project_id: esc_api::resources::ProjectId,
+
+    #[structopt(long, parse(try_from_str = parse_acl_id), help = "The acl id the cluster relates to")]
+    acl_id: esc_api::infra::AclId,
+
+    #[structopt(long, help = "The name of the cluster")]
+    name: String,
+
+    #[structopt(long, help = "The provider of the cluster")]
+    provider: String,
+
+    #[structopt(long, help = "The region of the cluster")]
+    region: String,
+
+    #[structopt(long, help = "The deployment tier of the cluster")]
+    deployment_tier: String,
+
+    #[structopt(long, help = "Whether mutual TLS is enabled for the cluster")]
+    mutual_tls_enabled: bool,
+
+    #[structopt(
+        long,
+        parse(try_from_str = parse_projection_level),
+        help = "The projection level of your database. Can be off, system or user "
+    )]
+    projection_level: esc_api::mesdb::ProjectionLevel,
+
+    #[structopt(long, help = "The server version of the cluster")]
+    server_version: String,
+
+    #[structopt(long, parse(try_from_str = parse_topology), help = "Either single-node or three-node-multi-zone")]
+    topology: esc_api::mesdb::Topology,
+}
+
+#[derive(Debug, StructOpt)]
+#[structopt(about = "List all shared clusters of an organization, given a project id")]
+struct ListSharedClusters {
+    #[structopt(long, parse(try_from_str = parse_org_id), default_value = "", help = "The organization id the cluster relates to")]
+    org_id: OrgId,
+
+    #[structopt(long, parse(try_from_str = parse_project_id), default_value = "", help = "The project id the cluster relates to")]
+    project_id: esc_api::resources::ProjectId,
+}
+
+#[derive(Debug, StructOpt)]
+#[structopt(about = "Delete a shared cluster")]
+struct DeleteSharedCluster {
+    #[structopt(long, parse(try_from_str = parse_org_id), default_value = "", help = "The organization id the cluster relates to")]
+    org_id: OrgId,
+
+    #[structopt(long, parse(try_from_str = parse_project_id), default_value = "", help = "The project id the cluster relates to")]
+    project_id: esc_api::resources::ProjectId,
+
+    #[structopt(long, short, parse(try_from_str = parse_cluster_id), help = "Id of the cluster you want to delete")]
+    id: esc_api::ClusterId,
+}
+
+#[derive(Debug, StructOpt)]
+#[structopt(about = "Get a shared cluster")]
+struct GetSharedCluster {
+    #[structopt(long, parse(try_from_str = parse_org_id), default_value = "", help = "The organization id the cluster relates to")]
+    org_id: OrgId,
+
+    #[structopt(long, parse(try_from_str = parse_project_id), default_value = "", help = "The project id the cluster relates to")]
+    project_id: esc_api::resources::ProjectId,
+
+    #[structopt(long, short, parse(try_from_str = parse_cluster_id), help = "Id of the cluster you want to get")]
+    id: esc_api::ClusterId,
+}
+
 #[derive(Debug, StructOpt)]
 #[structopt(about = "Gathers backup management commands")]
 struct Backups {
@@ -2717,6 +2816,72 @@ async fn call_api<'a, 'b>(
 
         Command::Mesdb(mesdb) => {
             match mesdb.mesdb_command {
+                MesdbCommand::SharedClusters(shared_clusters) => {
+                    match shared_clusters.shared_clusters_command {
+                        SharedClustersCommand::Create(params) => {
+                            let client = client_builder.create().await?;
+                            let resp = esc_api::mesdb::create_shared_cluster(
+                                &client,
+                                params.org_id,
+                                params.project_id,
+                                esc_api::mesdb::CreateSharedClusterDeploymentRequest {
+                                    cluster: esc_api::mesdb::CreateSharedClusterRequest {
+                                        name: params.name,
+                                        provider: params.provider,
+                                        region: params.region,
+                                        deployment_tier: params.deployment_tier,
+                                        mutual_tls_enabled: params.mutual_tls_enabled,
+                                        projection_level: params.projection_level,
+                                        server_version: params.server_version,
+                                        topology: params.topology,
+                                    },
+                                    acl: esc_api::mesdb::Acl::ResourceIdentifier(
+                                        esc_api::mesdb::ResourceIdentifier {
+                                            id: params.acl_id.0,
+                                        },
+                                    ),
+                                },
+                            )
+                            .await?;
+                            printer.print(resp)?;
+                        }
+
+                        SharedClustersCommand::List(params) => {
+                            let client = client_builder.create().await?;
+                            let resp = esc_api::mesdb::list_shared_clusters(
+                                &client,
+                                params.org_id,
+                                params.project_id,
+                            )
+                            .await?;
+                            printer.print(resp)?;
+                        }
+
+                        SharedClustersCommand::Delete(params) => {
+                            let client = client_builder.create().await?;
+                            esc_api::mesdb::delete_shared_cluster(
+                                &client,
+                                params.org_id,
+                                params.project_id,
+                                params.id,
+                            )
+                            .await?;
+                        }
+
+                        SharedClustersCommand::Get(params) => {
+                            let client = client_builder.create().await?;
+                            let resp = esc_api::mesdb::get_shared_cluster(
+                                &client,
+                                params.org_id,
+                                params.project_id,
+                                params.id,
+                            )
+                            .await?;
+                            printer.print(resp)?;
+                        }
+                    }
+                }
+
                 MesdbCommand::Clusters(clusters) => match clusters.clusters_command {
                     ClustersCommand::Create(params) => {
                         let client = client_builder.create().await?;
@@ -2741,6 +2906,8 @@ async fn call_api<'a, 'b>(
                                 topology: params.topology,
                                 protected: params.protected,
                                 public_access: params.public_access,
+                                provider: params.provider,
+                                region: params.region,
                             },
                         )
                         .await?;

cli/src/v1/mesdb.rs

@@ -170,3 +170,74 @@ impl ToV1 for esc_api::mesdb::ListBackupsResponse {
         List(l)
     }
 }
+
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SharedCluster {
+    pub id: esc_api::mesdb::ClusterId,
+    pub org_id: OrgId,
+    pub project_id: esc_api::resources::ProjectId,
+    pub name: String,
+    pub provider: Provider,
+    pub region: String,
+    pub topology: esc_api::mesdb::Topology,
+    pub deployment_tier: String,
+    pub mutual_tls_enabled: bool,
+    pub per_node_cores: String,
+    pub per_node_memory: usize,
+    pub per_node_volume_size: usize,
+    pub status: String,
+    pub created: String,
+    pub acl_id: String,
+    pub projection_level: esc_api::mesdb::ProjectionLevel,
+    pub server_version: String,
+    pub server_version_tag: String,
+}
+
+impl ToV1 for esc_api::mesdb::SharedCluster {
+    type V1Type = SharedCluster;
+    fn to_v1(self) -> Self::V1Type {
+        SharedCluster {
+            created: self.created.to_rfc3339(),
+            id: self.id,
+            name: self.name,
+            org_id: self.organization_id.to_v1(),
+            project_id: self.project_id,
+            provider: Provider::from_string(&self.provider),
+            region: self.region,
+            topology: self.topology,
+            deployment_tier: self.deployment_tier,
+            mutual_tls_enabled: self.mutual_tls_enabled,
+            per_node_cores: self.per_node_cores,
+            per_node_memory: self.per_node_memory as usize,
+            per_node_volume_size: self.per_node_volume_size as usize,
+            status: self.status.to_string(),
+            acl_id: self.acl_id,
+            projection_level: self.projection_level,
+            server_version: self.server_version,
+            server_version_tag: self.server_version_tag,
+        }
+    }
+}
+
+impl ToV1 for esc_api::mesdb::CreateSharedClusterResponse {
+    type V1Type = esc_api::mesdb::ClusterId;
+    fn to_v1(self) -> Self::V1Type {
+        self.id
+    }
+}
+
+impl ToV1 for esc_api::mesdb::GetSharedClusterResponse {
+    type V1Type = SharedCluster;
+    fn to_v1(self) -> Self::V1Type {
+        self.cluster.to_v1()
+    }
+}
+
+impl ToV1 for esc_api::mesdb::ListSharedClustersResponse {
+    type V1Type = List<SharedCluster>;
+    fn to_v1(self) -> Self::V1Type {
+        let l = self.clusters.into_iter().map(|c| c.to_v1()).collect();
+        List(l)
+    }
+}