Implement scopes for Capella clusters

Implement scopes create for Capella clusters

Implement scopes drop for Capella clusters

Increase timeout in flaky tests

src/cli/scopes.rs

@@ -2,16 +2,22 @@ use crate::cli::collections::{get_bucket_or_active, Manifest};
 use crate::cli::error::{
     client_error_to_shell_error, deserialize_error, unexpected_status_code_error,
 };
-use crate::cli::util::{cluster_identifiers_from, get_active_cluster, NuValueMap};
+use crate::cli::util::{
+    cluster_from_conn_str, cluster_identifiers_from, find_org_id, find_project_id,
+    get_active_cluster, NuValueMap,
+};
 use crate::client::ManagementRequest;
-use crate::state::State;
+use crate::remote_cluster::RemoteCluster;
+use crate::remote_cluster::RemoteClusterType::Provisioned;
+use crate::state::{RemoteCapellaOrganization, State};
 use log::debug;
 use nu_protocol::ast::Call;
 use nu_protocol::engine::{Command, EngineState, Stack};
 use nu_protocol::{
-    Category, IntoPipelineData, PipelineData, ShellError, Signature, SyntaxShape, Value,
+    Category, IntoPipelineData, PipelineData, ShellError, Signature, Span, SyntaxShape, Value,
 };
 use std::ops::Add;
+use std::sync::atomic::AtomicBool;
 use std::sync::{Arc, Mutex};
 use tokio::time::Instant;
 
