Skip to content

Commit 9df73de

Browse files
WestwoooWestwooo
committed
Implement scopes for Capella clusters
Implement scopes create for Capella clusters Implement scopes drop for Capella clusters Increase timeout in flaky tests
1 parent 634d96b commit 9df73de

File tree

7 files changed

+488
-91
lines changed

7 files changed

+488
-91
lines changed

‎src/cli/scopes.rs

Lines changed: 101 additions & 25 deletions
Original file line numberDiff line numberDiff line change
@@ -2,16 +2,22 @@ use crate::cli::collections::{get_bucket_or_active, Manifest};
22
use crate::cli::error::{
33
client_error_to_shell_error, deserialize_error, unexpected_status_code_error,
44
};
5-
use crate::cli::util::{cluster_identifiers_from, get_active_cluster, NuValueMap};
5+
use crate::cli::util::{
6+
cluster_from_conn_str, cluster_identifiers_from, find_org_id, find_project_id,
7+
get_active_cluster, NuValueMap,
8+
};
69
use crate::client::ManagementRequest;
7-
use crate::state::State;
10+
use crate::remote_cluster::RemoteCluster;
11+
use crate::remote_cluster::RemoteClusterType::Provisioned;
12+
use crate::state::{RemoteCapellaOrganization, State};
813
use log::debug;
914
use nu_protocol::ast::Call;
1015
use nu_protocol::engine::{Command, EngineState, Stack};
1116
use nu_protocol::{
12-
Category, IntoPipelineData, PipelineData, ShellError, Signature, SyntaxShape, Value,
17+
Category, IntoPipelineData, PipelineData, ShellError, Signature, Span, SyntaxShape, Value,
1318
};
1419
use std::ops::Add;
20+
use std::sync::atomic::AtomicBool;
1521
use std::sync::{Arc, Mutex};
1622
use tokio::time::Instant;
1723