@@ -85,31 +91,23 @@ fn run(
 
         debug!("Running scopes get for bucket {:?}", &bucket);
 
-        let response = active_cluster
-            .cluster()
-            .http_client()
-            .management_request(
-                ManagementRequest::GetScopes { bucket },
-                Instant::now().add(active_cluster.timeouts().management_timeout()),
+        let scopes = if active_cluster.cluster_type() == Provisioned {
+            get_capella_scopes(
+                guard.named_or_active_org(active_cluster.capella_org())?,
+                guard.named_or_active_project(active_cluster.project())?,
+                active_cluster,
+                identifier.clone(),
+                bucket,
                 ctrl_c.clone(),
+                span,
             )
-            .map_err(|e| client_error_to_shell_error(e, span))?;
-
-        let manifest: Manifest = match response.status() {
-            200 => serde_json::from_str(response.content())
-                .map_err(|e| deserialize_error(e.to_string(), span))?,
-            _ => {
-                return Err(unexpected_status_code_error(
-                    response.status(),
-                    response.content(),
-                    span,
-                ));
-            }
-        };
-
-        for scope in manifest.scopes {
+        } else {
+            get_server_scopes(active_cluster, bucket, ctrl_c.clone(), span)
+        }?;
+
+        for scope in scopes {
             let mut collected = NuValueMap::default();
-            collected.add_string("scope", scope.name, span);
+            collected.add_string("scope", scope, span);
             collected.add_string("cluster", identifier.clone(), span);
             results.push(collected.into_value(span));
         }
@@ -121,3 +119,81 @@ fn run(
     }
     .into_pipeline_data())
 }
+
+fn get_capella_scopes(
+    org: &RemoteCapellaOrganization,
+    project: String,
+    cluster: &RemoteCluster,
+    identifier: String,
+    bucket: String,
+    ctrl_c: Arc<AtomicBool>,
+    span: Span,
+) -> Result<Vec<String>, ShellError> {
+    let client = org.client();
+    let deadline = Instant::now().add(org.timeout());
+
+    let org_id = find_org_id(ctrl_c.clone(), &client, deadline, span)?;
+    let project_id = find_project_id(
+        ctrl_c.clone(),
+        project,
+        &client,
+        deadline,
+        span,
+        org_id.clone(),
+    )?;
+
+    let json_cluster = cluster_from_conn_str(
+        identifier.clone(),
+        ctrl_c.clone(),
+        cluster.hostnames().clone(),
+        &client,
+        deadline,
+        span,
+        org_id.clone(),
+        project_id.clone(),
+    )?;
+
+    let scopes = client
+        .list_scopes(
+            org_id,
+            project_id,
+            json_cluster.id(),
+            bucket,
+            deadline,
+            ctrl_c,
+        )
+        .map_err(|e| client_error_to_shell_error(e, span))?;
+
+    Ok(scopes.scopes().iter().map(|s| s.name().clone()).collect())
+}
+
+fn get_server_scopes(
+    cluster: &RemoteCluster,
+    bucket: String,
+    ctrl_c: Arc<AtomicBool>,
+    span: Span,
+) -> Result<Vec<String>, ShellError> {
+    let response = cluster
+        .cluster()
+        .http_client()
+        .management_request(
+            ManagementRequest::GetScopes { bucket },
+            Instant::now().add(cluster.timeouts().management_timeout()),
+            ctrl_c.clone(),
+        )
+        .map_err(|e| client_error_to_shell_error(e, span))?;
+
+    let manifest: Manifest = match response.status() {
+        200 => serde_json::from_str(response.content())
+            .map_err(|e| deserialize_error(e.to_string(), span))?,
+        _ => {
+            return Err(unexpected_status_code_error(
+                response.status(),
+                response.content(),
+                span,
+            ));
+        }
+    };
+
+    Ok(manifest.scopes.iter().map(|s| s.name.clone()).collect())
+}

src/cli/scopes_create.rs

@@ -1,20 +1,25 @@
-use crate::cli::util::{cluster_identifiers_from, get_active_cluster};
+use crate::cli::util::{
+    cluster_from_conn_str, cluster_identifiers_from, find_org_id, find_project_id,
+    get_active_cluster,
+};
 use crate::client::ManagementRequest;
-use crate::state::State;
+use crate::state::{RemoteCapellaOrganization, State};
 use log::debug;
 use std::ops::Add;
+use std::sync::atomic::AtomicBool;
 use std::sync::{Arc, Mutex};
 use tokio::time::Instant;
 
 use crate::cli::collections::get_bucket_or_active;
 use crate::cli::error::{
     client_error_to_shell_error, serialize_error, unexpected_status_code_error,
 };
+use crate::remote_cluster::RemoteCluster;
+use crate::remote_cluster::RemoteClusterType::Provisioned;
 use nu_engine::CallExt;
 use nu_protocol::ast::Call;
 use nu_protocol::engine::{Command, EngineState, Stack};
-use nu_protocol::Value::Nothing;
-use nu_protocol::{Category, PipelineData, ShellError, Signature, SyntaxShape};
+use nu_protocol::{Category, PipelineData, ShellError, Signature, Span, SyntaxShape};
 
 #[derive(Clone)]
 pub struct ScopesCreate {
@@ -90,36 +95,108 @@ fn run(
             &scope, &bucket
         );
 
-        let form = vec![("name", scope.clone())];
-        let payload =
-            serde_urlencoded::to_string(&form).map_err(|e| serialize_error(e.to_string(), span))?;
-        let response = active_cluster
-            .cluster()
-            .http_client()
-            .management_request(
-                ManagementRequest::CreateScope { payload, bucket },
-                Instant::now().add(active_cluster.timeouts().management_timeout()),
+        if active_cluster.cluster_type() == Provisioned {
+            create_capella_scope(
+                guard.named_or_active_org(active_cluster.capella_org())?,
+                guard.named_or_active_project(active_cluster.project())?,
+                active_cluster,
+                identifier.clone(),
+                bucket.clone(),
+                scope.clone(),
                 ctrl_c.clone(),
+                span,
             )
-            .map_err(|e| client_error_to_shell_error(e, span))?;
-
-        match response.status() {
-            200 => {}
-            202 => {}
-            _ => {
-                return Err(unexpected_status_code_error(
-                    response.status(),
-                    response.content(),
-                    span,
-                ));
-            }
-        }
+        } else {
+            create_server_scope(
+                active_cluster,
+                bucket.clone(),
+                scope.clone(),
+                ctrl_c.clone(),
+                span,
+            )
+        }?;
     }
 
-    Ok(PipelineData::Value(
-        Nothing {
-            internal_span: span,
-        },
-        None,
-    ))
+    Ok(PipelineData::empty())
+}
+
+fn create_capella_scope(
+    org: &RemoteCapellaOrganization,
+    project: String,
+    cluster: &RemoteCluster,
+    identifier: String,
+    bucket: String,
+    name: String,
+    ctrl_c: Arc<AtomicBool>,
+    span: Span,
+) -> Result<(), ShellError> {
+    let client = org.client();
+    let deadline = Instant::now().add(org.timeout());
+
+    let org_id = find_org_id(ctrl_c.clone(), &client, deadline, span)?;
+
+    let project_id = find_project_id(
+        ctrl_c.clone(),
+        project,
+        &client,
+        deadline,
+        span,
+        org_id.clone(),
+    )?;
+
+    let json_cluster = cluster_from_conn_str(
+        identifier.clone(),
+        ctrl_c.clone(),
+        cluster.hostnames().clone(),
+        &client,
+        deadline,
+        span,
+        org_id.clone(),
+        project_id.clone(),
+    )?;
+
+    client
+        .create_scope(
+            org_id,
+            project_id,
+            json_cluster.id(),
+            bucket,
+            name,
+            deadline,
+            ctrl_c,
+        )
+        .map_err(|e| client_error_to_shell_error(e, span))
+}
+
+fn create_server_scope(
+    cluster: &RemoteCluster,
+    bucket: String,
+    scope: String,
+    ctrl_c: Arc<AtomicBool>,
+    span: Span,
+) -> Result<(), ShellError> {
+    let form = vec![("name", scope.clone())];
+    let payload =
+        serde_urlencoded::to_string(form).map_err(|e| serialize_error(e.to_string(), span))?;
+    let response = cluster
+        .cluster()
+        .http_client()
+        .management_request(
+            ManagementRequest::CreateScope { payload, bucket },
+            Instant::now().add(cluster.timeouts().management_timeout()),
+            ctrl_c.clone(),
+        )
+        .map_err(|e| client_error_to_shell_error(e, span))?;
+
+    match response.status() {
+        200 => Ok(()),
+        202 => Ok(()),
+        _ => {
+            return Err(unexpected_status_code_error(
+                response.status(),
+                response.content(),
+                span,
+            ));
+        }
+    }
 }