@@ -85,31 +91,23 @@ fn run(
8591

8692
debug!("Running scopes get for bucket {:?}", &bucket);
8793

88-
let response = active_cluster
89-
.cluster()
90-
.http_client()
91-
.management_request(
92-
ManagementRequest::GetScopes { bucket },
93-
Instant::now().add(active_cluster.timeouts().management_timeout()),
94+
let scopes = if active_cluster.cluster_type() == Provisioned {
95+
get_capella_scopes(
96+
guard.named_or_active_org(active_cluster.capella_org())?,
97+
guard.named_or_active_project(active_cluster.project())?,
98+
active_cluster,
99+
identifier.clone(),
100+
bucket,
94101
ctrl_c.clone(),
102+
span,
95103
)
96-
.map_err(|e| client_error_to_shell_error(e, span))?;
97-
98-
let manifest: Manifest = match response.status() {
99-
200 => serde_json::from_str(response.content())
100-
.map_err(|e| deserialize_error(e.to_string(), span))?,
101-
_ => {
102-
return Err(unexpected_status_code_error(
103-
response.status(),
104-
response.content(),
105-
span,
106-
));
107-
}
108-
};
109-
110-
for scope in manifest.scopes {
104+
} else {
105+
get_server_scopes(active_cluster, bucket, ctrl_c.clone(), span)
106+
}?;
107+
108+
for scope in scopes {
111109
let mut collected = NuValueMap::default();
112-
collected.add_string("scope", scope.name, span);
110+
collected.add_string("scope", scope, span);
113111
collected.add_string("cluster", identifier.clone(), span);
114112
results.push(collected.into_value(span));
115113
}
@@ -121,3 +119,81 @@ fn run(
121119
}
122120
.into_pipeline_data())
123121
}
122+
123+
fn get_capella_scopes(
124+
org: &RemoteCapellaOrganization,
125+
project: String,
126+
cluster: &RemoteCluster,
127+
identifier: String,
128+
bucket: String,
129+
ctrl_c: Arc<AtomicBool>,
130+
span: Span,
131+
) -> Result<Vec<String>, ShellError> {
132+
let client = org.client();
133+
let deadline = Instant::now().add(org.timeout());
134+
135+
let org_id = find_org_id(ctrl_c.clone(), &client, deadline, span)?;
136+
let project_id = find_project_id(
137+
ctrl_c.clone(),
138+
project,
139+
&client,
140+
deadline,
141+
span,
142+
org_id.clone(),
143+
)?;
144+
145+
let json_cluster = cluster_from_conn_str(
146+
identifier.clone(),
147+
ctrl_c.clone(),
148+
cluster.hostnames().clone(),
149+
&client,
150+
deadline,
151+
span,
152+
org_id.clone(),
153+
project_id.clone(),
154+
)?;
155+
156+
let scopes = client
157+
.list_scopes(
158+
org_id,
159+
project_id,
160+
json_cluster.id(),
161+
bucket,
162+
deadline,
163+
ctrl_c,
164+
)
165+
.map_err(|e| client_error_to_shell_error(e, span))?;
166+
167+
Ok(scopes.scopes().iter().map(|s| s.name().clone()).collect())
168+
}
169+
170+
fn get_server_scopes(
171+
cluster: &RemoteCluster,
172+
bucket: String,
173+
ctrl_c: Arc<AtomicBool>,
174+
span: Span,
175+
) -> Result<Vec<String>, ShellError> {
176+
let response = cluster
177+
.cluster()
178+
.http_client()
179+
.management_request(
180+
ManagementRequest::GetScopes { bucket },
181+
Instant::now().add(cluster.timeouts().management_timeout()),
182+
ctrl_c.clone(),
183+
)
184+
.map_err(|e| client_error_to_shell_error(e, span))?;
185+
186+
let manifest: Manifest = match response.status() {
187+
200 => serde_json::from_str(response.content())
188+
.map_err(|e| deserialize_error(e.to_string(), span))?,
189+
_ => {
190+
return Err(unexpected_status_code_error(
191+
response.status(),
192+
response.content(),
193+
span,
194+
));
195+
}
196+
};
197+
198+
Ok(manifest.scopes.iter().map(|s| s.name.clone()).collect())
199+
}

‎src/cli/scopes_create.rs

Lines changed: 109 additions & 32 deletions
Original file line numberDiff line numberDiff line change
@@ -1,20 +1,25 @@
1-
use crate::cli::util::{cluster_identifiers_from, get_active_cluster};
1+
use crate::cli::util::{
2+
cluster_from_conn_str, cluster_identifiers_from, find_org_id, find_project_id,
3+
get_active_cluster,
4+
};
25
use crate::client::ManagementRequest;
3-
use crate::state::State;
6+
use crate::state::{RemoteCapellaOrganization, State};
47
use log::debug;
58
use std::ops::Add;
9+
use std::sync::atomic::AtomicBool;
610
use std::sync::{Arc, Mutex};
711
use tokio::time::Instant;
812

913
use crate::cli::collections::get_bucket_or_active;
1014
use crate::cli::error::{
1115
client_error_to_shell_error, serialize_error, unexpected_status_code_error,
1216
};
17+
use crate::remote_cluster::RemoteCluster;
18+
use crate::remote_cluster::RemoteClusterType::Provisioned;
1319
use nu_engine::CallExt;
1420
use nu_protocol::ast::Call;
1521
use nu_protocol::engine::{Command, EngineState, Stack};
16-
use nu_protocol::Value::Nothing;
17-
use nu_protocol::{Category, PipelineData, ShellError, Signature, SyntaxShape};
22+
use nu_protocol::{Category, PipelineData, ShellError, Signature, Span, SyntaxShape};
1823

1924
#[derive(Clone)]
2025
pub struct ScopesCreate {
@@ -90,36 +95,108 @@ fn run(
9095
&scope, &bucket
9196
);
9297

93-
let form = vec![("name", scope.clone())];
94-
let payload =
95-
serde_urlencoded::to_string(&form).map_err(|e| serialize_error(e.to_string(), span))?;
96-
let response = active_cluster
97-
.cluster()
98-
.http_client()
99-
.management_request(
100-
ManagementRequest::CreateScope { payload, bucket },
101-
Instant::now().add(active_cluster.timeouts().management_timeout()),
98+
if active_cluster.cluster_type() == Provisioned {
99+
create_capella_scope(
100+
guard.named_or_active_org(active_cluster.capella_org())?,
101+
guard.named_or_active_project(active_cluster.project())?,
102+
active_cluster,
103+
identifier.clone(),
104+
bucket.clone(),
105+
scope.clone(),
102106
ctrl_c.clone(),
107+
span,
103108
)
104-
.map_err(|e| client_error_to_shell_error(e, span))?;
105-
106-
match response.status() {
107-
200 => {}
108-
202 => {}
109-
_ => {
110-
return Err(unexpected_status_code_error(
111-
response.status(),
112-
response.content(),
113-
span,
114-
));
115-
}
116-
}
109+
} else {
110+
create_server_scope(
111+
active_cluster,
112+
bucket.clone(),
113+
scope.clone(),
114+
ctrl_c.clone(),
115+
span,
116+
)
117+
}?;
117118
}
118119

119-
Ok(PipelineData::Value(
120-
Nothing {
121-
internal_span: span,
122-
},
123-
None,
124-
))
120+
Ok(PipelineData::empty())
121+
}
122+
123+
fn create_capella_scope(
124+
org: &RemoteCapellaOrganization,
125+
project: String,
126+
cluster: &RemoteCluster,
127+
identifier: String,
128+
bucket: String,
129+
name: String,
130+
ctrl_c: Arc<AtomicBool>,
131+
span: Span,
132+
) -> Result<(), ShellError> {
133+
let client = org.client();
134+
let deadline = Instant::now().add(org.timeout());
135+
136+
let org_id = find_org_id(ctrl_c.clone(), &client, deadline, span)?;
137+
138+
let project_id = find_project_id(
139+
ctrl_c.clone(),
140+
project,
141+
&client,
142+
deadline,
143+
span,
144+
org_id.clone(),
145+
)?;
146+
147+
let json_cluster = cluster_from_conn_str(
148+
identifier.clone(),
149+
ctrl_c.clone(),
150+
cluster.hostnames().clone(),
151+
&client,
152+
deadline,
153+
span,
154+
org_id.clone(),
155+
project_id.clone(),
156+
)?;
157+
158+
client
159+
.create_scope(
160+
org_id,
161+
project_id,
162+
json_cluster.id(),
163+
bucket,
164+
name,
165+
deadline,
166+
ctrl_c,
167+
)
168+
.map_err(|e| client_error_to_shell_error(e, span))
169+
}
170+
171+
fn create_server_scope(
172+
cluster: &RemoteCluster,
173+
bucket: String,
174+
scope: String,
175+
ctrl_c: Arc<AtomicBool>,
176+
span: Span,
177+
) -> Result<(), ShellError> {
178+
let form = vec![("name", scope.clone())];
179+
let payload =
180+
serde_urlencoded::to_string(form).map_err(|e| serialize_error(e.to_string(), span))?;
181+
let response = cluster
182+
.cluster()
183+
.http_client()
184+
.management_request(
185+
ManagementRequest::CreateScope { payload, bucket },
186+
Instant::now().add(cluster.timeouts().management_timeout()),
187+
ctrl_c.clone(),
188+
)
189+
.map_err(|e| client_error_to_shell_error(e, span))?;
190+
191+
match response.status() {
192+
200 => Ok(()),
193+
202 => Ok(()),
194+
_ => {
195+
return Err(unexpected_status_code_error(
196+
response.status(),
197+
response.content(),
198+
span,
199+
));
200+
}
201+
}
125202
}

0 commit comments

Comments
 (0)