From a873f47a78cea9ddcf2a170e287682ccddf8da32 Mon Sep 17 00:00:00 2001 From: Evan Lezar Date: Wed, 9 Sep 2026 11:36:02 +0200 Subject: [PATCH 1/7] feat(api)!: unify portable sandbox resource requirements Model CPU, memory, and GPU through one typed ResourceRequirements envelope across inline sandbox specs, reusable workload templates, and compute drivers. Update the CLI, gateway translation, and built-in drivers to consume the unified model. BREAKING CHANGE: CPU and memory move to typed resource requirements, and SandboxWorkloadConfig.resources now uses ResourceRequirements instead of SandboxResources. Part of #2838 Signed-off-by: Evan Lezar --- crates/openshell-cli/src/main.rs | 21 +- crates/openshell-cli/src/run.rs | 306 +++++++----------- .../sandbox_create_lifecycle_integration.rs | 98 +++--- crates/openshell-core/src/gpu.rs | 4 +- crates/openshell-core/src/lib.rs | 1 + crates/openshell-core/src/quantity.rs | 121 +++++++ crates/openshell-driver-docker/src/lib.rs | 46 ++- crates/openshell-driver-docker/src/tests.rs | 56 ++-- .../openshell-driver-kubernetes/src/driver.rs | 130 +++++--- crates/openshell-driver-mxc/src/driver.rs | 11 + .../openshell-driver-podman/src/container.rs | 86 +++-- crates/openshell-driver-podman/src/driver.rs | 2 + crates/openshell-driver-vm/src/driver.rs | 48 ++- crates/openshell-server/src/compute/mod.rs | 113 ++++--- crates/openshell-server/src/grpc/sandbox.rs | 105 ++---- proto/compute_driver.proto | 36 +-- proto/openshell.proto | 32 +- 17 files changed, 662 insertions(+), 554 deletions(-) create mode 100644 crates/openshell-core/src/quantity.rs diff --git a/crates/openshell-cli/src/main.rs b/crates/openshell-cli/src/main.rs index 142a520068..756eb30a45 100644 --- a/crates/openshell-cli/src/main.rs +++ b/crates/openshell-cli/src/main.rs @@ -19,7 +19,7 @@ use openshell_bootstrap::{ use openshell_cli::completers; use openshell_cli::run; use openshell_cli::tls::TlsOptions; -use openshell_core::proto::GpuResourceRequirements; +use openshell_core::proto::{GpuResourceRequirements, ResourceRequirements}; /// Resolved gateway context: name + gateway endpoint. struct GatewayContext { @@ -3281,6 +3281,21 @@ async fn run_async() -> Result<()> { .transpose()?; let keep = keep || !no_keep || editor.is_some() || forward.is_some(); let gpu_requirements: Option = gpu.map(Into::into); + let cpu_requirements = run::build_cpu_resource_requirements(cpu.as_deref())?; + let memory_requirements = + run::build_memory_resource_requirements(memory.as_deref())?; + let resource_requirements = if gpu_requirements.is_some() + || cpu_requirements.is_some() + || memory_requirements.is_some() + { + Some(ResourceRequirements { + gpu: gpu_requirements, + cpu: cpu_requirements, + memory: memory_requirements, + }) + } else { + None + }; let ctx = resolve_gateway(&cli.gateway, &cli.gateway_endpoint)?; let endpoint = &ctx.endpoint; @@ -3295,9 +3310,7 @@ async fn run_async() -> Result<()> { from: from.as_deref(), uploads: &upload_specs, keep, - gpu_requirements, - cpu: cpu.as_deref(), - memory: memory.as_deref(), + resource_requirements, driver_config_json: driver_config_json.as_deref(), editor, providers: &providers, diff --git a/crates/openshell-cli/src/run.rs b/crates/openshell-cli/src/run.rs index 18c8ee7366..e033a6eb04 100644 --- a/crates/openshell-cli/src/run.rs +++ b/crates/openshell-cli/src/run.rs @@ -45,21 +45,21 @@ use openshell_bootstrap::{ use openshell_core::net::set_tcp_nodelay_best_effort; use openshell_core::proto::{ ApproveAllDraftChunksRequest, ApproveDraftChunkRequest, BeginRootfsTarStagingRequest, - ClearDraftChunksRequest, CreateSandboxRequest, CreateSandboxTemplateRequest, - CreateSshSessionRequest, DeleteInferenceRouteRequest, DeleteSandboxRequest, - DeleteSandboxTemplateRequest, DeleteServiceRequest, ExecSandboxRequest, ExposeServiceRequest, - GetCurrentUserRequest, GetDraftHistoryRequest, GetDraftPolicyRequest, GetGatewayConfigRequest, - GetInferenceRouteRequest, GetSandboxConfigRequest, GetSandboxConfigResponse, - GetSandboxLogsRequest, GetSandboxPolicyStatusRequest, GetSandboxRequest, - GetSandboxTemplateRequest, GetServiceRequest, GpuResourceRequirements, + ClearDraftChunksRequest, CpuResourceRequirements, CreateSandboxRequest, + CreateSandboxTemplateRequest, CreateSshSessionRequest, DeleteInferenceRouteRequest, + DeleteSandboxRequest, DeleteSandboxTemplateRequest, DeleteServiceRequest, ExecSandboxRequest, + ExposeServiceRequest, GetCurrentUserRequest, GetDraftHistoryRequest, GetDraftPolicyRequest, + GetGatewayConfigRequest, GetInferenceRouteRequest, GetSandboxConfigRequest, + GetSandboxConfigResponse, GetSandboxLogsRequest, GetSandboxPolicyStatusRequest, + GetSandboxRequest, GetSandboxTemplateRequest, GetServiceRequest, GpuResourceRequirements, ListSandboxPoliciesRequest, ListSandboxTemplatesRequest, ListSandboxesRequest, - ListServicesRequest, PolicySource, PolicyStatus, RejectDraftChunkRequest, ResourceRequirements, - RevokeSshSessionRequest, Sandbox, SandboxPhase, SandboxPolicy, SandboxResources, - SandboxServiceLevel, SandboxSpec, SandboxStartup, SandboxTemplate, SandboxWorkloadConfig, - SandboxWorkloadTemplate, SandboxWorkloadTemplateSpec, ServiceEndpointResponse, - SetInferenceRouteRequest, SettingScope, StartSandboxRequest, StopSandboxRequest, - TcpForwardFrame, TcpForwardInit, TcpRelayTarget, UpdateConfigRequest, WatchSandboxRequest, - exec_sandbox_event, tcp_forward_init, + ListServicesRequest, MemoryResourceRequirements, PolicySource, PolicyStatus, + RejectDraftChunkRequest, ResourceRequirements, RevokeSshSessionRequest, Sandbox, SandboxPhase, + SandboxPolicy, SandboxServiceLevel, SandboxSpec, SandboxStartup, SandboxTemplate, + SandboxWorkloadConfig, SandboxWorkloadTemplate, SandboxWorkloadTemplateSpec, + ServiceEndpointResponse, SetInferenceRouteRequest, SettingScope, StartSandboxRequest, + StopSandboxRequest, TcpForwardFrame, TcpForwardInit, TcpRelayTarget, UpdateConfigRequest, + WatchSandboxRequest, exec_sandbox_event, tcp_forward_init, }; use openshell_core::settings; use openshell_core::{ObjectId, ObjectName, ObjectWorkspace}; @@ -253,41 +253,28 @@ fn has_main_process_result(sandbox: &Sandbox) -> bool { }) } -fn build_sandbox_resource_limits( +pub fn build_cpu_resource_requirements( cpu: Option<&str>, - memory: Option<&str>, -) -> Result> { - use prost_types::{Struct, Value, value::Kind}; - - fn string_value(value: String) -> Value { - Value { - kind: Some(Kind::StringValue(value)), - } - } +) -> Result> { + let Some(cpu) = cpu else { + return Ok(None); + }; - let mut limits = std::collections::BTreeMap::new(); - if let Some(cpu) = cpu { - limits.insert("cpu".to_string(), string_value(validate_cpu_quantity(cpu)?)); - } - if let Some(memory) = memory { - limits.insert( - "memory".to_string(), - string_value(validate_memory_quantity(memory)?), - ); - } + Ok(Some(CpuResourceRequirements { + limit: validate_cpu_quantity(cpu)?, + })) +} - if limits.is_empty() { +pub fn build_memory_resource_requirements( + memory: Option<&str>, +) -> Result> { + let Some(memory) = memory else { return Ok(None); - } + }; - let mut fields = std::collections::BTreeMap::new(); - fields.insert( - "limits".to_string(), - Value { - kind: Some(Kind::StructValue(Struct { fields: limits })), - }, - ); - Ok(Some(Struct { fields })) + Ok(Some(MemoryResourceRequirements { + limit: validate_memory_quantity(memory)?, + })) } fn parse_driver_config_json(value: &str) -> Result { @@ -307,61 +294,14 @@ fn parse_driver_config_json(value: &str) -> Result { } fn validate_cpu_quantity(value: &str) -> Result { - let value = value.trim(); - if value.is_empty() { - return Err(miette!("--cpu must not be empty")); - } - - if let Some(millicores) = value.strip_suffix('m') { - if millicores.is_empty() || !millicores.bytes().all(|b| b.is_ascii_digit()) { - return Err(miette!( - "invalid --cpu value '{value}': expected positive cores or millicores, for example 2, 0.5, or 500m" - )); - } - let millicores = millicores.parse::().into_diagnostic()?; - if millicores == 0 { - return Err(miette!("--cpu must be greater than zero")); - } - return Ok(value.to_string()); - } - - let cores = value.parse::().map_err(|_| { - miette!( - "invalid --cpu value '{value}': expected positive cores or millicores, for example 2, 0.5, or 500m" - ) - })?; - if !cores.is_finite() || cores <= 0.0 { - return Err(miette!("--cpu must be greater than zero")); - } - Ok(value.to_string()) + openshell_core::quantity::validate_cpu_quantity(value, "--cpu").map_err(|e| miette!("{e}"))?; + Ok(value.trim().to_string()) } fn validate_memory_quantity(value: &str) -> Result { - let value = value.trim(); - if value.is_empty() { - return Err(miette!("--memory must not be empty")); - } - - let number_end = value - .find(|ch: char| !ch.is_ascii_digit()) - .unwrap_or(value.len()); - let (number, suffix) = value.split_at(number_end); - if number.is_empty() - || !matches!( - suffix, - "" | "Ki" | "Mi" | "Gi" | "Ti" | "Pi" | "Ei" | "K" | "M" | "G" | "T" | "P" | "E" - ) - { - return Err(miette!( - "invalid --memory value '{value}': expected positive bytes or a quantity such as 512Mi, 4Gi, or 8G" - )); - } - - let amount = number.parse::().into_diagnostic()?; - if amount == 0 { - return Err(miette!("--memory must be greater than zero")); - } - Ok(value.to_string()) + openshell_core::quantity::validate_memory_quantity(value, "--memory") + .map_err(|e| miette!("{e}"))?; + Ok(value.trim().to_string()) } async fn finalize_sandbox_create_session( @@ -402,9 +342,7 @@ pub struct SandboxCreateConfig<'a> { pub from: Option<&'a str>, pub uploads: &'a [(String, Option, bool)], pub keep: bool, - pub gpu_requirements: Option, - pub cpu: Option<&'a str>, - pub memory: Option<&'a str>, + pub resource_requirements: Option, pub driver_config_json: Option<&'a str>, pub editor: Option, pub providers: &'a [String], @@ -428,9 +366,7 @@ impl Default for SandboxCreateConfig<'_> { from: None, uploads: &[], keep: false, - gpu_requirements: None, - cpu: None, - memory: None, + resource_requirements: None, driver_config_json: None, editor: None, providers: &[], @@ -462,9 +398,7 @@ pub async fn sandbox_create( from, uploads, keep, - gpu_requirements, - cpu, - memory, + resource_requirements, driver_config_json, editor, providers, @@ -514,9 +448,7 @@ pub async fn sandbox_create( if template.is_some() && (from.is_some() - || gpu_requirements.is_some() - || cpu.is_some() - || memory.is_some() + || resource_requirements.is_some() || driver_config_json.is_some() || !environment.is_empty()) { @@ -566,11 +498,6 @@ pub async fn sandbox_create( .await?; let policy = load_sandbox_policy(policy)?; - let resource_limits = if template.is_none() { - build_sandbox_resource_limits(cpu, memory)? - } else { - None - }; let mut driver_config = if template.is_none() { driver_config_json .map(parse_driver_config_json) @@ -583,22 +510,16 @@ pub async fn sandbox_create( driver_config = Some(merge_rootfs_tar_driver_config(driver_config, token)?); } - let inline_template = if image.is_some() - || resource_limits.is_some() - || driver_config.is_some() - || rootfs_tar_token.is_some() - { - Some(SandboxTemplate { - image: image.unwrap_or_default(), - resources: resource_limits, - driver_config, - ..SandboxTemplate::default() - }) - } else { - None - }; - - let resource_requirements = gpu_requirements.map(|gpu| ResourceRequirements { gpu: Some(gpu) }); + let inline_template = + if image.is_some() || driver_config.is_some() || rootfs_tar_token.is_some() { + Some(SandboxTemplate { + image: image.unwrap_or_default(), + driver_config, + ..SandboxTemplate::default() + }) + } else { + None + }; let main_terminal = tty_override .unwrap_or_else(|| std::io::stdin().is_terminal() && std::io::stdout().is_terminal()); @@ -623,7 +544,7 @@ pub async fn sandbox_create( }; let request = CreateSandboxRequest { spec: Some(SandboxSpec { - resource_requirements, + resource_requirements: resource_requirements.clone(), environment: if template.is_none() { environment } else { @@ -2545,15 +2466,15 @@ pub async fn sandbox_template_create( tls: &TlsOptions, ) -> Result<()> { let resources = if cpu.is_some() || memory.is_some() || gpu_requirements.is_some() { - Some(SandboxResources { + Some(ResourceRequirements { cpu: cpu .map(validate_cpu_quantity) .transpose()? - .unwrap_or_default(), + .map(|limit| CpuResourceRequirements { limit }), memory: memory .map(validate_memory_quantity) .transpose()? - .unwrap_or_default(), + .map(|limit| MemoryResourceRequirements { limit }), gpu: gpu_requirements, }) } else { @@ -2796,12 +2717,11 @@ fn sandbox_template_to_json(template: &SandboxWorkloadTemplate) -> serde_json::V } if let Some(resources) = &workload.resources { let mut resources_json = serde_json::Map::new(); - if !resources.cpu.is_empty() { - resources_json.insert("cpu".to_string(), serde_json::json!(resources.cpu)); + if let Some(cpu) = &resources.cpu { + resources_json.insert("cpu".to_string(), serde_json::json!(cpu.limit)); } - if !resources.memory.is_empty() { - resources_json - .insert("memory".to_string(), serde_json::json!(resources.memory)); + if let Some(memory) = &resources.memory { + resources_json.insert("memory".to_string(), serde_json::json!(memory.limit)); } if let Some(gpu) = &resources.gpu { let value = gpu @@ -2898,12 +2818,17 @@ fn print_sandbox_template_detail(template: &SandboxWorkloadTemplate) { println!( " {} {}", "CPU:".dimmed(), - non_empty_or(&resources.cpu, "") + resources + .cpu + .as_ref() + .map_or("", |cpu| non_empty_or(&cpu.limit, "")) ); println!( " {} {}", "Memory:".dimmed(), - non_empty_or(&resources.memory, "") + resources.memory.as_ref().map_or("", |memory| { + non_empty_or(&memory.limit, "") + }) ); println!( " {} {}", @@ -2987,11 +2912,13 @@ fn print_sandbox_template_table(templates: &[SandboxWorkloadTemplate], show_work for template in templates { let resources = template_resources(template); let cpu = resources - .map(|resources| resources.cpu.as_str()) + .and_then(|resources| resources.cpu.as_ref()) + .map(|cpu| cpu.limit.as_str()) .filter(|cpu| !cpu.is_empty()) .unwrap_or("-"); let memory = resources - .map(|resources| resources.memory.as_str()) + .and_then(|resources| resources.memory.as_ref()) + .map(|memory| memory.limit.as_str()) .filter(|memory| !memory.is_empty()) .unwrap_or("-"); let gpu = resources @@ -3051,7 +2978,7 @@ fn template_image(template: &SandboxWorkloadTemplate) -> String { ) } -fn template_resources(template: &SandboxWorkloadTemplate) -> Option<&SandboxResources> { +fn template_resources(template: &SandboxWorkloadTemplate) -> Option<&ResourceRequirements> { template .spec .as_ref() @@ -3059,7 +2986,7 @@ fn template_resources(template: &SandboxWorkloadTemplate) -> Option<&SandboxReso .and_then(|workload| workload.resources.as_ref()) } -fn template_resources_gpu_display(resources: &SandboxResources) -> Option { +fn template_resources_gpu_display(resources: &ResourceRequirements) -> Option { if let Some(gpu) = &resources.gpu { return Some( gpu.count @@ -6155,12 +6082,13 @@ fn format_endpoint(endpoint: &openshell_core::proto::NetworkEndpoint) -> String #[cfg(test)] mod tests { use super::{ - PolicyGetView, ProvisioningStep, build_sandbox_resource_limits, - dockerfile_sources_supported_for_gateway, format_endpoint, format_log_line, git_sync_files, - has_main_process_result, parse_cli_setting_value, parse_credential_expiry_cli_value, - parse_driver_config_json, parse_secret_material_env_pairs, policy_revision_list_json, - policy_revision_to_json, provisioning_timeout_message, ready_false_condition_message, - resolve_from, sandbox_should_persist, sandbox_upload_plan, service_endpoint_to_json, + PolicyGetView, ProvisioningStep, build_cpu_resource_requirements, + build_memory_resource_requirements, dockerfile_sources_supported_for_gateway, + format_endpoint, format_log_line, git_sync_files, has_main_process_result, + parse_cli_setting_value, parse_credential_expiry_cli_value, parse_driver_config_json, + parse_secret_material_env_pairs, policy_revision_list_json, policy_revision_to_json, + provisioning_timeout_message, ready_false_condition_message, resolve_from, + sandbox_should_persist, sandbox_upload_plan, service_endpoint_to_json, service_expose_status_error, service_url_for_gateway, workspace_member_to_json, }; use crate::TEST_ENV_LOCK; @@ -6181,10 +6109,9 @@ mod tests { use openshell_core::proto::{ GetSandboxConfigResponse, GpuResourceRequirements, PolicySource, PolicyStatus, ResourceRequirements, Sandbox, SandboxCondition, SandboxPhase, SandboxPolicy, - SandboxPolicyRevision, SandboxResources, SandboxStatus, SandboxWorkloadConfig, - SandboxWorkloadTemplate, SandboxWorkloadTemplateProvenance, SandboxWorkloadTemplateSpec, - ServiceEndpoint, ServiceEndpointResponse, WorkspaceMember, WorkspaceRole, - datamodel::v1::ObjectMeta, + SandboxPolicyRevision, SandboxStatus, SandboxWorkloadConfig, SandboxWorkloadTemplate, + SandboxWorkloadTemplateProvenance, SandboxWorkloadTemplateSpec, ServiceEndpoint, + ServiceEndpointResponse, WorkspaceMember, WorkspaceRole, datamodel::v1::ObjectMeta, }; #[test] @@ -6519,52 +6446,29 @@ mod tests { } #[test] - fn build_sandbox_resource_limits_sets_limits_only() { - let resources = build_sandbox_resource_limits(Some("500m"), Some("2Gi")) - .expect("resource limits should parse") - .expect("resource limits should be present"); + fn build_cpu_resource_requirements_sets_typed_limit() { + let cpu = build_cpu_resource_requirements(Some("500m")) + .expect("CPU limit should parse") + .expect("CPU requirements should be present"); - let limits = resources - .fields - .get("limits") - .and_then(|value| value.kind.as_ref()) - .and_then(|kind| match kind { - prost_types::value::Kind::StructValue(inner) => Some(inner), - _ => None, - }) - .expect("limits should be a struct"); + assert_eq!(cpu.limit, "500m"); + } - assert_eq!( - limits - .fields - .get("cpu") - .and_then(|value| value.kind.as_ref()) - .and_then(|kind| match kind { - prost_types::value::Kind::StringValue(value) => Some(value.as_str()), - _ => None, - }), - Some("500m") - ); - assert_eq!( - limits - .fields - .get("memory") - .and_then(|value| value.kind.as_ref()) - .and_then(|kind| match kind { - prost_types::value::Kind::StringValue(value) => Some(value.as_str()), - _ => None, - }), - Some("2Gi") - ); - assert!(!resources.fields.contains_key("requests")); + #[test] + fn build_memory_resource_requirements_sets_typed_limit() { + let memory = build_memory_resource_requirements(Some("2Gi")) + .expect("memory limit should parse") + .expect("memory requirements should be present"); + + assert_eq!(memory.limit, "2Gi"); } #[test] - fn build_sandbox_resource_limits_rejects_invalid_quantities() { - assert!(build_sandbox_resource_limits(Some("0"), None).is_err()); - assert!(build_sandbox_resource_limits(Some("half"), None).is_err()); - assert!(build_sandbox_resource_limits(None, Some("0Gi")).is_err()); - assert!(build_sandbox_resource_limits(None, Some("1.5Gi")).is_err()); + fn build_cpu_and_memory_resource_requirements_reject_invalid_quantities() { + assert!(build_cpu_resource_requirements(Some("0")).is_err()); + assert!(build_cpu_resource_requirements(Some("half")).is_err()); + assert!(build_memory_resource_requirements(Some("0Gi")).is_err()); + assert!(build_memory_resource_requirements(Some("1.5Gi")).is_err()); } #[test] @@ -7046,6 +6950,8 @@ mod tests { fn provisioning_timeout_message_includes_condition_and_gpu_hint() { let resource_requirements = ResourceRequirements { gpu: Some(GpuResourceRequirements { count: None }), + cpu: None, + memory: None, }; let message = provisioning_timeout_message( 120, @@ -7067,7 +6973,11 @@ mod tests { #[test] fn provisioning_timeout_message_omits_gpu_hint_without_gpu_requirements() { - let resource_requirements = ResourceRequirements { gpu: None }; + let resource_requirements = ResourceRequirements { + gpu: None, + cpu: None, + memory: None, + }; let message = provisioning_timeout_message(120, Some(&resource_requirements), None); assert_eq!(message, "sandbox provisioning timed out after 120s"); @@ -7306,7 +7216,7 @@ mod tests { let template = SandboxWorkloadTemplate { spec: Some(SandboxWorkloadTemplateSpec { workload: Some(SandboxWorkloadConfig { - resources: Some(SandboxResources { + resources: Some(ResourceRequirements { gpu: Some(GpuResourceRequirements { count: None }), ..Default::default() }), @@ -7327,7 +7237,7 @@ mod tests { let template = SandboxWorkloadTemplate { spec: Some(SandboxWorkloadTemplateSpec { workload: Some(SandboxWorkloadConfig { - resources: Some(SandboxResources { + resources: Some(ResourceRequirements { gpu: Some(GpuResourceRequirements { count: Some(2) }), ..Default::default() }), diff --git a/crates/openshell-cli/tests/sandbox_create_lifecycle_integration.rs b/crates/openshell-cli/tests/sandbox_create_lifecycle_integration.rs index d2f50735de..7ad1a06229 100644 --- a/crates/openshell-cli/tests/sandbox_create_lifecycle_integration.rs +++ b/crates/openshell-cli/tests/sandbox_create_lifecycle_integration.rs @@ -25,9 +25,9 @@ use openshell_core::proto::{ GpuResourceRequirements, HealthRequest, HealthResponse, ListProvidersRequest, ListProvidersResponse, ListSandboxProvidersRequest, ListSandboxProvidersResponse, ListSandboxTemplatesRequest, ListSandboxTemplatesResponse, ListSandboxesRequest, - ListSandboxesResponse, PlatformEvent, Provider, ProviderResponse, RevokeSshSessionRequest, - RevokeSshSessionResponse, Sandbox, SandboxCondition, SandboxLogLine, SandboxPhase, - SandboxResponse, SandboxStatus, SandboxStreamEvent, SandboxTemplateResponse, + ListSandboxesResponse, PlatformEvent, Provider, ProviderResponse, ResourceRequirements, + RevokeSshSessionRequest, RevokeSshSessionResponse, Sandbox, SandboxCondition, SandboxLogLine, + SandboxPhase, SandboxResponse, SandboxStatus, SandboxStreamEvent, SandboxTemplateResponse, SandboxWorkloadTemplate, ServiceStatus, SettingValue, SupervisorMessage, UpdateProviderRequest, WatchSandboxRequest, sandbox_stream_event, }; @@ -1380,6 +1380,14 @@ fn gpu_requirements(count: Option) -> GpuResourceRequirements { GpuResourceRequirements { count } } +fn resource_requirements( + gpu: Option, + cpu: Option, + memory: Option, +) -> ResourceRequirements { + ResourceRequirements { gpu, cpu, memory } +} + /// Shared defaults for integration tests. Note: `keep` is `true` here (most /// tests expect persistent sandboxes) while `SandboxCreateConfig::default()` /// sets `keep: false` (the safe production default). Tests that exercise @@ -1495,7 +1503,7 @@ async fn sandbox_create_without_inferred_provider_skips_gateway_config() { } #[tokio::test] -async fn sandbox_create_sends_cpu_and_memory_limits_only() { +async fn sandbox_create_sends_typed_cpu_and_memory_requirements() { let server = run_server().await; let fake_ssh_dir = tempfile::tempdir().unwrap(); let xdg_dir = tempfile::tempdir().unwrap(); @@ -1508,8 +1516,15 @@ async fn sandbox_create_sends_cpu_and_memory_limits_only() { "openshell", run::SandboxCreateConfig { name: Some("resources"), - cpu: Some("500m"), - memory: Some("2Gi"), + resource_requirements: Some(resource_requirements( + None, + Some(openshell_core::proto::CpuResourceRequirements { + limit: "500m".to_string(), + }), + Some(openshell_core::proto::MemoryResourceRequirements { + limit: "2Gi".to_string(), + }), + )), command: &["echo".into(), "OK".into()], ..test_config() }, @@ -1520,45 +1535,31 @@ async fn sandbox_create_sends_cpu_and_memory_limits_only() { .expect("sandbox create should succeed"); let requests = create_requests(&server).await; - let resources = requests[0] + let requirements = requests[0] .spec .as_ref() - .and_then(|spec| spec.template.as_ref()) - .and_then(|template| template.resources.as_ref()) - .expect("resource limits should be sent"); - let limits = resources - .fields - .get("limits") - .and_then(|value| value.kind.as_ref()) - .and_then(|kind| match kind { - prost_types::value::Kind::StructValue(inner) => Some(inner), - _ => None, - }) - .expect("limits should be a struct"); + .and_then(|spec| spec.resource_requirements.as_ref()) + .expect("resource requirements should be sent"); assert_eq!( - limits - .fields - .get("cpu") - .and_then(|value| value.kind.as_ref()) - .and_then(|kind| match kind { - prost_types::value::Kind::StringValue(value) => Some(value.as_str()), - _ => None, - }), + requirements.cpu.as_ref().map(|cpu| cpu.limit.as_str()), Some("500m") ); assert_eq!( - limits - .fields - .get("memory") - .and_then(|value| value.kind.as_ref()) - .and_then(|kind| match kind { - prost_types::value::Kind::StringValue(value) => Some(value.as_str()), - _ => None, - }), + requirements + .memory + .as_ref() + .map(|memory| memory.limit.as_str()), Some("2Gi") ); - assert!(!resources.fields.contains_key("requests")); + assert!( + requests[0] + .spec + .as_ref() + .and_then(|spec| spec.template.as_ref()) + .is_none(), + "resource-only create should not synthesize a template" + ); } #[tokio::test] @@ -1784,8 +1785,17 @@ async fn sandbox_template_create_sends_workload_template_resource() { .resources .as_ref() .expect("resources should be sent"); - assert_eq!(resources.cpu, "2"); - assert_eq!(resources.memory, "4Gi"); + assert_eq!( + resources.cpu.as_ref().map(|cpu| cpu.limit.as_str()), + Some("2") + ); + assert_eq!( + resources + .memory + .as_ref() + .map(|memory| memory.limit.as_str()), + Some("4Gi") + ); assert_eq!(resources.gpu.as_ref().and_then(|gpu| gpu.count), Some(1)); assert!(spec.driver_config.is_some()); let startup = spec @@ -1901,7 +1911,11 @@ async fn sandbox_create_sends_gpu_default_request() { "openshell", run::SandboxCreateConfig { name: Some("gpu-default"), - gpu_requirements: Some(gpu_requirements(None)), + resource_requirements: Some(resource_requirements( + Some(gpu_requirements(None)), + None, + None, + )), command: &["echo".into(), "OK".into()], ..test_config() }, @@ -1936,7 +1950,11 @@ async fn sandbox_create_sends_gpu_count_request() { "openshell", run::SandboxCreateConfig { name: Some("gpu-two"), - gpu_requirements: Some(gpu_requirements(Some(2))), + resource_requirements: Some(resource_requirements( + Some(gpu_requirements(Some(2))), + None, + None, + )), command: &["echo".into(), "OK".into()], ..test_config() }, diff --git a/crates/openshell-core/src/gpu.rs b/crates/openshell-core/src/gpu.rs index f5ff67cd35..749a477487 100644 --- a/crates/openshell-core/src/gpu.rs +++ b/crates/openshell-core/src/gpu.rs @@ -12,7 +12,7 @@ use crate::config::CDI_GPU_DEVICE_ALL; use crate::proto::ResourceRequirements as SandboxResourceRequirements; use crate::proto::compute::v1::{ GpuResourceRequirements as DriverGpuResourceRequirements, - ResourceRequirements as DriverResourceRequirements, + ResourceRequirements as DriverSandboxResourceRequirements, }; /// Return whether sandbox resource requirements request a GPU. @@ -53,7 +53,7 @@ pub fn effective_driver_gpu_count( /// Return the requested compute-driver GPU requirements, if present. #[must_use] pub fn driver_gpu_requirements( - resources: Option<&DriverResourceRequirements>, + resources: Option<&DriverSandboxResourceRequirements>, ) -> Option<&DriverGpuResourceRequirements> { resources.and_then(|resources| resources.gpu.as_ref()) } diff --git a/crates/openshell-core/src/lib.rs b/crates/openshell-core/src/lib.rs index 85195f2040..b6579f4af5 100644 --- a/crates/openshell-core/src/lib.rs +++ b/crates/openshell-core/src/lib.rs @@ -43,6 +43,7 @@ pub mod proposals; pub mod proto; pub mod proto_struct; pub mod provider_credentials; +pub mod quantity; pub mod sandbox_env; pub mod secrets; pub mod settings; diff --git a/crates/openshell-core/src/quantity.rs b/crates/openshell-core/src/quantity.rs new file mode 100644 index 0000000000..57997e32e9 --- /dev/null +++ b/crates/openshell-core/src/quantity.rs @@ -0,0 +1,121 @@ +// SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +// SPDX-License-Identifier: Apache-2.0 + +//! Shared Kubernetes-style CPU and memory quantity validation. +//! +//! `field_name` identifies the field in error messages (e.g. `--cpu` for the +//! CLI or `spec.resource_requirements.cpu.limit` for the gateway), so both +//! callers can present the same validation errors in their own idiom. + +/// Validate a Kubernetes-style CPU quantity string (e.g. "500m", "2", "0.5"). +/// +/// # Errors +/// Returns a human-readable error message when the value is empty, +/// malformed, or not greater than zero. +pub fn validate_cpu_quantity(value: &str, field_name: &str) -> Result<(), String> { + let value = value.trim(); + if value.is_empty() { + return Err(format!("{field_name} must not be empty")); + } + + if let Some(millicores) = value.strip_suffix('m') { + if millicores.is_empty() || !millicores.bytes().all(|b| b.is_ascii_digit()) { + return Err(format!( + "invalid {field_name} value '{value}': expected positive cores or millicores, for example 2, 0.5, or 500m" + )); + } + let millicores = millicores.parse::().map_err(|_| { + format!( + "invalid {field_name} value '{value}': expected positive cores or millicores, for example 2, 0.5, or 500m" + ) + })?; + if millicores == 0 { + return Err(format!("{field_name} must be greater than zero")); + } + return Ok(()); + } + + let cores = value.parse::().map_err(|_| { + format!( + "invalid {field_name} value '{value}': expected positive cores or millicores, for example 2, 0.5, or 500m" + ) + })?; + if !cores.is_finite() || cores <= 0.0 { + return Err(format!("{field_name} must be greater than zero")); + } + Ok(()) +} + +/// Validate a Kubernetes-style memory quantity string (e.g. "512Mi", "4Gi", "8G"). +/// +/// # Errors +/// Returns a human-readable error message when the value is empty, +/// malformed, or not greater than zero. +pub fn validate_memory_quantity(value: &str, field_name: &str) -> Result<(), String> { + let value = value.trim(); + if value.is_empty() { + return Err(format!("{field_name} must not be empty")); + } + + let number_end = value + .find(|ch: char| !ch.is_ascii_digit()) + .unwrap_or(value.len()); + let (number, suffix) = value.split_at(number_end); + if number.is_empty() + || !matches!( + suffix, + "" | "Ki" | "Mi" | "Gi" | "Ti" | "Pi" | "Ei" | "K" | "M" | "G" | "T" | "P" | "E" + ) + { + return Err(format!( + "invalid {field_name} value '{value}': expected positive bytes or a quantity such as 512Mi, 4Gi, or 8G" + )); + } + + let amount = number.parse::().map_err(|_| { + format!( + "invalid {field_name} value '{value}': expected positive bytes or a quantity such as 512Mi, 4Gi, or 8G" + ) + })?; + if amount == 0 { + return Err(format!("{field_name} must be greater than zero")); + } + Ok(()) +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn validate_cpu_quantity_accepts_cores_and_millicores() { + assert!(validate_cpu_quantity("2", "--cpu").is_ok()); + assert!(validate_cpu_quantity("0.5", "--cpu").is_ok()); + assert!(validate_cpu_quantity("500m", "--cpu").is_ok()); + } + + #[test] + fn validate_cpu_quantity_rejects_zero_and_malformed() { + assert!(validate_cpu_quantity("", "--cpu").is_err()); + assert!(validate_cpu_quantity("0", "--cpu").is_err()); + assert!(validate_cpu_quantity("0m", "--cpu").is_err()); + assert!(validate_cpu_quantity("abc", "--cpu").is_err()); + assert!(validate_cpu_quantity("-1", "--cpu").is_err()); + } + + #[test] + fn validate_memory_quantity_accepts_known_suffixes() { + assert!(validate_memory_quantity("512Mi", "--memory").is_ok()); + assert!(validate_memory_quantity("4Gi", "--memory").is_ok()); + assert!(validate_memory_quantity("8G", "--memory").is_ok()); + assert!(validate_memory_quantity("1024", "--memory").is_ok()); + } + + #[test] + fn validate_memory_quantity_rejects_zero_and_malformed() { + assert!(validate_memory_quantity("", "--memory").is_err()); + assert!(validate_memory_quantity("0Gi", "--memory").is_err()); + assert!(validate_memory_quantity("4Xi", "--memory").is_err()); + assert!(validate_memory_quantity("Gi", "--memory").is_err()); + } +} diff --git a/crates/openshell-driver-docker/src/lib.rs b/crates/openshell-driver-docker/src/lib.rs index df5aee4750..fd3baabe3a 100644 --- a/crates/openshell-driver-docker/src/lib.rs +++ b/crates/openshell-driver-docker/src/lib.rs @@ -45,8 +45,8 @@ use openshell_core::proto::compute::v1::{ GetCapabilitiesRequest, GetCapabilitiesResponse, GetGatewayListenerRequirementsRequest, GetGatewayListenerRequirementsResponse, GetSandboxRequest, GetSandboxResponse, GpuResourceCapabilities, GpuResourceRequirements, ListSandboxesRequest, ListSandboxesResponse, - MemoryResourceCapabilities, ResourceCapabilities, StartSandboxRequest, StartSandboxResponse, - StopSandboxRequest, StopSandboxResponse, ValidateSandboxCreateRequest, + MemoryResourceCapabilities, ResourceCapabilities, ResourceRequirements, StartSandboxRequest, + StartSandboxResponse, StopSandboxRequest, StopSandboxResponse, ValidateSandboxCreateRequest, ValidateSandboxCreateResponse, WatchSandboxesDeletedEvent, WatchSandboxesEvent, WatchSandboxesPlatformEvent, WatchSandboxesRequest, WatchSandboxesSandboxEvent, compute_driver_server::ComputeDriver, gateway_listener_requirement::Selector, @@ -631,7 +631,7 @@ impl DockerComputeDriver { .ok_or_else(|| Status::invalid_argument("sandbox.spec.template is required"))?; Self::validate_sandbox_template_base(template)?; - let _ = docker_resource_limits(template)?; + let _ = docker_resource_limits(spec.resource_requirements.as_ref())?; let driver_config = DockerSandboxDriverConfig::from_template(template).map_err(Status::invalid_argument)?; validate_docker_driver_mounts(&driver_config.mounts, config.enable_bind_mounts)?; @@ -2959,7 +2959,7 @@ fn build_container_create_body_for_image( .template .as_ref() .ok_or_else(|| Status::invalid_argument("sandbox.spec.template is required"))?; - let resource_limits = docker_resource_limits(template)?; + let resource_limits = docker_resource_limits(spec.resource_requirements.as_ref())?; let workspace_root = driver_mounts::resolve_oci_workspace_root(&image.working_dir) .map_err(Status::failed_precondition)?; driver_mounts::validate_workspace_control_path(&workspace_root, &config.ssh_socket_path) @@ -3323,26 +3323,20 @@ fn docker_bridge_gateway_ip( } fn docker_resource_limits( - template: &DriverSandboxTemplate, + resources: Option<&ResourceRequirements>, ) -> Result { - let Some(resources) = template.resources.as_ref() else { + let Some(resources) = resources else { return Ok(DockerResourceLimits::default()); }; - if !resources.cpu_request.trim().is_empty() { - return Err(Status::failed_precondition( - "docker compute driver does not support resources.requests.cpu", - )); - } - if !resources.memory_request.trim().is_empty() { - return Err(Status::failed_precondition( - "docker compute driver does not support resources.requests.memory", - )); - } - Ok(DockerResourceLimits { - nano_cpus: parse_cpu_limit(&resources.cpu_limit)?, - memory_bytes: parse_memory_limit(&resources.memory_limit)?, + nano_cpus: parse_cpu_limit(resources.cpu.as_ref().map_or("", |cpu| cpu.limit.as_str()))?, + memory_bytes: parse_memory_limit( + resources + .memory + .as_ref() + .map_or("", |memory| memory.limit.as_str()), + )?, }) } @@ -3377,12 +3371,12 @@ fn parse_cpu_limit(value: &str) -> Result, Status> { if let Some(millicores) = value.strip_suffix('m') { let millicores = millicores.parse::().map_err(|_| { Status::failed_precondition(format!( - "invalid docker cpu_limit '{value}'; expected an integer or millicore quantity", + "invalid docker cpu.limit '{value}'; expected an integer or millicore quantity", )) })?; if millicores <= 0 { return Err(Status::failed_precondition( - "docker cpu_limit must be greater than zero", + "docker cpu.limit must be greater than zero", )); } return Ok(Some(millicores.saturating_mul(1_000_000))); @@ -3390,12 +3384,12 @@ fn parse_cpu_limit(value: &str) -> Result, Status> { let cores = value.parse::().map_err(|_| { Status::failed_precondition(format!( - "invalid docker cpu_limit '{value}'; expected an integer or millicore quantity", + "invalid docker cpu.limit '{value}'; expected an integer or millicore quantity", )) })?; if !cores.is_finite() || cores <= 0.0 { return Err(Status::failed_precondition( - "docker cpu_limit must be greater than zero", + "docker cpu.limit must be greater than zero", )); } @@ -3415,12 +3409,12 @@ fn parse_memory_limit(value: &str) -> Result, Status> { let (number, suffix) = value.split_at(number_end); let amount = number.parse::().map_err(|_| { Status::failed_precondition(format!( - "invalid docker memory_limit '{value}'; expected a Kubernetes-style quantity", + "invalid docker memory.limit '{value}'; expected a Kubernetes-style quantity", )) })?; if !amount.is_finite() || amount <= 0.0 { return Err(Status::failed_precondition( - "docker memory_limit must be greater than zero", + "docker memory.limit must be greater than zero", )); } @@ -3440,7 +3434,7 @@ fn parse_memory_limit(value: &str) -> Result, Status> { "E" => 1000_f64.powi(6), _ => { return Err(Status::failed_precondition(format!( - "invalid docker memory_limit suffix '{suffix}'", + "invalid docker memory.limit suffix '{suffix}'", ))); } }; diff --git a/crates/openshell-driver-docker/src/tests.rs b/crates/openshell-driver-docker/src/tests.rs index aff5ba17f8..e29ce6baec 100644 --- a/crates/openshell-driver-docker/src/tests.rs +++ b/crates/openshell-driver-docker/src/tests.rs @@ -13,9 +13,9 @@ use openshell_core::progress::{ PROGRESS_STEP_STARTING_SANDBOX, }; use openshell_core::proto::compute::v1::{ - DriverResourceRequirements, DriverSandboxSpec, DriverSandboxTemplate, - GetGatewayListenerRequirementsRequest, GpuResourceRequirements, ResourceRequirements, - gateway_listener_requirement::Selector, + CpuResourceRequirements, DriverSandboxSpec, DriverSandboxTemplate, + GetGatewayListenerRequirementsRequest, GpuResourceRequirements, MemoryResourceRequirements, + ResourceRequirements, gateway_listener_requirement::Selector, }; use std::fs; use std::net::{IpAddr, Ipv4Addr, SocketAddr}; @@ -89,6 +89,20 @@ fn list_string_driver_config(field: &str, values: &[&str]) -> prost_types::Struc fn gpu_resources(count: Option) -> ResourceRequirements { ResourceRequirements { gpu: Some(GpuResourceRequirements { count }), + cpu: None, + memory: None, + } +} + +fn cpu_memory_resources(cpu: Option<&str>, memory: Option<&str>) -> ResourceRequirements { + ResourceRequirements { + gpu: None, + cpu: cpu.map(|limit| CpuResourceRequirements { + limit: limit.to_string(), + }), + memory: memory.map(|limit| MemoryResourceRequirements { + limit: limit.to_string(), + }), } } @@ -1165,43 +1179,11 @@ fn parse_memory_limit_supports_binary_quantities() { assert!(parse_memory_limit("12XB").is_err()); } -#[test] -fn docker_resource_limits_rejects_requests() { - let template = DriverSandboxTemplate { - image: "img".to_string(), - agent_socket_path: String::new(), - labels: HashMap::new(), - environment: HashMap::new(), - resources: Some(DriverResourceRequirements { - cpu_request: "250m".to_string(), - cpu_limit: String::new(), - memory_request: String::new(), - memory_limit: String::new(), - }), - ..Default::default() - }; - - let err = docker_resource_limits(&template).unwrap_err(); - assert_eq!(err.code(), tonic::Code::FailedPrecondition); - assert!(err.message().contains("resources.requests.cpu")); -} - #[test] fn docker_resource_limits_applies_cpu_and_memory_limits() { - let template = DriverSandboxTemplate { - image: "img".to_string(), - agent_socket_path: String::new(), - labels: HashMap::new(), - environment: HashMap::new(), - resources: Some(DriverResourceRequirements { - cpu_limit: "500m".to_string(), - memory_limit: "2Gi".to_string(), - ..Default::default() - }), - ..Default::default() - }; + let resources = cpu_memory_resources(Some("500m"), Some("2Gi")); - let limits = docker_resource_limits(&template).unwrap(); + let limits = docker_resource_limits(Some(&resources)).unwrap(); assert_eq!(limits.nano_cpus, Some(500_000_000)); assert_eq!(limits.memory_bytes, Some(2_147_483_648)); } diff --git a/crates/openshell-driver-kubernetes/src/driver.rs b/crates/openshell-driver-kubernetes/src/driver.rs index 3a19917384..e97ce6e421 100644 --- a/crates/openshell-driver-kubernetes/src/driver.rs +++ b/crates/openshell-driver-kubernetes/src/driver.rs @@ -49,8 +49,8 @@ use openshell_core::proto::compute::v1::{ DriverSandboxSpec as SandboxSpec, DriverSandboxStatus as SandboxStatus, DriverSandboxTemplate as SandboxTemplate, GetCapabilitiesResponse, GpuResourceCapabilities, GpuResourceRequirements, MemoryResourceCapabilities, ResourceCapabilities, - WatchSandboxesDeletedEvent, WatchSandboxesEvent, WatchSandboxesPlatformEvent, - WatchSandboxesSandboxEvent, watch_sandboxes_event, + ResourceRequirements, WatchSandboxesDeletedEvent, WatchSandboxesEvent, + WatchSandboxesPlatformEvent, WatchSandboxesSandboxEvent, watch_sandboxes_event, }; use openshell_core::proto_struct::{struct_to_json_object, value_to_json}; use serde::Deserialize; @@ -3709,7 +3709,7 @@ fn sandbox_to_k8s_spec( "podTemplate".to_string(), sandbox_template_to_k8s_with_validated_config( template, - driver_gpu_requirements(spec.resource_requirements.as_ref()), + spec.resource_requirements.as_ref(), &pod_env, Some(spec), &driver_config, @@ -3743,7 +3743,7 @@ fn sandbox_to_k8s_spec( "podTemplate".to_string(), sandbox_template_to_k8s_with_validated_config( &SandboxTemplate::default(), - driver_gpu_requirements(spec.and_then(|s| s.resource_requirements.as_ref())), + spec.and_then(|s| s.resource_requirements.as_ref()), &pod_env, spec, &driver_config, @@ -3766,12 +3766,16 @@ fn sandbox_template_to_k8s( inject_workspace: bool, params: &SandboxPodParams<'_>, ) -> serde_json::Value { - let gpu_requirements = gpu.then_some(GpuResourceRequirements { count: None }); + let resource_requirements = gpu.then_some(ResourceRequirements { + gpu: Some(GpuResourceRequirements { count: None }), + cpu: None, + memory: None, + }); let driver_config = KubernetesSandboxDriverConfig::from_template(template) .expect("test Kubernetes driver_config should be valid"); sandbox_template_to_k8s_with_validated_config( template, - gpu_requirements.as_ref(), + resource_requirements.as_ref(), spec_environment, None, &driver_config, @@ -3788,11 +3792,37 @@ fn sandbox_template_to_k8s_with_gpu_requirements( inject_workspace: bool, params: &SandboxPodParams<'_>, ) -> serde_json::Value { + let resource_requirements = gpu_requirements.map(|gpu| ResourceRequirements { + gpu: Some(*gpu), + cpu: None, + memory: None, + }); let driver_config = KubernetesSandboxDriverConfig::from_template(template) .expect("test Kubernetes driver_config should be valid"); sandbox_template_to_k8s_with_validated_config( template, - gpu_requirements, + resource_requirements.as_ref(), + spec_environment, + None, + &driver_config, + inject_workspace, + params, + ) +} + +#[cfg(test)] +fn sandbox_template_to_k8s_with_resource_requirements( + template: &SandboxTemplate, + resource_requirements: Option<&ResourceRequirements>, + spec_environment: &std::collections::HashMap, + inject_workspace: bool, + params: &SandboxPodParams<'_>, +) -> serde_json::Value { + let driver_config = KubernetesSandboxDriverConfig::from_template(template) + .expect("test Kubernetes driver_config should be valid"); + sandbox_template_to_k8s_with_validated_config( + template, + resource_requirements, spec_environment, None, &driver_config, @@ -3803,13 +3833,14 @@ fn sandbox_template_to_k8s_with_gpu_requirements( fn sandbox_template_to_k8s_with_validated_config( template: &SandboxTemplate, - gpu_requirements: Option<&GpuResourceRequirements>, + resource_requirements: Option<&ResourceRequirements>, spec_environment: &std::collections::HashMap, sandbox_spec: Option<&openshell_core::proto::compute::v1::DriverSandboxSpec>, driver_config: &KubernetesSandboxDriverConfig, inject_workspace: bool, params: &SandboxPodParams<'_>, ) -> serde_json::Value { + let gpu_requirements = driver_gpu_requirements(resource_requirements); let mut metadata = serde_json::Map::new(); let mut pod_labels = template .labels @@ -4012,7 +4043,7 @@ fn sandbox_template_to_k8s_with_validated_config( serde_json::Value::Array(volume_mounts), ); - if let Some(resources) = container_resources(template, gpu_requirements) { + if let Some(resources) = container_resources(template, resource_requirements) { container.insert("resources".to_string(), resources); } apply_agent_driver_resources(&mut container, &driver_config.containers.agent.resources); @@ -4250,16 +4281,18 @@ fn app_armor_profile_to_k8s(profile: &AppArmorProfile) -> serde_json::Value { fn container_resources( template: &SandboxTemplate, - gpu_requirements: Option<&GpuResourceRequirements>, + resource_requirements: Option<&ResourceRequirements>, ) -> Option { + let gpu_requirements = driver_gpu_requirements(resource_requirements); + // Start from the raw resources passthrough in platform_config (preserves // custom resource types like GPU limits that users set via the public API - // Struct), then overlay the typed DriverResourceRequirements on top. + // Struct), then overlay the typed resource requirements on top. let mut resources = platform_config_struct(template, "resources_raw").unwrap_or_else(|| serde_json::json!({})); - // Overlay typed CPU/memory from DriverResourceRequirements. - if let Some(ref req) = template.resources { + // Overlay typed CPU/memory from ResourceRequirements. + if let Some(requirements) = resource_requirements { let obj = resources.as_object_mut().unwrap(); let mut apply = |section: &str, key: &str, value: &str| { if !value.is_empty() { @@ -4267,21 +4300,14 @@ fn container_resources( sec[key] = serde_json::json!(value); } }; - apply("limits", "cpu", &req.cpu_limit); - apply("limits", "memory", &req.memory_limit); - - let cpu_request = if req.cpu_request.is_empty() { - &req.cpu_limit - } else { - &req.cpu_request - }; - let memory_request = if req.memory_request.is_empty() { - &req.memory_limit - } else { - &req.memory_request - }; - apply("requests", "cpu", cpu_request); - apply("requests", "memory", memory_request); + if let Some(cpu) = requirements.cpu.as_ref() { + apply("limits", "cpu", &cpu.limit); + apply("requests", "cpu", &cpu.limit); + } + if let Some(memory) = requirements.memory.as_ref() { + apply("limits", "memory", &memory.limit); + apply("requests", "memory", &memory.limit); + } } if let Some(gpu) = gpu_requirements { @@ -4947,7 +4973,10 @@ mod tests { PROGRESS_ACTIVE_DETAIL_KEY, PROGRESS_ACTIVE_STEP_KEY, PROGRESS_COMPLETE_LABEL_KEY, PROGRESS_COMPLETE_STEP_KEY, }; - use openshell_core::proto::compute::v1::{GpuResourceRequirements, ResourceRequirements}; + use openshell_core::proto::compute::v1::{ + CpuResourceRequirements, GpuResourceRequirements, MemoryResourceRequirements, + ResourceRequirements, + }; use prost_types::{Struct, Value, value::Kind}; use std::collections::BTreeSet; @@ -6137,6 +6166,8 @@ mod tests { spec: Some(SandboxSpec { resource_requirements: Some(ResourceRequirements { gpu: Some(GpuResourceRequirements { count: Some(0) }), + cpu: None, + memory: None, }), ..SandboxSpec::default() }), @@ -7217,22 +7248,26 @@ mod tests { } #[test] - fn gpu_sandbox_preserves_existing_resource_limits() { - use openshell_core::proto::compute::v1::DriverResourceRequirements; - let template = SandboxTemplate { - resources: Some(DriverResourceRequirements { - cpu_limit: "2".to_string(), - ..Default::default() + fn gpu_sandbox_preserves_typed_cpu_resource_limits() { + let template = SandboxTemplate::default(); + let resource_requirements = ResourceRequirements { + gpu: Some(GpuResourceRequirements { count: None }), + cpu: Some(CpuResourceRequirements { + limit: "2".to_string(), }), - ..SandboxTemplate::default() + memory: None, }; let pod_template = { let params = SandboxPodParams::default(); - sandbox_template_to_k8s( + let driver_config = KubernetesSandboxDriverConfig::from_template(&template) + .expect("test Kubernetes driver_config should be valid"); + sandbox_template_to_k8s_with_validated_config( &template, - true, + Some(&resource_requirements), &std::collections::HashMap::new(), + None, + &driver_config, true, ¶ms, ) @@ -7245,21 +7280,22 @@ mod tests { #[test] fn cpu_and_memory_limits_are_mirrored_to_requests() { - use openshell_core::proto::compute::v1::DriverResourceRequirements; - let template = SandboxTemplate { - resources: Some(DriverResourceRequirements { - cpu_limit: "500m".to_string(), - memory_limit: "2Gi".to_string(), - ..Default::default() + let template = SandboxTemplate::default(); + let resource_requirements = ResourceRequirements { + gpu: None, + cpu: Some(CpuResourceRequirements { + limit: "500m".to_string(), + }), + memory: Some(MemoryResourceRequirements { + limit: "2Gi".to_string(), }), - ..SandboxTemplate::default() }; let pod_template = { let params = SandboxPodParams::default(); - sandbox_template_to_k8s( + sandbox_template_to_k8s_with_resource_requirements( &template, - false, + Some(&resource_requirements), &std::collections::HashMap::new(), true, ¶ms, diff --git a/crates/openshell-driver-mxc/src/driver.rs b/crates/openshell-driver-mxc/src/driver.rs index 62f134205b..d6b1664d71 100644 --- a/crates/openshell-driver-mxc/src/driver.rs +++ b/crates/openshell-driver-mxc/src/driver.rs @@ -308,6 +308,17 @@ impl MxcComputeBackend { "mxc driver does not support GPU sandboxes", )); } + if spec + .resource_requirements + .as_ref() + .is_some_and(|requirements| { + requirements.cpu.is_some() || requirements.memory.is_some() + }) + { + return Err(tonic::Status::failed_precondition( + "mxc driver does not support spec.resource_requirements.cpu or spec.resource_requirements.memory", + )); + } if let Some(tmpl) = &spec.template && !tmpl.agent_socket_path.is_empty() { diff --git a/crates/openshell-driver-podman/src/container.rs b/crates/openshell-driver-podman/src/container.rs index a81ee13e1d..8504ac69d7 100644 --- a/crates/openshell-driver-podman/src/container.rs +++ b/crates/openshell-driver-podman/src/container.rs @@ -8,7 +8,9 @@ use openshell_core::ComputeDriverError; use openshell_core::driver_mounts::SelinuxLabel; #[cfg(test)] use openshell_core::gpu::{driver_gpu_requirements, validate_specific_gpu_device_request}; -use openshell_core::proto::compute::v1::{DriverSandbox, DriverSandboxTemplate}; +use openshell_core::proto::compute::v1::{ + DriverSandbox, DriverSandboxTemplate, ResourceRequirements, +}; use openshell_core::proto_struct::deserialize_optional_non_empty_string_list; use openshell_core::{driver_mounts, proto_struct}; use serde::Serialize; @@ -628,32 +630,57 @@ fn build_labels(sandbox: &DriverSandbox) -> BTreeMap { labels } -/// Parse resource limits from the sandbox template, falling back to defaults. -fn build_resource_limits(sandbox: &DriverSandbox, config: &PodmanComputeConfig) -> ResourceLimits { +/// Parse resource limits from typed sandbox requirements, falling back to defaults. +fn build_resource_limits( + sandbox: &DriverSandbox, + config: &PodmanComputeConfig, +) -> Result { let resources = sandbox .spec .as_ref() - .and_then(|s| s.template.as_ref()) - .and_then(|t| t.resources.as_ref()); + .and_then(|s| s.resource_requirements.as_ref()); - let cpu_micros = resources - .filter(|r| !r.cpu_limit.is_empty()) - .and_then(|r| parse_cpu_to_microseconds(&r.cpu_limit)) - .unwrap_or(DEFAULT_CPU_QUOTA); + let cpu_micros = parse_podman_cpu_limit(resources)?.unwrap_or(DEFAULT_CPU_QUOTA); + let mem_bytes = parse_podman_memory_limit(resources)?.unwrap_or(DEFAULT_MEMORY_LIMIT); - let mem_bytes = resources - .filter(|r| !r.memory_limit.is_empty()) - .and_then(|r| parse_memory_to_bytes(&r.memory_limit)) - .unwrap_or(DEFAULT_MEMORY_LIMIT); - - ResourceLimits { + Ok(ResourceLimits { cpu: CpuLimits { quota: cpu_micros, period: DEFAULT_CPU_PERIOD, }, memory: MemoryLimits { limit: mem_bytes }, pids_limit: podman_pids_limit(config.sandbox_pids_limit), - } + }) +} + +fn parse_podman_cpu_limit( + resources: Option<&ResourceRequirements>, +) -> Result, ComputeDriverError> { + let Some(cpu) = resources.and_then(|resources| resources.cpu.as_ref()) else { + return Ok(None); + }; + parse_cpu_to_microseconds(&cpu.limit) + .map(Some) + .ok_or_else(|| { + ComputeDriverError::Precondition(format!( + "invalid podman cpu limit '{}'; expected positive cores or millicores", + cpu.limit + )) + }) +} + +fn parse_podman_memory_limit( + resources: Option<&ResourceRequirements>, +) -> Result, ComputeDriverError> { + let Some(memory) = resources.and_then(|resources| resources.memory.as_ref()) else { + return Ok(None); + }; + parse_memory_to_bytes(&memory.limit).map(Some).ok_or_else(|| { + ComputeDriverError::Precondition(format!( + "invalid podman memory limit '{}'; expected positive bytes or a Kubernetes-style quantity", + memory.limit + )) + }) } fn podman_pids_limit(value: i64) -> Option { @@ -1022,7 +1049,7 @@ pub fn build_container_spec_for_image( let env = build_env(sandbox, config, requested_image, oci_user); let labels = build_labels(sandbox); - let resource_limits = build_resource_limits(sandbox, config); + let resource_limits = build_resource_limits(sandbox, config)?; let user_mounts = podman_user_mounts(sandbox, config.enable_bind_mounts) .map_err(ComputeDriverError::InvalidArgument)?; if sandbox @@ -1491,7 +1518,10 @@ fn parse_memory_to_bytes(quantity: &str) -> Option { #[cfg(test)] mod tests { use super::*; - use openshell_core::proto::compute::v1::{GpuResourceRequirements, ResourceRequirements}; + use openshell_core::proto::compute::v1::{ + CpuResourceRequirements, GpuResourceRequirements, MemoryResourceRequirements, + ResourceRequirements, + }; static ENV_LOCK: std::sync::LazyLock> = std::sync::LazyLock::new(|| std::sync::Mutex::new(())); @@ -1507,6 +1537,8 @@ mod tests { fn gpu_resources(count: Option) -> ResourceRequirements { ResourceRequirements { gpu: Some(GpuResourceRequirements { count }), + cpu: None, + memory: None, } } @@ -1545,19 +1577,19 @@ mod tests { #[test] fn container_spec_applies_cpu_and_memory_limits() { - use openshell_core::proto::compute::v1::{ - DriverResourceRequirements, DriverSandboxSpec, DriverSandboxTemplate, - }; + use openshell_core::proto::compute::v1::{DriverSandboxSpec, DriverSandboxTemplate}; let mut sandbox = test_sandbox("test-id", "test-name"); sandbox.spec = Some(DriverSandboxSpec { - template: Some(DriverSandboxTemplate { - resources: Some(DriverResourceRequirements { - cpu_limit: "500m".to_string(), - memory_limit: "2Gi".to_string(), - ..Default::default() + template: Some(DriverSandboxTemplate::default()), + resource_requirements: Some(ResourceRequirements { + gpu: None, + cpu: Some(CpuResourceRequirements { + limit: "500m".to_string(), + }), + memory: Some(MemoryResourceRequirements { + limit: "2Gi".to_string(), }), - ..Default::default() }), ..Default::default() }); diff --git a/crates/openshell-driver-podman/src/driver.rs b/crates/openshell-driver-podman/src/driver.rs index 50eb014691..75b434b7e2 100644 --- a/crates/openshell-driver-podman/src/driver.rs +++ b/crates/openshell-driver-podman/src/driver.rs @@ -1667,6 +1667,8 @@ mod tests { fn gpu_resources(count: Option) -> ResourceRequirements { ResourceRequirements { gpu: Some(GpuResourceRequirements { count }), + cpu: None, + memory: None, } } diff --git a/crates/openshell-driver-vm/src/driver.rs b/crates/openshell-driver-vm/src/driver.rs index 896daa48a5..e2f481f9b8 100644 --- a/crates/openshell-driver-vm/src/driver.rs +++ b/crates/openshell-driver-vm/src/driver.rs @@ -4049,6 +4049,7 @@ fn validate_vm_sandbox(sandbox: &Sandbox, gpu_enabled: bool) -> Result<(), Statu if let Some(template) = spec.template.as_ref() { validate_vm_sandbox_template(template)?; } + validate_cpu_memory_request(spec)?; validate_gpu_request(sandbox, gpu_enabled)?; Ok(()) @@ -4069,6 +4070,22 @@ fn validate_vm_sandbox_template(template: &SandboxTemplate) -> Result<(), Status Ok(()) } +#[allow(clippy::result_large_err)] +fn validate_cpu_memory_request( + spec: &openshell_core::proto::compute::v1::DriverSandboxSpec, +) -> Result<(), Status> { + let resources = spec.resource_requirements.as_ref(); + if resources + .is_some_and(|requirements| requirements.cpu.is_some() || requirements.memory.is_some()) + { + return Err(Status::failed_precondition( + "vm sandboxes do not support spec.resource_requirements.cpu or spec.resource_requirements.memory yet; configure VM driver vcpus and mem_mib instead", + )); + } + + Ok(()) +} + #[allow(clippy::result_large_err)] fn validate_gpu_request(sandbox: &Sandbox, gpu_enabled: bool) -> Result<(), Status> { let spec = sandbox @@ -6577,8 +6594,9 @@ mod tests { PROGRESS_COMPLETE_STEP_KEY, }; use openshell_core::proto::compute::v1::{ - DriverSandboxSpec as SandboxSpec, DriverSandboxTemplate as SandboxTemplate, - GpuResourceRequirements, ResourceRequirements, + CpuResourceRequirements, DriverSandboxSpec as SandboxSpec, + DriverSandboxTemplate as SandboxTemplate, GpuResourceRequirements, + MemoryResourceRequirements, ResourceRequirements, }; use prost_types::{Struct, Value, value::Kind}; use std::fs; @@ -7248,6 +7266,8 @@ mod tests { fn gpu_resources(count: Option) -> ResourceRequirements { ResourceRequirements { gpu: Some(GpuResourceRequirements { count }), + cpu: None, + memory: None, } } @@ -7619,26 +7639,28 @@ mod tests { } #[test] - fn validate_vm_sandbox_accepts_template_resources_as_noop() { - use openshell_core::proto::compute::v1::DriverResourceRequirements; - + fn validate_vm_sandbox_rejects_typed_cpu_and_memory_resources() { let sandbox = Sandbox { id: "sandbox-123".to_string(), spec: Some(SandboxSpec { - template: Some(SandboxTemplate { - resources: Some(DriverResourceRequirements { - cpu_limit: "2".to_string(), - memory_limit: "4Gi".to_string(), - ..Default::default() + resource_requirements: Some(ResourceRequirements { + gpu: None, + cpu: Some(CpuResourceRequirements { + limit: "2".to_string(), + }), + memory: Some(MemoryResourceRequirements { + limit: "4Gi".to_string(), }), - ..Default::default() }), ..Default::default() }), ..Default::default() }; - validate_vm_sandbox(&sandbox, false) - .expect("template.resources should be accepted and ignored"); + let err = validate_vm_sandbox(&sandbox, false).expect_err( + "typed CPU/memory resources should be rejected until VM sizing is supported", + ); + assert_eq!(err.code(), Code::FailedPrecondition); + assert!(err.message().contains("spec.resource_requirements.cpu")); } #[test] diff --git a/crates/openshell-server/src/compute/mod.rs b/crates/openshell-server/src/compute/mod.rs index 2b11946a63..06088bc306 100644 --- a/crates/openshell-server/src/compute/mod.rs +++ b/crates/openshell-server/src/compute/mod.rs @@ -21,14 +21,15 @@ use futures::{Stream, StreamExt}; #[cfg(unix)] use hyper_util::rt::TokioIo; use openshell_core::proto::compute::v1::{ - AuthenticateSandboxRequest, CreateSandboxRequest, DeleteSandboxRequest, DeleteWorkspaceRequest, - DeleteWorkspaceResponse, DriverCondition, DriverPlatformEvent, DriverResourceRequirements, - DriverSandbox, DriverSandboxSpec, DriverSandboxStatus, DriverSandboxTemplate, - EnsureWorkspaceRequest, EnsureWorkspaceResponse, + AuthenticateSandboxRequest, CpuResourceRequirements as DriverCpuResourceRequirements, + CreateSandboxRequest, DeleteSandboxRequest, DeleteWorkspaceRequest, DeleteWorkspaceResponse, + DriverCondition, DriverPlatformEvent, DriverSandbox, DriverSandboxSpec, DriverSandboxStatus, + DriverSandboxTemplate, EnsureWorkspaceRequest, EnsureWorkspaceResponse, GatewayListenerRequirement as ProtoGatewayListenerRequirement, GetCapabilitiesRequest, GetGatewayListenerRequirementsRequest, GetGatewayListenerRequirementsResponse, GetSandboxRequest, GpuResourceRequirements as DriverGpuResourceRequirements, - ListSandboxesRequest, ResourceCapabilities as DriverResourceCapabilities, + ListSandboxesRequest, MemoryResourceRequirements as DriverMemoryResourceRequirements, + ResourceCapabilities as DriverResourceCapabilities, ResourceRequirements as DriverSandboxResourceRequirements, StartSandboxRequest, StopSandboxRequest, ValidateSandboxCreateRequest, WatchSandboxesEvent, WatchSandboxesRequest, compute_driver_client::ComputeDriverClient, compute_driver_server::ComputeDriver, @@ -3925,6 +3926,17 @@ fn driver_sandbox_spec_from_public( .gpu .as_ref() .map(|gpu| DriverGpuResourceRequirements { count: gpu.count }), + cpu: requirements + .cpu + .as_ref() + .map(|cpu| DriverCpuResourceRequirements { + limit: cpu.limit.clone(), + }), + memory: requirements.memory.as_ref().map(|memory| { + DriverMemoryResourceRequirements { + limit: memory.limit.clone(), + } + }), } }), sandbox_token: String::new(), @@ -3943,7 +3955,6 @@ fn driver_sandbox_template_from_public( agent_socket_path: template.agent_socket.clone(), labels: template.labels.clone(), environment: template.environment.clone(), - resources: extract_typed_resources(&template.resources), platform_config: build_platform_config(template), driver_config: select_driver_config(&template.driver_config, driver_name)?, user_namespaces: template.user_namespaces, @@ -4038,50 +4049,6 @@ fn select_driver_config( } } -/// Extract typed CPU/memory quantities from the public `resources` Struct. -/// -/// The public API exposes resources as an untyped `google.protobuf.Struct` -/// with the Kubernetes limits/requests shape. We pull out the well-known -/// keys into the typed `DriverResourceRequirements` message. -fn extract_typed_resources( - resources: &Option, -) -> Option { - fn get_quantity(s: &prost_types::Struct, section: &str, key: &str) -> String { - s.fields - .get(section) - .and_then(|v| match v.kind.as_ref() { - Some(prost_types::value::Kind::StructValue(inner)) => inner.fields.get(key), - _ => None, - }) - .and_then(|v| match v.kind.as_ref() { - Some(prost_types::value::Kind::StringValue(val)) => Some(val.clone()), - _ => None, - }) - .unwrap_or_default() - } - - let s = resources.as_ref()?; - - let req = DriverResourceRequirements { - cpu_request: get_quantity(s, "requests", "cpu"), - cpu_limit: get_quantity(s, "limits", "cpu"), - memory_request: get_quantity(s, "requests", "memory"), - memory_limit: get_quantity(s, "limits", "memory"), - }; - - // Return None when all fields are empty so drivers can distinguish - // "no resource requirements" from "zero requirements". - if req.cpu_request.is_empty() - && req.cpu_limit.is_empty() - && req.memory_request.is_empty() - && req.memory_limit.is_empty() - { - None - } else { - Some(req) - } -} - /// Build the opaque `platform_config` Struct from platform-specific public /// template fields (`runtime_class_name`, annotations) plus any resource fields /// beyond CPU/memory. @@ -4122,9 +4089,8 @@ fn build_platform_config(template: &SandboxTemplate) -> Option Option { - Some(ResourceRequirements { - gpu: Some(resources.gpu?), - }) -} - -fn template_resource_struct(resources: &SandboxResources) -> Option { - let mut limits = std::collections::BTreeMap::new(); - if !resources.cpu.is_empty() { - limits.insert( - "cpu".to_string(), - Value { - kind: Some(Kind::StringValue(resources.cpu.clone())), - }, - ); - } - if !resources.memory.is_empty() { - limits.insert( - "memory".to_string(), - Value { - kind: Some(Kind::StringValue(resources.memory.clone())), - }, - ); - } - if limits.is_empty() { - None - } else { - let mut fields = std::collections::BTreeMap::new(); - fields.insert( - "limits".to_string(), - Value { - kind: Some(Kind::StructValue(Struct { fields: limits })), - }, - ); - Some(Struct { fields }) - } -} - pub(super) async fn handle_get_sandbox( state: &Arc, request: Request, @@ -3096,8 +3055,8 @@ mod tests { }; use crate::provider_profile_sources::ProviderProfileSources; use openshell_core::GatewayProviderProfileSourceConfig; - use openshell_core::proto::GpuResourceRequirements; use openshell_core::proto::datamodel::v1::ObjectMeta; + use openshell_core::proto::{GpuResourceRequirements, ResourceRequirements}; async fn test_server_state_with_user_only_github_profile() -> Arc { let mut state = test_server_state().await; @@ -3172,6 +3131,8 @@ mod tests { policy: Some(openshell_core::proto::SandboxPolicy::default()), resource_requirements: Some(ResourceRequirements { gpu: Some(GpuResourceRequirements { count: Some(1) }), + cpu: None, + memory: None, }), ..SandboxSpec::default() }), @@ -3553,9 +3514,13 @@ mod tests { workload: Some(openshell_core::proto::SandboxWorkloadConfig { image: "registry.example.com/agent:latest".to_string(), environment: HashMap::from([("FEATURE_FLAG".to_string(), "on".to_string())]), - resources: Some(SandboxResources { - cpu: "2".to_string(), - memory: "4Gi".to_string(), + resources: Some(ResourceRequirements { + cpu: Some(openshell_core::proto::CpuResourceRequirements { + limit: "2".to_string(), + }), + memory: Some(openshell_core::proto::MemoryResourceRequirements { + limit: "4Gi".to_string(), + }), gpu: Some(GpuResourceRequirements { count: Some(1) }), }), }), @@ -3565,13 +3530,6 @@ mod tests { } } - fn proto_string_value(value: &Value) -> Option<&str> { - match value.kind.as_ref() { - Some(Kind::StringValue(value)) => Some(value.as_str()), - _ => None, - } - } - #[tokio::test] #[ignore = "flaky under concurrent test execution"] async fn watch_producer_releases_request_span_when_client_disconnects() { @@ -5335,27 +5293,22 @@ mod tests { let template = spec.template.expect("resolved inline template"); assert_eq!(template.image, "registry.example.com/agent:latest"); - let limits = template - .resources - .as_ref() - .and_then(|resources| resources.fields.get("limits")) - .and_then(|limits| limits.kind.as_ref()) - .and_then(|kind| match kind { - Kind::StructValue(value) => Some(&value.fields), - _ => None, - }) - .expect("resource limits"); - assert_eq!(limits.get("cpu").and_then(proto_string_value), Some("2")); + assert!(template.resources.is_none()); + let requirements = spec + .resource_requirements + .expect("portable resource requirements"); assert_eq!( - limits.get("memory").and_then(proto_string_value), - Some("4Gi") + requirements.cpu.as_ref().map(|cpu| cpu.limit.as_str()), + Some("2") ); assert_eq!( - spec.resource_requirements - .and_then(|requirements| requirements.gpu) - .and_then(|gpu| gpu.count), - Some(1) + requirements + .memory + .as_ref() + .map(|memory| memory.limit.as_str()), + Some("4Gi") ); + assert_eq!(requirements.gpu.and_then(|gpu| gpu.count), Some(1)); } #[tokio::test] diff --git a/proto/compute_driver.proto b/proto/compute_driver.proto index f9a19589f9..595caaccd9 100644 --- a/proto/compute_driver.proto +++ b/proto/compute_driver.proto @@ -221,6 +221,10 @@ message DriverSandboxSpec { message ResourceRequirements { // GPU requirements for the sandbox. Presence indicates a GPU request. GpuResourceRequirements gpu = 1; + // CPU requirements for the sandbox workload. + CpuResourceRequirements cpu = 2; + // Memory requirements for the sandbox workload. + MemoryResourceRequirements memory = 3; } // Driver GPU resource requirements. @@ -230,6 +234,18 @@ message GpuResourceRequirements { optional uint32 count = 1; } +// Driver CPU resource requirements. +message CpuResourceRequirements { + // CPU limit for the sandbox workload (e.g. "500m", "2"). + string limit = 1; +} + +// Driver memory resource requirements. +message MemoryResourceRequirements { + // Memory limit for the sandbox workload (e.g. "512Mi", "4Gi"). + string limit = 1; +} + // Driver-owned runtime template consumed by the compute platform. // // This message describes the sandbox workload in backend-neutral terms. @@ -246,8 +262,6 @@ message DriverSandboxTemplate { map labels = 4; // Additional environment variables injected into the sandbox runtime. map environment = 6; - // Typed compute-resource requirements for the sandbox workload. - DriverResourceRequirements resources = 10; // Opaque, platform-specific configuration passed through to the driver. // The gateway does not inspect this; each driver defines its own schema. // For the Kubernetes driver this carries fields such as runtimeClassName, @@ -261,22 +275,8 @@ message DriverSandboxTemplate { // map this portable intent to their compute platform; when unset, the // driver's configured default applies. optional bool user_namespaces = 13; -} - -// Typed compute-resource requirements. -// -// Values use Kubernetes-style quantity strings (e.g. "500m", "2", "4Gi") -// because they are a well-known, widely-adopted notation. Drivers for -// non-Kubernetes platforms must parse these strings into their native units. -message DriverResourceRequirements { - // Minimum CPU cores requested (e.g. "500m", "2"). - string cpu_request = 1; - // Maximum CPU cores allowed (e.g. "500m", "4"). - string cpu_limit = 2; - // Minimum memory requested (e.g. "256Mi", "4Gi"). - string memory_request = 3; - // Maximum memory allowed (e.g. "512Mi", "8Gi"). - string memory_limit = 4; + reserved 10; + reserved "resources"; } // Raw status observed directly from the compute platform. diff --git a/proto/openshell.proto b/proto/openshell.proto index 1308eb6a20..83a19d1a93 100644 --- a/proto/openshell.proto +++ b/proto/openshell.proto @@ -939,6 +939,10 @@ message SandboxSpec { message ResourceRequirements { // GPU requirements for the sandbox. Presence indicates a GPU request. GpuResourceRequirements gpu = 1; + // CPU requirements for the sandbox workload. + CpuResourceRequirements cpu = 2; + // Memory requirements for the sandbox workload. + MemoryResourceRequirements memory = 3; } // Public GPU resource requirements. @@ -948,6 +952,18 @@ message GpuResourceRequirements { optional uint32 count = 1; } +// Public CPU resource requirements. +message CpuResourceRequirements { + // CPU limit for the sandbox workload (e.g. "500m", "2"). + string limit = 1; +} + +// Public memory resource requirements. +message MemoryResourceRequirements { + // Memory limit for the sandbox workload (e.g. "512Mi", "4Gi"). + string limit = 1; +} + // Historical inline compute template mapped onto compute-driver template inputs. // // Despite its name, this is not a reusable named sandbox template resource. It @@ -967,7 +983,8 @@ message SandboxTemplate { map annotations = 5; // Additional environment variables injected by the template. map environment = 6; - // Platform-specific compute resource requirements and limits. + // Platform-specific resource passthrough. CPU and memory under + // limits/requests are rejected; use ResourceRequirements.cpu/memory instead. google.protobuf.Struct resources = 7; reserved 9; reserved "volume_claim_templates"; @@ -1012,18 +1029,7 @@ message SandboxWorkloadConfig { // Environment variables injected into the sandbox runtime. map environment = 2; // Portable resource requirements for sandboxes created from this workload. - SandboxResources resources = 3; -} - -message SandboxResources { - // Portable CPU quantity, for example "500m" or "2". - string cpu = 1; - // Portable memory quantity, for example "512Mi" or "2Gi". - string memory = 2; - // GPU requirements for the sandbox workload. Presence indicates a GPU - // request. When count is omitted, the request uses the selected driver's - // default GPU assignment behavior. - GpuResourceRequirements gpu = 3; + ResourceRequirements resources = 3; } message SandboxServiceLevel { From f09e982c778a5cfebb6097bb7df3f1a415a039d3 Mon Sep 17 00:00:00 2001 From: Evan Lezar Date: Wed, 9 Sep 2026 11:36:27 +0200 Subject: [PATCH 2/7] feat(sdk/rust)!: align portable resource requirements Expose the shared typed ResourceRequirements model for inline and reusable-template workloads and remove the template-only SandboxResources alias. BREAKING CHANGE: SandboxResources is removed; reusable workload templates now use ResourceRequirements with typed CPU and memory fields. Part of #2838 Signed-off-by: Evan Lezar --- crates/openshell-sdk/src/client.rs | 2 ++ crates/openshell-sdk/src/lib.rs | 3 ++- crates/openshell-sdk/src/raw.rs | 2 +- crates/openshell-sdk/src/types.rs | 13 +++++++++++-- crates/openshell-sdk/tests/client_mock.rs | 12 ++++++++---- 5 files changed, 24 insertions(+), 8 deletions(-) diff --git a/crates/openshell-sdk/src/client.rs b/crates/openshell-sdk/src/client.rs index b5486812f7..a499e02745 100644 --- a/crates/openshell-sdk/src/client.rs +++ b/crates/openshell-sdk/src/client.rs @@ -991,6 +991,8 @@ fn create_sandbox_request(spec: SandboxSpec) -> proto::CreateSandboxRequest { }); let resource_requirements = gpu.then_some(proto::ResourceRequirements { gpu: Some(proto::GpuResourceRequirements { count: None }), + cpu: None, + memory: None, }); proto::CreateSandboxRequest { spec: Some(proto::SandboxSpec { diff --git a/crates/openshell-sdk/src/lib.rs b/crates/openshell-sdk/src/lib.rs index 985c7ecc05..ad9624a589 100644 --- a/crates/openshell-sdk/src/lib.rs +++ b/crates/openshell-sdk/src/lib.rs @@ -47,7 +47,8 @@ pub use config::{AuthConfig, ClientConfig}; pub use error::SdkError; pub use refresh::{Refresh, RefreshError, RefreshedToken, TokenSource}; pub use types::{ - ExecOptions, ExecResult, Health, ListOptions, SandboxPhase, SandboxRef, SandboxResources, + CpuResourceRequirements, ExecOptions, ExecResult, GpuResourceRequirements, Health, ListOptions, + MemoryResourceRequirements, ResourceRequirements, SandboxPhase, SandboxRef, SandboxServiceLevel, SandboxSpec, SandboxStartup, SandboxTemplateCreateSpec, SandboxTemplateListOptions, SandboxWorkloadConfig, SandboxWorkloadTemplate, SandboxWorkloadTemplateProvenance, SandboxWorkloadTemplateSpec, ServiceStatus, WorkspaceRef, diff --git a/crates/openshell-sdk/src/raw.rs b/crates/openshell-sdk/src/raw.rs index 35d91f3325..8557c21a53 100644 --- a/crates/openshell-sdk/src/raw.rs +++ b/crates/openshell-sdk/src/raw.rs @@ -26,7 +26,7 @@ pub use openshell_core::proto::{ DeleteSandboxRequest, DeleteSandboxTemplateRequest, DeleteWorkspaceRequest, ExecSandboxRequest, GetSandboxRequest, GetSandboxTemplateRequest, GetWorkspaceRequest, HealthRequest, ListProvidersRequest, ListSandboxTemplatesRequest, ListSandboxesRequest, ListWorkspacesRequest, - Sandbox, SandboxPhase as ProtoSandboxPhase, SandboxResources, SandboxServiceLevel, + ResourceRequirements, Sandbox, SandboxPhase as ProtoSandboxPhase, SandboxServiceLevel, SandboxSpec as ProtoSandboxSpec, SandboxStartup, SandboxTemplate, SandboxTemplateResponse, SandboxWorkloadConfig, SandboxWorkloadTemplate, SandboxWorkloadTemplateProvenance, SandboxWorkloadTemplateSpec, ServiceStatus as ProtoServiceStatus, StartSandboxRequest, diff --git a/crates/openshell-sdk/src/types.rs b/crates/openshell-sdk/src/types.rs index db2944474b..6214954413 100644 --- a/crates/openshell-sdk/src/types.rs +++ b/crates/openshell-sdk/src/types.rs @@ -149,8 +149,17 @@ pub type SandboxWorkloadTemplateSpec = proto::SandboxWorkloadTemplateSpec; /// Portable sandbox workload configuration for template-backed sandboxes. pub type SandboxWorkloadConfig = proto::SandboxWorkloadConfig; -/// Portable resource requirements for template-backed sandboxes. -pub type SandboxResources = proto::SandboxResources; +/// Portable resource requirements shared by inline and template-backed sandboxes. +pub type ResourceRequirements = proto::ResourceRequirements; + +/// CPU resource requirements for a sandbox workload. +pub type CpuResourceRequirements = proto::CpuResourceRequirements; + +/// Memory resource requirements for a sandbox workload. +pub type MemoryResourceRequirements = proto::MemoryResourceRequirements; + +/// GPU resource requirements for a sandbox workload. +pub type GpuResourceRequirements = proto::GpuResourceRequirements; /// Desired service level for sandboxes created from a template. pub type SandboxServiceLevel = proto::SandboxServiceLevel; diff --git a/crates/openshell-sdk/tests/client_mock.rs b/crates/openshell-sdk/tests/client_mock.rs index 89cc68bf0f..1f22c1f092 100644 --- a/crates/openshell-sdk/tests/client_mock.rs +++ b/crates/openshell-sdk/tests/client_mock.rs @@ -125,10 +125,14 @@ fn workload_template_proto(name: &str, workspace: &str) -> proto::SandboxWorkloa workload: Some(proto::SandboxWorkloadConfig { image: format!("ghcr.io/test/{name}:latest"), environment: HashMap::new(), - resources: Some(proto::SandboxResources { - cpu: "1".to_string(), - memory: "512Mi".to_string(), - ..proto::SandboxResources::default() + resources: Some(proto::ResourceRequirements { + cpu: Some(proto::CpuResourceRequirements { + limit: "1".to_string(), + }), + memory: Some(proto::MemoryResourceRequirements { + limit: "512Mi".to_string(), + }), + ..Default::default() }), }), driver_config: None, From 569378da12daa5a623c4240543c59c8665ea2fde Mon Sep 17 00:00:00 2001 From: Evan Lezar Date: Wed, 9 Sep 2026 11:36:27 +0200 Subject: [PATCH 3/7] feat(sdk/go)!: align portable resource requirements Use ResourceRequirements for both inline and reusable-template sandbox workloads, update deep-copy converters and fakes, and regenerate the Go protobuf binding. BREAKING CHANGE: SandboxWorkloadConfig.Resources now uses ResourceRequirements, and the template-only SandboxResources and SandboxGPURequirements types are removed. Part of #2838 Signed-off-by: Evan Lezar --- sdk/go/openshell/v1/fake/sandbox.go | 59 +- .../v1/fake/sandbox_template_test.go | 47 +- .../v1/internal/converter/coverage_test.go | 10 - .../v1/internal/converter/sandbox.go | 95 +- .../v1/internal/converter/sandbox_test.go | 82 +- sdk/go/openshell/v1/sandbox.go | 12 + sdk/go/openshell/v1/sandbox_client.go | 2 +- sdk/go/openshell/v1/sandbox_client_test.go | 13 +- sdk/go/openshell/v1/sandbox_template.go | 6 - .../v1/sandbox_template_client_test.go | 14 +- sdk/go/openshell/v1/types/sandbox.go | 55 +- sdk/go/proto/openshellv1/openshell.pb.go | 2526 +++++++++-------- 12 files changed, 1510 insertions(+), 1411 deletions(-) diff --git a/sdk/go/openshell/v1/fake/sandbox.go b/sdk/go/openshell/v1/fake/sandbox.go index 5de3062d96..c5b0377f66 100644 --- a/sdk/go/openshell/v1/fake/sandbox.go +++ b/sdk/go/openshell/v1/fake/sandbox.go @@ -49,14 +49,37 @@ func copySandboxSpec(s types.SandboxSpec) types.SandboxSpec { t := copySandboxTemplate(*s.Template) s.Template = &t } - if s.GPUCount != nil { - v := *s.GPUCount - s.GPUCount = &v - } + s.ResourceRequirements = copyResourceRequirements(s.ResourceRequirements) s.Policy = copySandboxPolicy(s.Policy) return s } +// copyResourceRequirements returns a deep copy of a ResourceRequirements +// pointer. All nested pointer fields are duplicated to prevent aliasing. +func copyResourceRequirements(rr *types.ResourceRequirements) *types.ResourceRequirements { + if rr == nil { + return nil + } + cp := *rr + if rr.GPU != nil { + gpu := *rr.GPU + if rr.GPU.Count != nil { + v := *rr.GPU.Count + gpu.Count = &v + } + cp.GPU = &gpu + } + if rr.CPU != nil { + cpu := *rr.CPU + cp.CPU = &cpu + } + if rr.Memory != nil { + mem := *rr.Memory + cp.Memory = &mem + } + return &cp +} + // copySandboxPolicy returns a deep copy of a SandboxPolicy pointer. // All sub-policies, slices, and map entries are duplicated. func copySandboxPolicy(p *types.SandboxPolicy) *types.SandboxPolicy { @@ -391,7 +414,7 @@ func validateTemplateCreateSpec(spec *types.SandboxSpec) error { if spec == nil { return nil } - if spec.LogLevel != "" || len(spec.Environment) > 0 || spec.Template != nil || spec.GPU || spec.GPUCount != nil { + if spec.LogLevel != "" || len(spec.Environment) > 0 || spec.Template != nil || spec.ResourceRequirements != nil { return &types.StatusError{Code: types.ErrorInvalidArgument, Message: "template creates only allow policy, providers, command, and tty in spec"} } return nil @@ -407,36 +430,12 @@ func sandboxSpecFromWorkloadTemplate(template *types.SandboxWorkloadTemplate) ty spec.Environment = copyStringMap(workload.Environment) spec.Template = &types.SandboxTemplate{ Image: workload.Image, - Resources: sandboxTemplateResources(workload.Resources), DriverConfig: copyAnyMap(template.Spec.DriverConfig), } - if workload.Resources != nil && workload.Resources.GPU != nil { - spec.GPU = true - if workload.Resources.GPU.Count != nil { - count := *workload.Resources.GPU.Count - spec.GPUCount = &count - } - } + spec.ResourceRequirements = copyResourceRequirements(workload.Resources) return spec } -func sandboxTemplateResources(resources *types.SandboxResources) map[string]any { - if resources == nil { - return nil - } - limits := make(map[string]any) - if resources.CPU != "" { - limits["cpu"] = resources.CPU - } - if resources.Memory != "" { - limits["memory"] = resources.Memory - } - if len(limits) == 0 { - return nil - } - return map[string]any{"limits": limits} -} - // Get retrieves a sandbox by name. func (c *fakeSandboxClient) Get(_ context.Context, workspace, name string) (*types.Sandbox, error) { if c.closedFunc() { diff --git a/sdk/go/openshell/v1/fake/sandbox_template_test.go b/sdk/go/openshell/v1/fake/sandbox_template_test.go index 06a5187227..518c2c512e 100644 --- a/sdk/go/openshell/v1/fake/sandbox_template_test.go +++ b/sdk/go/openshell/v1/fake/sandbox_template_test.go @@ -224,10 +224,10 @@ func TestSandboxTemplate_CreateSandboxFromTemplateResolvesWorkloadAndGovernance( Workload: &types.SandboxWorkloadConfig{ Image: "registry.example.com/agent:latest", Environment: map[string]string{"FEATURE_FLAG": "on"}, - Resources: &types.SandboxResources{ - CPU: "2", - Memory: "4Gi", - GPU: &types.SandboxGPURequirements{Count: &gpuCount}, + Resources: &types.ResourceRequirements{ + CPU: &types.CPUResourceRequirements{Limit: "2"}, + Memory: &types.MemoryResourceRequirements{Limit: "4Gi"}, + GPU: &types.GPUResourceRequirements{Count: &gpuCount}, }, }, DriverConfig: map[string]any{ @@ -254,11 +254,16 @@ func TestSandboxTemplate_CreateSandboxFromTemplateResolvesWorkloadAndGovernance( assert.Equal(t, map[string]string{"FEATURE_FLAG": "on"}, created.Spec.Environment) require.NotNil(t, created.Spec.Template) assert.Equal(t, "registry.example.com/agent:latest", created.Spec.Template.Image) - assert.Equal(t, map[string]any{"limits": map[string]any{"cpu": "2", "memory": "4Gi"}}, created.Spec.Template.Resources) + assert.Nil(t, created.Spec.Template.Resources) assert.Equal(t, "kata-containers", created.Spec.Template.DriverConfig["kubernetes"].(map[string]any)["runtime_class_name"]) - assert.True(t, created.Spec.GPU) - require.NotNil(t, created.Spec.GPUCount) - assert.Equal(t, uint32(1), *created.Spec.GPUCount) + require.NotNil(t, created.Spec.ResourceRequirements) + require.NotNil(t, created.Spec.ResourceRequirements.CPU) + assert.Equal(t, "2", created.Spec.ResourceRequirements.CPU.Limit) + require.NotNil(t, created.Spec.ResourceRequirements.Memory) + assert.Equal(t, "4Gi", created.Spec.ResourceRequirements.Memory.Limit) + require.NotNil(t, created.Spec.ResourceRequirements.GPU) + require.NotNil(t, created.Spec.ResourceRequirements.GPU.Count) + assert.Equal(t, uint32(1), *created.Spec.ResourceRequirements.GPU.Count) assert.Equal(t, []string{"github"}, created.Spec.Providers) require.NotNil(t, created.Spec.Policy) assert.Equal(t, uint32(1), created.Spec.Policy.Version) @@ -288,11 +293,10 @@ func TestSandboxTemplate_CreateSandboxFromTemplateRejectsWorkloadOverrides(t *te "template": { Template: &types.SandboxTemplate{Image: "registry.example.com/override:latest"}, }, - "gpu_count": { - GPUCount: &gpuCount, - }, - "gpu": { - GPU: true, + "resources": { + ResourceRequirements: &types.ResourceRequirements{ + GPU: &types.GPUResourceRequirements{Count: &gpuCount}, + }, }, } @@ -318,8 +322,8 @@ func TestSandboxTemplate_DefaultGpuRequestRoundTripsTemplate(t *testing.T) { Name: "default-gpu", Spec: types.SandboxWorkloadTemplateSpec{ Workload: &types.SandboxWorkloadConfig{ - Resources: &types.SandboxResources{ - GPU: &types.SandboxGPURequirements{}, + Resources: &types.ResourceRequirements{ + GPU: &types.GPUResourceRequirements{}, }, }, }, @@ -345,8 +349,8 @@ func TestSandboxTemplate_CreateSandboxFromTemplatePreservesDefaultGPURequest(t * Spec: types.SandboxWorkloadTemplateSpec{ Workload: &types.SandboxWorkloadConfig{ Image: "registry.example.com/agent:latest", - Resources: &types.SandboxResources{ - GPU: &types.SandboxGPURequirements{}, + Resources: &types.ResourceRequirements{ + GPU: &types.GPUResourceRequirements{}, }, }, }, @@ -362,8 +366,9 @@ func TestSandboxTemplate_CreateSandboxFromTemplatePreservesDefaultGPURequest(t * ) require.NoError(t, err) - assert.True(t, created.Spec.GPU) - assert.Nil(t, created.Spec.GPUCount) + require.NotNil(t, created.Spec.ResourceRequirements) + require.NotNil(t, created.Spec.ResourceRequirements.GPU) + assert.Nil(t, created.Spec.ResourceRequirements.GPU.Count) } func TestSandboxTemplate_DeepCopy(t *testing.T) { @@ -448,8 +453,8 @@ func TestSandboxTemplate_CreateRejectsInvalidTemplate(t *testing.T) { Spec: types.SandboxWorkloadTemplateSpec{ Workload: &types.SandboxWorkloadConfig{ Image: "registry.example.com/agent:latest", - Resources: &types.SandboxResources{ - GPU: &types.SandboxGPURequirements{Count: &zeroGPUCount}, + Resources: &types.ResourceRequirements{ + GPU: &types.GPUResourceRequirements{Count: &zeroGPUCount}, }, }, }, diff --git a/sdk/go/openshell/v1/internal/converter/coverage_test.go b/sdk/go/openshell/v1/internal/converter/coverage_test.go index 16929f672c..8f1a8f3255 100644 --- a/sdk/go/openshell/v1/internal/converter/coverage_test.go +++ b/sdk/go/openshell/v1/internal/converter/coverage_test.go @@ -81,16 +81,6 @@ func TestConverterCoversAllProtoFields_SandboxWorkloadConfig(t *testing.T) { assertAllFieldsCovered(t, (&pb.SandboxWorkloadConfig{}).ProtoReflect().Descriptor(), handled, nil) } -func TestConverterCoversAllProtoFields_SandboxResources(t *testing.T) { - handled := fieldSet{ - "cpu": true, - "memory": true, - "gpu": true, - } - - assertAllFieldsCovered(t, (&pb.SandboxResources{}).ProtoReflect().Descriptor(), handled, nil) -} - func TestConverterCoversAllProtoFields_SandboxServiceLevel(t *testing.T) { handled := fieldSet{ "startup": true, diff --git a/sdk/go/openshell/v1/internal/converter/sandbox.go b/sdk/go/openshell/v1/internal/converter/sandbox.go index bf15f11059..e24035333c 100644 --- a/sdk/go/openshell/v1/internal/converter/sandbox.go +++ b/sdk/go/openshell/v1/internal/converter/sandbox.go @@ -81,12 +81,7 @@ func sandboxSpecFromProto(spec *pb.SandboxSpec) types.SandboxSpec { } if rr := spec.GetResourceRequirements(); rr != nil { - if gpu := rr.GetGpu(); gpu != nil { - result.GPU = true - if gpu.Count != nil { - result.GPUCount = gpu.Count - } - } + result.ResourceRequirements = resourceRequirementsFromProto(rr) } result.Command = CopyStringSlice(spec.GetCommand()) result.TTY = spec.GetTty() @@ -94,6 +89,25 @@ func sandboxSpecFromProto(spec *pb.SandboxSpec) types.SandboxSpec { return result } +// resourceRequirementsFromProto converts a proto ResourceRequirements to an +// SDK ResourceRequirements. +func resourceRequirementsFromProto(rr *pb.ResourceRequirements) *types.ResourceRequirements { + if rr == nil { + return nil + } + result := &types.ResourceRequirements{} + if gpu := rr.GetGpu(); gpu != nil { + result.GPU = &types.GPUResourceRequirements{Count: CopyUint32Ptr(gpu.Count)} + } + if cpu := rr.GetCpu(); cpu != nil { + result.CPU = &types.CPUResourceRequirements{Limit: cpu.GetLimit()} + } + if mem := rr.GetMemory(); mem != nil { + result.Memory = &types.MemoryResourceRequirements{Limit: mem.GetLimit()} + } + return result +} + func sandboxStatusFromProto(status *pb.SandboxStatus) types.SandboxStatus { result := types.SandboxStatus{ SandboxName: status.GetSandboxName(), @@ -231,12 +245,8 @@ func SandboxSpecToProto(spec *types.SandboxSpec) *pb.SandboxSpec { result.Template = tmpl } - if spec.GPU || spec.GPUCount != nil { - result.ResourceRequirements = &pb.ResourceRequirements{ - Gpu: &pb.GpuResourceRequirements{ - Count: spec.GPUCount, - }, - } + if spec.ResourceRequirements != nil { + result.ResourceRequirements = resourceRequirementsToProto(spec.ResourceRequirements) } result.Command = CopyStringSlice(spec.Command) @@ -245,6 +255,25 @@ func SandboxSpecToProto(spec *types.SandboxSpec) *pb.SandboxSpec { return result } +// resourceRequirementsToProto converts an SDK ResourceRequirements to a +// proto ResourceRequirements. +func resourceRequirementsToProto(rr *types.ResourceRequirements) *pb.ResourceRequirements { + if rr == nil { + return nil + } + result := &pb.ResourceRequirements{} + if rr.GPU != nil { + result.Gpu = &pb.GpuResourceRequirements{Count: CopyUint32Ptr(rr.GPU.Count)} + } + if rr.CPU != nil { + result.Cpu = &pb.CpuResourceRequirements{Limit: rr.CPU.Limit} + } + if rr.Memory != nil { + result.Memory = &pb.MemoryResourceRequirements{Limit: rr.Memory.Limit} + } + return result +} + // SandboxSpecToProtoChecked converts an SDK SandboxSpec and reports values // that protobuf Struct cannot represent instead of silently dropping them. func SandboxSpecToProtoChecked(spec *types.SandboxSpec) (*pb.SandboxSpec, error) { @@ -322,19 +351,7 @@ func SandboxWorkloadConfigFromProto(workload *pb.SandboxWorkloadConfig) *types.S return &types.SandboxWorkloadConfig{ Image: workload.GetImage(), Environment: CopyStringMap(workload.GetEnvironment()), - Resources: SandboxResourcesFromProto(workload.GetResources()), - } -} - -// SandboxResourcesFromProto converts portable resource requirements. -func SandboxResourcesFromProto(resources *pb.SandboxResources) *types.SandboxResources { - if resources == nil { - return nil - } - return &types.SandboxResources{ - CPU: resources.GetCpu(), - Memory: resources.GetMemory(), - GPU: sandboxResourceGpuFromProto(resources), + Resources: resourceRequirementsFromProto(workload.GetResources()), } } @@ -404,34 +421,8 @@ func SandboxWorkloadConfigToProto(workload *types.SandboxWorkloadConfig) *pb.San return &pb.SandboxWorkloadConfig{ Image: workload.Image, Environment: CopyStringMap(workload.Environment), - Resources: SandboxResourcesToProto(workload.Resources), - } -} - -// SandboxResourcesToProto converts portable resource requirements. -func SandboxResourcesToProto(resources *types.SandboxResources) *pb.SandboxResources { - if resources == nil { - return nil - } - return &pb.SandboxResources{ - Cpu: resources.CPU, - Memory: resources.Memory, - Gpu: sandboxResourceGpuToProto(resources), - } -} - -func sandboxResourceGpuToProto(resources *types.SandboxResources) *pb.GpuResourceRequirements { - if resources == nil || resources.GPU == nil { - return nil - } - return &pb.GpuResourceRequirements{Count: CopyUint32Ptr(resources.GPU.Count)} -} - -func sandboxResourceGpuFromProto(resources *pb.SandboxResources) *types.SandboxGPURequirements { - if resources == nil || resources.GetGpu() == nil { - return nil + Resources: resourceRequirementsToProto(workload.Resources), } - return &types.SandboxGPURequirements{Count: CopyUint32Ptr(resources.GetGpu().Count)} } // SandboxServiceLevelToProto converts template service-level hints. diff --git a/sdk/go/openshell/v1/internal/converter/sandbox_test.go b/sdk/go/openshell/v1/internal/converter/sandbox_test.go index 6087933616..0922936acb 100644 --- a/sdk/go/openshell/v1/internal/converter/sandbox_test.go +++ b/sdk/go/openshell/v1/internal/converter/sandbox_test.go @@ -58,6 +58,8 @@ func TestSandboxFromProto(t *testing.T) { Gpu: &pb.GpuResourceRequirements{ Count: &gpuCount, }, + Cpu: &pb.CpuResourceRequirements{Limit: "500m"}, + Memory: &pb.MemoryResourceRequirements{Limit: "2Gi"}, }, Command: []string{"/opt/agent", "--serve"}, Tty: false, @@ -107,9 +109,14 @@ func TestSandboxFromProto(t *testing.T) { assert.Equal(t, "debug", s.Spec.LogLevel) assert.Equal(t, map[string]string{"FOO": "bar"}, s.Spec.Environment) assert.Equal(t, []string{"claude", "github"}, s.Spec.Providers) - assert.True(t, s.Spec.GPU) - require.NotNil(t, s.Spec.GPUCount) - assert.Equal(t, uint32(2), *s.Spec.GPUCount) + require.NotNil(t, s.Spec.ResourceRequirements) + require.NotNil(t, s.Spec.ResourceRequirements.GPU) + require.NotNil(t, s.Spec.ResourceRequirements.GPU.Count) + assert.Equal(t, uint32(2), *s.Spec.ResourceRequirements.GPU.Count) + require.NotNil(t, s.Spec.ResourceRequirements.CPU) + assert.Equal(t, "500m", s.Spec.ResourceRequirements.CPU.Limit) + require.NotNil(t, s.Spec.ResourceRequirements.Memory) + assert.Equal(t, "2Gi", s.Spec.ResourceRequirements.Memory.Limit) assert.Equal(t, []string{"/opt/agent", "--serve"}, s.Spec.Command) assert.False(t, s.Spec.TTY) @@ -183,8 +190,7 @@ func TestSandboxFromProto_NilFields(t *testing.T) { assert.Empty(t, s.Name) assert.True(t, s.CreatedAt.IsZero()) assert.Nil(t, s.Spec.Template) - assert.False(t, s.Spec.GPU) - assert.Nil(t, s.Spec.GPUCount) + assert.Nil(t, s.Spec.ResourceRequirements) assert.Equal(t, v1.SandboxUnknown, s.Status.Phase) } @@ -200,8 +206,9 @@ func TestSandboxFromProto_DefaultGPURequest(t *testing.T) { s := SandboxFromProto(proto) require.NotNil(t, s) - assert.True(t, s.Spec.GPU) - assert.Nil(t, s.Spec.GPUCount) + require.NotNil(t, s.Spec.ResourceRequirements) + require.NotNil(t, s.Spec.ResourceRequirements.GPU) + assert.Nil(t, s.Spec.ResourceRequirements.GPU.Count) } func TestSandboxFromProto_Nil(t *testing.T) { @@ -280,9 +287,13 @@ func TestSandboxToProto(t *testing.T) { UserNamespaces: &userNS, }, Providers: []string{"prov-a"}, - GPUCount: &gpuCount, - Command: []string{"/opt/agent", "--serve"}, - TTY: false, + ResourceRequirements: &v1.ResourceRequirements{ + GPU: &v1.GPUResourceRequirements{Count: &gpuCount}, + CPU: &v1.CPUResourceRequirements{Limit: "1"}, + Memory: &v1.MemoryResourceRequirements{Limit: "4Gi"}, + }, + Command: []string{"/opt/agent", "--serve"}, + TTY: false, }, } @@ -309,6 +320,10 @@ func TestSandboxToProto(t *testing.T) { require.NotNil(t, p.Spec.ResourceRequirements) require.NotNil(t, p.Spec.ResourceRequirements.Gpu) assert.Equal(t, uint32(4), p.Spec.ResourceRequirements.Gpu.GetCount()) + require.NotNil(t, p.Spec.ResourceRequirements.Cpu) + assert.Equal(t, "1", p.Spec.ResourceRequirements.Cpu.GetLimit()) + require.NotNil(t, p.Spec.ResourceRequirements.Memory) + assert.Equal(t, "4Gi", p.Spec.ResourceRequirements.Memory.GetLimit()) require.NotNil(t, p.Spec.Template) assert.Equal(t, "img:v1", p.Spec.Template.Image) @@ -344,7 +359,9 @@ func TestSandboxToProto_NilTemplate(t *testing.T) { func TestSandboxToProto_DefaultGPURequest(t *testing.T) { s := &v1.Sandbox{ Spec: v1.SandboxSpec{ - GPU: true, + ResourceRequirements: &v1.ResourceRequirements{ + GPU: &v1.GPUResourceRequirements{}, + }, }, } @@ -373,10 +390,10 @@ func TestSandboxWorkloadTemplateRoundTrip(t *testing.T) { Workload: &v1.SandboxWorkloadConfig{ Image: "nvcr.io/nvidia/openshell:latest", Environment: map[string]string{"CUDA_VISIBLE_DEVICES": "all"}, - Resources: &v1.SandboxResources{ - CPU: "2", - Memory: "8Gi", - GPU: &v1.SandboxGPURequirements{Count: &gpuCount}, + Resources: &v1.ResourceRequirements{ + CPU: &v1.CPUResourceRequirements{Limit: "2"}, + Memory: &v1.MemoryResourceRequirements{Limit: "8Gi"}, + GPU: &v1.GPUResourceRequirements{Count: &gpuCount}, }, }, DriverConfig: map[string]any{ @@ -401,8 +418,10 @@ func TestSandboxWorkloadTemplateRoundTrip(t *testing.T) { assert.Equal(t, "nvcr.io/nvidia/openshell:latest", protoTemplate.Spec.Workload.Image) assert.Equal(t, map[string]string{"CUDA_VISIBLE_DEVICES": "all"}, protoTemplate.Spec.Workload.Environment) require.NotNil(t, protoTemplate.Spec.Workload.Resources) - assert.Equal(t, "2", protoTemplate.Spec.Workload.Resources.Cpu) - assert.Equal(t, "8Gi", protoTemplate.Spec.Workload.Resources.Memory) + require.NotNil(t, protoTemplate.Spec.Workload.Resources.Cpu) + assert.Equal(t, "2", protoTemplate.Spec.Workload.Resources.Cpu.Limit) + require.NotNil(t, protoTemplate.Spec.Workload.Resources.Memory) + assert.Equal(t, "8Gi", protoTemplate.Spec.Workload.Resources.Memory.Limit) require.NotNil(t, protoTemplate.Spec.Workload.Resources.Gpu) require.NotNil(t, protoTemplate.Spec.Workload.Resources.Gpu.Count) assert.Equal(t, uint32(2), *protoTemplate.Spec.Workload.Resources.Gpu.Count) @@ -444,8 +463,8 @@ func TestSandboxWorkloadTemplateRoundTrip_DefaultGpuRequest(t *testing.T) { Name: "default-gpu", Spec: v1.SandboxWorkloadTemplateSpec{ Workload: &v1.SandboxWorkloadConfig{ - Resources: &v1.SandboxResources{ - GPU: &v1.SandboxGPURequirements{}, + Resources: &v1.ResourceRequirements{ + GPU: &v1.GPUResourceRequirements{}, }, }, }, @@ -493,7 +512,11 @@ func TestSandboxRoundTrip(t *testing.T) { UserNamespaces: &userNS, }, Providers: []string{"p1", "p2"}, - GPUCount: &gpuCount, + ResourceRequirements: &v1.ResourceRequirements{ + GPU: &v1.GPUResourceRequirements{Count: &gpuCount}, + CPU: &v1.CPUResourceRequirements{Limit: "2"}, + Memory: &v1.MemoryResourceRequirements{Limit: "8Gi"}, + }, Policy: &v1.SandboxPolicy{ Version: 3, Filesystem: &v1.FilesystemPolicy{ @@ -542,9 +565,14 @@ func TestSandboxRoundTrip(t *testing.T) { assert.Equal(t, original.Spec.LogLevel, back.Spec.LogLevel) assert.Equal(t, original.Spec.Environment, back.Spec.Environment) assert.Equal(t, original.Spec.Providers, back.Spec.Providers) - assert.True(t, back.Spec.GPU) - require.NotNil(t, back.Spec.GPUCount) - assert.Equal(t, *original.Spec.GPUCount, *back.Spec.GPUCount) + require.NotNil(t, back.Spec.ResourceRequirements) + require.NotNil(t, back.Spec.ResourceRequirements.GPU) + require.NotNil(t, back.Spec.ResourceRequirements.GPU.Count) + assert.Equal(t, *original.Spec.ResourceRequirements.GPU.Count, *back.Spec.ResourceRequirements.GPU.Count) + require.NotNil(t, back.Spec.ResourceRequirements.CPU) + assert.Equal(t, original.Spec.ResourceRequirements.CPU.Limit, back.Spec.ResourceRequirements.CPU.Limit) + require.NotNil(t, back.Spec.ResourceRequirements.Memory) + assert.Equal(t, original.Spec.ResourceRequirements.Memory.Limit, back.Spec.ResourceRequirements.Memory.Limit) require.NotNil(t, back.Spec.Template) assert.Equal(t, original.Spec.Template.Image, back.Spec.Template.Image) require.NotNil(t, back.Spec.Template.UserNamespaces) @@ -615,7 +643,11 @@ func TestSandboxSpecToProto(t *testing.T) { DriverConfig: map[string]any{"runtime": "kata"}, }, Providers: []string{"prov"}, - GPUCount: &gpuCount, + ResourceRequirements: &v1.ResourceRequirements{ + GPU: &v1.GPUResourceRequirements{Count: &gpuCount}, + CPU: &v1.CPUResourceRequirements{Limit: "500m"}, + Memory: &v1.MemoryResourceRequirements{Limit: "1Gi"}, + }, Policy: &v1.SandboxPolicy{ Version: 2, Filesystem: &v1.FilesystemPolicy{ @@ -632,6 +664,8 @@ func TestSandboxSpecToProto(t *testing.T) { assert.Equal(t, []string{"prov"}, p.Providers) require.NotNil(t, p.ResourceRequirements) assert.Equal(t, uint32(3), p.ResourceRequirements.Gpu.GetCount()) + assert.Equal(t, "500m", p.ResourceRequirements.Cpu.GetLimit()) + assert.Equal(t, "1Gi", p.ResourceRequirements.Memory.GetLimit()) require.NotNil(t, p.Template) assert.Equal(t, "img:spec", p.Template.Image) require.NotNil(t, p.Template.Resources) diff --git a/sdk/go/openshell/v1/sandbox.go b/sdk/go/openshell/v1/sandbox.go index 79174ac7f3..a08ea371e1 100644 --- a/sdk/go/openshell/v1/sandbox.go +++ b/sdk/go/openshell/v1/sandbox.go @@ -15,6 +15,18 @@ type Sandbox = types.Sandbox // SandboxSpec holds the desired state of a sandbox. type SandboxSpec = types.SandboxSpec +// ResourceRequirements holds portable compute requirements for a sandbox. +type ResourceRequirements = types.ResourceRequirements + +// GPUResourceRequirements holds GPU requirements for a sandbox. +type GPUResourceRequirements = types.GPUResourceRequirements + +// CPUResourceRequirements holds a portable CPU limit for a sandbox. +type CPUResourceRequirements = types.CPUResourceRequirements + +// MemoryResourceRequirements holds a portable memory limit for a sandbox. +type MemoryResourceRequirements = types.MemoryResourceRequirements + // SandboxTemplate defines the container template for a sandbox. type SandboxTemplate = types.SandboxTemplate diff --git a/sdk/go/openshell/v1/sandbox_client.go b/sdk/go/openshell/v1/sandbox_client.go index 75d8d4caa3..f73e922b9f 100644 --- a/sdk/go/openshell/v1/sandbox_client.go +++ b/sdk/go/openshell/v1/sandbox_client.go @@ -81,7 +81,7 @@ func validateTemplateCreateSpec(spec *SandboxSpec) error { if spec == nil { return nil } - if spec.LogLevel != "" || len(spec.Environment) > 0 || spec.Template != nil || spec.GPU || spec.GPUCount != nil { + if spec.LogLevel != "" || len(spec.Environment) > 0 || spec.Template != nil || spec.ResourceRequirements != nil { return &StatusError{Code: ErrorInvalidArgument, Message: "template creates only allow policy, providers, command, and tty in spec"} } return nil diff --git a/sdk/go/openshell/v1/sandbox_client_test.go b/sdk/go/openshell/v1/sandbox_client_test.go index 7926b28a16..2f187289ab 100644 --- a/sdk/go/openshell/v1/sandbox_client_test.go +++ b/sdk/go/openshell/v1/sandbox_client_test.go @@ -273,13 +273,16 @@ func TestSandboxCreate_DefaultGPURequest(t *testing.T) { defer cleanup() result, err := client.Create(context.Background(), "default", "gpu-sandbox", &SandboxSpec{ - GPU: true, + ResourceRequirements: &ResourceRequirements{ + GPU: &GPUResourceRequirements{}, + }, }, nil) require.NoError(t, err) require.NotNil(t, result) - assert.True(t, result.Spec.GPU) - assert.Nil(t, result.Spec.GPUCount) + require.NotNil(t, result.Spec.ResourceRequirements) + require.NotNil(t, result.Spec.ResourceRequirements.GPU) + assert.Nil(t, result.Spec.ResourceRequirements.GPU.Count) mock.mu.Lock() defer mock.mu.Unlock() @@ -311,7 +314,9 @@ func TestSandboxCreateFromTemplateRejectsGPUOverrideBeforeRPC(t *testing.T) { defer cleanup() _, err := client.CreateFromTemplate(context.Background(), "default", "bad", "gpu-kata", &SandboxSpec{ - GPU: true, + ResourceRequirements: &ResourceRequirements{ + GPU: &GPUResourceRequirements{}, + }, }, nil) require.Error(t, err) diff --git a/sdk/go/openshell/v1/sandbox_template.go b/sdk/go/openshell/v1/sandbox_template.go index e2f2d71874..f2ca03f920 100644 --- a/sdk/go/openshell/v1/sandbox_template.go +++ b/sdk/go/openshell/v1/sandbox_template.go @@ -18,12 +18,6 @@ type SandboxWorkloadTemplateSpec = types.SandboxWorkloadTemplateSpec // SandboxWorkloadConfig defines the portable workload for a reusable template. type SandboxWorkloadConfig = types.SandboxWorkloadConfig -// SandboxResources defines portable sandbox resource requirements. -type SandboxResources = types.SandboxResources - -// SandboxGPURequirements defines template GPU requirements. -type SandboxGPURequirements = types.SandboxGPURequirements - // SandboxServiceLevel describes desired operational characteristics. type SandboxServiceLevel = types.SandboxServiceLevel diff --git a/sdk/go/openshell/v1/sandbox_template_client_test.go b/sdk/go/openshell/v1/sandbox_template_client_test.go index 4f9e3058c0..5caa895253 100644 --- a/sdk/go/openshell/v1/sandbox_template_client_test.go +++ b/sdk/go/openshell/v1/sandbox_template_client_test.go @@ -138,10 +138,10 @@ func TestSandboxTemplateCreate(t *testing.T) { Workload: &SandboxWorkloadConfig{ Image: "nvcr.io/nvidia/openshell:latest", Environment: map[string]string{"NVIDIA_VISIBLE_DEVICES": "all"}, - Resources: &SandboxResources{ - CPU: "2", - Memory: "8Gi", - GPU: &SandboxGPURequirements{Count: &gpuCount}, + Resources: &ResourceRequirements{ + CPU: &CPUResourceRequirements{Limit: "2"}, + Memory: &MemoryResourceRequirements{Limit: "8Gi"}, + GPU: &GPUResourceRequirements{Count: &gpuCount}, }, }, DriverConfig: map[string]any{ @@ -166,8 +166,10 @@ func TestSandboxTemplateCreate(t *testing.T) { require.NotNil(t, mock.createRequest) assert.Equal(t, "default", mock.createRequest.Workspace) assert.Equal(t, "gpu-kata", mock.createRequest.Template.Metadata.Name) - assert.Equal(t, "2", mock.createRequest.Template.Spec.Workload.Resources.Cpu) - assert.Equal(t, "8Gi", mock.createRequest.Template.Spec.Workload.Resources.Memory) + require.NotNil(t, mock.createRequest.Template.Spec.Workload.Resources.Cpu) + assert.Equal(t, "2", mock.createRequest.Template.Spec.Workload.Resources.Cpu.Limit) + require.NotNil(t, mock.createRequest.Template.Spec.Workload.Resources.Memory) + assert.Equal(t, "8Gi", mock.createRequest.Template.Spec.Workload.Resources.Memory.Limit) require.NotNil(t, mock.createRequest.Template.Spec.Workload.Resources.Gpu) require.NotNil(t, mock.createRequest.Template.Spec.Workload.Resources.Gpu.Count) assert.Equal(t, uint32(1), *mock.createRequest.Template.Spec.Workload.Resources.Gpu.Count) diff --git a/sdk/go/openshell/v1/types/sandbox.go b/sdk/go/openshell/v1/types/sandbox.go index 8be13888ba..f1ef9f434e 100644 --- a/sdk/go/openshell/v1/types/sandbox.go +++ b/sdk/go/openshell/v1/types/sandbox.go @@ -26,16 +26,47 @@ type SandboxSpec struct { Environment map[string]string Template *SandboxTemplate Providers []string - // GPU requests GPU resources using the active driver's default GPU assignment - // when GPUCount is nil. GPUCount implies GPU for backward compatibility. - GPU bool - GPUCount *uint32 + // ResourceRequirements are the portable GPU, CPU, and memory requirements + // for the sandbox workload. Nil means no resource requirements specified. + ResourceRequirements *ResourceRequirements // Policy is the security policy for the sandbox. Nil means no policy specified. Policy *SandboxPolicy Command []string TTY bool } +// ResourceRequirements holds portable compute resource requirements for a +// sandbox workload, mirroring the proto ResourceRequirements message. +type ResourceRequirements struct { + // GPU requirements for the sandbox. Presence indicates a GPU request. + GPU *GPUResourceRequirements + // CPU requirements for the sandbox workload. + CPU *CPUResourceRequirements + // Memory requirements for the sandbox workload. + Memory *MemoryResourceRequirements +} + +// GPUResourceRequirements holds GPU resource requirements for a sandbox. +type GPUResourceRequirements struct { + // Count is the number of GPUs requested. Nil means the driver's default + // GPU assignment count semantics apply. + Count *uint32 +} + +// CPUResourceRequirements holds CPU resource requirements for a sandbox. +type CPUResourceRequirements struct { + // Limit is the CPU limit for the sandbox workload, using a + // Kubernetes-style CPU quantity string such as "500m", "1", or "2.5". + Limit string +} + +// MemoryResourceRequirements holds memory resource requirements for a sandbox. +type MemoryResourceRequirements struct { + // Limit is the memory limit for the sandbox workload, using a + // Kubernetes-style memory quantity string such as "512Mi", "4Gi", or "8G". + Limit string +} + // SandboxTemplate defines the container template for a sandbox. type SandboxTemplate struct { Image string @@ -73,21 +104,7 @@ type SandboxWorkloadTemplateSpec struct { type SandboxWorkloadConfig struct { Image string Environment map[string]string - Resources *SandboxResources -} - -// SandboxResources defines portable sandbox resource requirements. -type SandboxResources struct { - CPU string - Memory string - // GPU requests GPU resources for template-backed sandboxes. A non-nil GPU - // with nil Count requests the active driver's default GPU assignment. - GPU *SandboxGPURequirements -} - -// SandboxGPURequirements defines template GPU requirements. -type SandboxGPURequirements struct { - Count *uint32 + Resources *ResourceRequirements } // SandboxServiceLevel describes desired operational characteristics. diff --git a/sdk/go/proto/openshellv1/openshell.pb.go b/sdk/go/proto/openshellv1/openshell.pb.go index 58f1968a04..acfa07e3c7 100644 --- a/sdk/go/proto/openshellv1/openshell.pb.go +++ b/sdk/go/proto/openshellv1/openshell.pb.go @@ -1553,7 +1553,11 @@ func (x *SandboxSpec) GetTty() bool { type ResourceRequirements struct { state protoimpl.MessageState `protogen:"open.v1"` // GPU requirements for the sandbox. Presence indicates a GPU request. - Gpu *GpuResourceRequirements `protobuf:"bytes,1,opt,name=gpu,proto3" json:"gpu,omitempty"` + Gpu *GpuResourceRequirements `protobuf:"bytes,1,opt,name=gpu,proto3" json:"gpu,omitempty"` + // CPU requirements for the sandbox workload. + Cpu *CpuResourceRequirements `protobuf:"bytes,2,opt,name=cpu,proto3" json:"cpu,omitempty"` + // Memory requirements for the sandbox workload. + Memory *MemoryResourceRequirements `protobuf:"bytes,3,opt,name=memory,proto3" json:"memory,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } @@ -1595,6 +1599,20 @@ func (x *ResourceRequirements) GetGpu() *GpuResourceRequirements { return nil } +func (x *ResourceRequirements) GetCpu() *CpuResourceRequirements { + if x != nil { + return x.Cpu + } + return nil +} + +func (x *ResourceRequirements) GetMemory() *MemoryResourceRequirements { + if x != nil { + return x.Memory + } + return nil +} + // Public GPU resource requirements. type GpuResourceRequirements struct { state protoimpl.MessageState `protogen:"open.v1"` @@ -1642,6 +1660,98 @@ func (x *GpuResourceRequirements) GetCount() uint32 { return 0 } +// Public CPU resource requirements. +type CpuResourceRequirements struct { + state protoimpl.MessageState `protogen:"open.v1"` + // CPU limit for the sandbox workload (e.g. "500m", "2"). + Limit string `protobuf:"bytes,1,opt,name=limit,proto3" json:"limit,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *CpuResourceRequirements) Reset() { + *x = CpuResourceRequirements{} + mi := &file_openshell_proto_msgTypes[20] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *CpuResourceRequirements) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*CpuResourceRequirements) ProtoMessage() {} + +func (x *CpuResourceRequirements) ProtoReflect() protoreflect.Message { + mi := &file_openshell_proto_msgTypes[20] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use CpuResourceRequirements.ProtoReflect.Descriptor instead. +func (*CpuResourceRequirements) Descriptor() ([]byte, []int) { + return file_openshell_proto_rawDescGZIP(), []int{20} +} + +func (x *CpuResourceRequirements) GetLimit() string { + if x != nil { + return x.Limit + } + return "" +} + +// Public memory resource requirements. +type MemoryResourceRequirements struct { + state protoimpl.MessageState `protogen:"open.v1"` + // Memory limit for the sandbox workload (e.g. "512Mi", "4Gi"). + Limit string `protobuf:"bytes,1,opt,name=limit,proto3" json:"limit,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *MemoryResourceRequirements) Reset() { + *x = MemoryResourceRequirements{} + mi := &file_openshell_proto_msgTypes[21] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *MemoryResourceRequirements) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*MemoryResourceRequirements) ProtoMessage() {} + +func (x *MemoryResourceRequirements) ProtoReflect() protoreflect.Message { + mi := &file_openshell_proto_msgTypes[21] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use MemoryResourceRequirements.ProtoReflect.Descriptor instead. +func (*MemoryResourceRequirements) Descriptor() ([]byte, []int) { + return file_openshell_proto_rawDescGZIP(), []int{21} +} + +func (x *MemoryResourceRequirements) GetLimit() string { + if x != nil { + return x.Limit + } + return "" +} + // Historical inline compute template mapped onto compute-driver template inputs. // // Despite its name, this is not a reusable named sandbox template resource. It @@ -1662,7 +1772,8 @@ type SandboxTemplate struct { Annotations map[string]string `protobuf:"bytes,5,rep,name=annotations,proto3" json:"annotations,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` // Additional environment variables injected by the template. Environment map[string]string `protobuf:"bytes,6,rep,name=environment,proto3" json:"environment,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` - // Platform-specific compute resource requirements and limits. + // Platform-specific resource passthrough. CPU and memory under + // limits/requests are rejected; use ResourceRequirements.cpu/memory instead. Resources *structpb.Struct `protobuf:"bytes,7,opt,name=resources,proto3" json:"resources,omitempty"` // Enable Kubernetes user namespace isolation (hostUsers: false). // When true, container UID 0 maps to a non-root host UID and capabilities @@ -1681,7 +1792,7 @@ type SandboxTemplate struct { func (x *SandboxTemplate) Reset() { *x = SandboxTemplate{} - mi := &file_openshell_proto_msgTypes[20] + mi := &file_openshell_proto_msgTypes[22] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1693,7 +1804,7 @@ func (x *SandboxTemplate) String() string { func (*SandboxTemplate) ProtoMessage() {} func (x *SandboxTemplate) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[20] + mi := &file_openshell_proto_msgTypes[22] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1706,7 +1817,7 @@ func (x *SandboxTemplate) ProtoReflect() protoreflect.Message { // Deprecated: Use SandboxTemplate.ProtoReflect.Descriptor instead. func (*SandboxTemplate) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{20} + return file_openshell_proto_rawDescGZIP(), []int{22} } func (x *SandboxTemplate) GetImage() string { @@ -1790,7 +1901,7 @@ type SandboxWorkloadTemplate struct { func (x *SandboxWorkloadTemplate) Reset() { *x = SandboxWorkloadTemplate{} - mi := &file_openshell_proto_msgTypes[21] + mi := &file_openshell_proto_msgTypes[23] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1802,7 +1913,7 @@ func (x *SandboxWorkloadTemplate) String() string { func (*SandboxWorkloadTemplate) ProtoMessage() {} func (x *SandboxWorkloadTemplate) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[21] + mi := &file_openshell_proto_msgTypes[23] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1815,7 +1926,7 @@ func (x *SandboxWorkloadTemplate) ProtoReflect() protoreflect.Message { // Deprecated: Use SandboxWorkloadTemplate.ProtoReflect.Descriptor instead. func (*SandboxWorkloadTemplate) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{21} + return file_openshell_proto_rawDescGZIP(), []int{23} } func (x *SandboxWorkloadTemplate) GetMetadata() *datamodelv1.ObjectMeta { @@ -1846,7 +1957,7 @@ type SandboxWorkloadTemplateSpec struct { func (x *SandboxWorkloadTemplateSpec) Reset() { *x = SandboxWorkloadTemplateSpec{} - mi := &file_openshell_proto_msgTypes[22] + mi := &file_openshell_proto_msgTypes[24] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1858,7 +1969,7 @@ func (x *SandboxWorkloadTemplateSpec) String() string { func (*SandboxWorkloadTemplateSpec) ProtoMessage() {} func (x *SandboxWorkloadTemplateSpec) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[22] + mi := &file_openshell_proto_msgTypes[24] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1871,7 +1982,7 @@ func (x *SandboxWorkloadTemplateSpec) ProtoReflect() protoreflect.Message { // Deprecated: Use SandboxWorkloadTemplateSpec.ProtoReflect.Descriptor instead. func (*SandboxWorkloadTemplateSpec) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{22} + return file_openshell_proto_rawDescGZIP(), []int{24} } func (x *SandboxWorkloadTemplateSpec) GetWorkload() *SandboxWorkloadConfig { @@ -1902,14 +2013,14 @@ type SandboxWorkloadConfig struct { // Environment variables injected into the sandbox runtime. Environment map[string]string `protobuf:"bytes,2,rep,name=environment,proto3" json:"environment,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` // Portable resource requirements for sandboxes created from this workload. - Resources *SandboxResources `protobuf:"bytes,3,opt,name=resources,proto3" json:"resources,omitempty"` + Resources *ResourceRequirements `protobuf:"bytes,3,opt,name=resources,proto3" json:"resources,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } func (x *SandboxWorkloadConfig) Reset() { *x = SandboxWorkloadConfig{} - mi := &file_openshell_proto_msgTypes[23] + mi := &file_openshell_proto_msgTypes[25] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1921,7 +2032,7 @@ func (x *SandboxWorkloadConfig) String() string { func (*SandboxWorkloadConfig) ProtoMessage() {} func (x *SandboxWorkloadConfig) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[23] + mi := &file_openshell_proto_msgTypes[25] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1934,7 +2045,7 @@ func (x *SandboxWorkloadConfig) ProtoReflect() protoreflect.Message { // Deprecated: Use SandboxWorkloadConfig.ProtoReflect.Descriptor instead. func (*SandboxWorkloadConfig) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{23} + return file_openshell_proto_rawDescGZIP(), []int{25} } func (x *SandboxWorkloadConfig) GetImage() string { @@ -1951,78 +2062,13 @@ func (x *SandboxWorkloadConfig) GetEnvironment() map[string]string { return nil } -func (x *SandboxWorkloadConfig) GetResources() *SandboxResources { +func (x *SandboxWorkloadConfig) GetResources() *ResourceRequirements { if x != nil { return x.Resources } return nil } -type SandboxResources struct { - state protoimpl.MessageState `protogen:"open.v1"` - // Portable CPU quantity, for example "500m" or "2". - Cpu string `protobuf:"bytes,1,opt,name=cpu,proto3" json:"cpu,omitempty"` - // Portable memory quantity, for example "512Mi" or "2Gi". - Memory string `protobuf:"bytes,2,opt,name=memory,proto3" json:"memory,omitempty"` - // GPU requirements for the sandbox workload. Presence indicates a GPU - // request. When count is omitted, the request uses the selected driver's - // default GPU assignment behavior. - Gpu *GpuResourceRequirements `protobuf:"bytes,3,opt,name=gpu,proto3" json:"gpu,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *SandboxResources) Reset() { - *x = SandboxResources{} - mi := &file_openshell_proto_msgTypes[24] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *SandboxResources) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*SandboxResources) ProtoMessage() {} - -func (x *SandboxResources) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[24] - if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use SandboxResources.ProtoReflect.Descriptor instead. -func (*SandboxResources) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{24} -} - -func (x *SandboxResources) GetCpu() string { - if x != nil { - return x.Cpu - } - return "" -} - -func (x *SandboxResources) GetMemory() string { - if x != nil { - return x.Memory - } - return "" -} - -func (x *SandboxResources) GetGpu() *GpuResourceRequirements { - if x != nil { - return x.Gpu - } - return nil -} - type SandboxServiceLevel struct { state protoimpl.MessageState `protogen:"open.v1"` Startup *SandboxStartup `protobuf:"bytes,1,opt,name=startup,proto3" json:"startup,omitempty"` @@ -2032,7 +2078,7 @@ type SandboxServiceLevel struct { func (x *SandboxServiceLevel) Reset() { *x = SandboxServiceLevel{} - mi := &file_openshell_proto_msgTypes[25] + mi := &file_openshell_proto_msgTypes[26] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2044,7 +2090,7 @@ func (x *SandboxServiceLevel) String() string { func (*SandboxServiceLevel) ProtoMessage() {} func (x *SandboxServiceLevel) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[25] + mi := &file_openshell_proto_msgTypes[26] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2057,7 +2103,7 @@ func (x *SandboxServiceLevel) ProtoReflect() protoreflect.Message { // Deprecated: Use SandboxServiceLevel.ProtoReflect.Descriptor instead. func (*SandboxServiceLevel) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{25} + return file_openshell_proto_rawDescGZIP(), []int{26} } func (x *SandboxServiceLevel) GetStartup() *SandboxStartup { @@ -2077,7 +2123,7 @@ type SandboxStartup struct { func (x *SandboxStartup) Reset() { *x = SandboxStartup{} - mi := &file_openshell_proto_msgTypes[26] + mi := &file_openshell_proto_msgTypes[27] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2089,7 +2135,7 @@ func (x *SandboxStartup) String() string { func (*SandboxStartup) ProtoMessage() {} func (x *SandboxStartup) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[26] + mi := &file_openshell_proto_msgTypes[27] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2102,7 +2148,7 @@ func (x *SandboxStartup) ProtoReflect() protoreflect.Message { // Deprecated: Use SandboxStartup.ProtoReflect.Descriptor instead. func (*SandboxStartup) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{26} + return file_openshell_proto_rawDescGZIP(), []int{27} } func (x *SandboxStartup) GetReadyWithin() *durationpb.Duration { @@ -2129,7 +2175,7 @@ type SandboxWorkloadTemplateProvenance struct { func (x *SandboxWorkloadTemplateProvenance) Reset() { *x = SandboxWorkloadTemplateProvenance{} - mi := &file_openshell_proto_msgTypes[27] + mi := &file_openshell_proto_msgTypes[28] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2141,7 +2187,7 @@ func (x *SandboxWorkloadTemplateProvenance) String() string { func (*SandboxWorkloadTemplateProvenance) ProtoMessage() {} func (x *SandboxWorkloadTemplateProvenance) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[27] + mi := &file_openshell_proto_msgTypes[28] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2154,7 +2200,7 @@ func (x *SandboxWorkloadTemplateProvenance) ProtoReflect() protoreflect.Message // Deprecated: Use SandboxWorkloadTemplateProvenance.ProtoReflect.Descriptor instead. func (*SandboxWorkloadTemplateProvenance) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{27} + return file_openshell_proto_rawDescGZIP(), []int{28} } func (x *SandboxWorkloadTemplateProvenance) GetName() string { @@ -2203,7 +2249,7 @@ type SandboxStatus struct { func (x *SandboxStatus) Reset() { *x = SandboxStatus{} - mi := &file_openshell_proto_msgTypes[28] + mi := &file_openshell_proto_msgTypes[29] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2215,7 +2261,7 @@ func (x *SandboxStatus) String() string { func (*SandboxStatus) ProtoMessage() {} func (x *SandboxStatus) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[28] + mi := &file_openshell_proto_msgTypes[29] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2228,7 +2274,7 @@ func (x *SandboxStatus) ProtoReflect() protoreflect.Message { // Deprecated: Use SandboxStatus.ProtoReflect.Descriptor instead. func (*SandboxStatus) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{28} + return file_openshell_proto_rawDescGZIP(), []int{29} } func (x *SandboxStatus) GetSandboxName() string { @@ -2313,7 +2359,7 @@ type SandboxCondition struct { func (x *SandboxCondition) Reset() { *x = SandboxCondition{} - mi := &file_openshell_proto_msgTypes[29] + mi := &file_openshell_proto_msgTypes[30] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2325,7 +2371,7 @@ func (x *SandboxCondition) String() string { func (*SandboxCondition) ProtoMessage() {} func (x *SandboxCondition) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[29] + mi := &file_openshell_proto_msgTypes[30] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2338,7 +2384,7 @@ func (x *SandboxCondition) ProtoReflect() protoreflect.Message { // Deprecated: Use SandboxCondition.ProtoReflect.Descriptor instead. func (*SandboxCondition) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{29} + return file_openshell_proto_rawDescGZIP(), []int{30} } func (x *SandboxCondition) GetType() string { @@ -2397,7 +2443,7 @@ type PlatformEvent struct { func (x *PlatformEvent) Reset() { *x = PlatformEvent{} - mi := &file_openshell_proto_msgTypes[30] + mi := &file_openshell_proto_msgTypes[31] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2409,7 +2455,7 @@ func (x *PlatformEvent) String() string { func (*PlatformEvent) ProtoMessage() {} func (x *PlatformEvent) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[30] + mi := &file_openshell_proto_msgTypes[31] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2422,7 +2468,7 @@ func (x *PlatformEvent) ProtoReflect() protoreflect.Message { // Deprecated: Use PlatformEvent.ProtoReflect.Descriptor instead. func (*PlatformEvent) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{30} + return file_openshell_proto_rawDescGZIP(), []int{31} } func (x *PlatformEvent) GetTimestampMs() int64 { @@ -2491,7 +2537,7 @@ type CreateSandboxRequest struct { func (x *CreateSandboxRequest) Reset() { *x = CreateSandboxRequest{} - mi := &file_openshell_proto_msgTypes[31] + mi := &file_openshell_proto_msgTypes[32] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2503,7 +2549,7 @@ func (x *CreateSandboxRequest) String() string { func (*CreateSandboxRequest) ProtoMessage() {} func (x *CreateSandboxRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[31] + mi := &file_openshell_proto_msgTypes[32] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2516,7 +2562,7 @@ func (x *CreateSandboxRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use CreateSandboxRequest.ProtoReflect.Descriptor instead. func (*CreateSandboxRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{31} + return file_openshell_proto_rawDescGZIP(), []int{32} } func (x *CreateSandboxRequest) GetSpec() *SandboxSpec { @@ -2579,7 +2625,7 @@ type CreateSandboxTemplateRequest struct { func (x *CreateSandboxTemplateRequest) Reset() { *x = CreateSandboxTemplateRequest{} - mi := &file_openshell_proto_msgTypes[32] + mi := &file_openshell_proto_msgTypes[33] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2591,7 +2637,7 @@ func (x *CreateSandboxTemplateRequest) String() string { func (*CreateSandboxTemplateRequest) ProtoMessage() {} func (x *CreateSandboxTemplateRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[32] + mi := &file_openshell_proto_msgTypes[33] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2604,7 +2650,7 @@ func (x *CreateSandboxTemplateRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use CreateSandboxTemplateRequest.ProtoReflect.Descriptor instead. func (*CreateSandboxTemplateRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{32} + return file_openshell_proto_rawDescGZIP(), []int{33} } func (x *CreateSandboxTemplateRequest) GetTemplate() *SandboxWorkloadTemplate { @@ -2632,7 +2678,7 @@ type GetSandboxTemplateRequest struct { func (x *GetSandboxTemplateRequest) Reset() { *x = GetSandboxTemplateRequest{} - mi := &file_openshell_proto_msgTypes[33] + mi := &file_openshell_proto_msgTypes[34] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2644,7 +2690,7 @@ func (x *GetSandboxTemplateRequest) String() string { func (*GetSandboxTemplateRequest) ProtoMessage() {} func (x *GetSandboxTemplateRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[33] + mi := &file_openshell_proto_msgTypes[34] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2657,7 +2703,7 @@ func (x *GetSandboxTemplateRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetSandboxTemplateRequest.ProtoReflect.Descriptor instead. func (*GetSandboxTemplateRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{33} + return file_openshell_proto_rawDescGZIP(), []int{34} } func (x *GetSandboxTemplateRequest) GetName() string { @@ -2690,7 +2736,7 @@ type ListSandboxTemplatesRequest struct { func (x *ListSandboxTemplatesRequest) Reset() { *x = ListSandboxTemplatesRequest{} - mi := &file_openshell_proto_msgTypes[34] + mi := &file_openshell_proto_msgTypes[35] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2702,7 +2748,7 @@ func (x *ListSandboxTemplatesRequest) String() string { func (*ListSandboxTemplatesRequest) ProtoMessage() {} func (x *ListSandboxTemplatesRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[34] + mi := &file_openshell_proto_msgTypes[35] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2715,7 +2761,7 @@ func (x *ListSandboxTemplatesRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListSandboxTemplatesRequest.ProtoReflect.Descriptor instead. func (*ListSandboxTemplatesRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{34} + return file_openshell_proto_rawDescGZIP(), []int{35} } func (x *ListSandboxTemplatesRequest) GetLimit() uint32 { @@ -2764,7 +2810,7 @@ type DeleteSandboxTemplateRequest struct { func (x *DeleteSandboxTemplateRequest) Reset() { *x = DeleteSandboxTemplateRequest{} - mi := &file_openshell_proto_msgTypes[35] + mi := &file_openshell_proto_msgTypes[36] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2776,7 +2822,7 @@ func (x *DeleteSandboxTemplateRequest) String() string { func (*DeleteSandboxTemplateRequest) ProtoMessage() {} func (x *DeleteSandboxTemplateRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[35] + mi := &file_openshell_proto_msgTypes[36] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2789,7 +2835,7 @@ func (x *DeleteSandboxTemplateRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteSandboxTemplateRequest.ProtoReflect.Descriptor instead. func (*DeleteSandboxTemplateRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{35} + return file_openshell_proto_rawDescGZIP(), []int{36} } func (x *DeleteSandboxTemplateRequest) GetName() string { @@ -2815,7 +2861,7 @@ type SandboxTemplateResponse struct { func (x *SandboxTemplateResponse) Reset() { *x = SandboxTemplateResponse{} - mi := &file_openshell_proto_msgTypes[36] + mi := &file_openshell_proto_msgTypes[37] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2827,7 +2873,7 @@ func (x *SandboxTemplateResponse) String() string { func (*SandboxTemplateResponse) ProtoMessage() {} func (x *SandboxTemplateResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[36] + mi := &file_openshell_proto_msgTypes[37] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2840,7 +2886,7 @@ func (x *SandboxTemplateResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use SandboxTemplateResponse.ProtoReflect.Descriptor instead. func (*SandboxTemplateResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{36} + return file_openshell_proto_rawDescGZIP(), []int{37} } func (x *SandboxTemplateResponse) GetTemplate() *SandboxWorkloadTemplate { @@ -2859,7 +2905,7 @@ type ListSandboxTemplatesResponse struct { func (x *ListSandboxTemplatesResponse) Reset() { *x = ListSandboxTemplatesResponse{} - mi := &file_openshell_proto_msgTypes[37] + mi := &file_openshell_proto_msgTypes[38] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2871,7 +2917,7 @@ func (x *ListSandboxTemplatesResponse) String() string { func (*ListSandboxTemplatesResponse) ProtoMessage() {} func (x *ListSandboxTemplatesResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[37] + mi := &file_openshell_proto_msgTypes[38] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2884,7 +2930,7 @@ func (x *ListSandboxTemplatesResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListSandboxTemplatesResponse.ProtoReflect.Descriptor instead. func (*ListSandboxTemplatesResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{37} + return file_openshell_proto_rawDescGZIP(), []int{38} } func (x *ListSandboxTemplatesResponse) GetTemplates() []*SandboxWorkloadTemplate { @@ -2903,7 +2949,7 @@ type DeleteSandboxTemplateResponse struct { func (x *DeleteSandboxTemplateResponse) Reset() { *x = DeleteSandboxTemplateResponse{} - mi := &file_openshell_proto_msgTypes[38] + mi := &file_openshell_proto_msgTypes[39] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2915,7 +2961,7 @@ func (x *DeleteSandboxTemplateResponse) String() string { func (*DeleteSandboxTemplateResponse) ProtoMessage() {} func (x *DeleteSandboxTemplateResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[38] + mi := &file_openshell_proto_msgTypes[39] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2928,7 +2974,7 @@ func (x *DeleteSandboxTemplateResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteSandboxTemplateResponse.ProtoReflect.Descriptor instead. func (*DeleteSandboxTemplateResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{38} + return file_openshell_proto_rawDescGZIP(), []int{39} } func (x *DeleteSandboxTemplateResponse) GetDeleted() bool { @@ -2956,7 +3002,7 @@ type BeginRootfsTarStagingRequest struct { func (x *BeginRootfsTarStagingRequest) Reset() { *x = BeginRootfsTarStagingRequest{} - mi := &file_openshell_proto_msgTypes[39] + mi := &file_openshell_proto_msgTypes[40] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2968,7 +3014,7 @@ func (x *BeginRootfsTarStagingRequest) String() string { func (*BeginRootfsTarStagingRequest) ProtoMessage() {} func (x *BeginRootfsTarStagingRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[39] + mi := &file_openshell_proto_msgTypes[40] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2981,7 +3027,7 @@ func (x *BeginRootfsTarStagingRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use BeginRootfsTarStagingRequest.ProtoReflect.Descriptor instead. func (*BeginRootfsTarStagingRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{39} + return file_openshell_proto_rawDescGZIP(), []int{40} } func (x *BeginRootfsTarStagingRequest) GetWorkspace() string { @@ -3024,7 +3070,7 @@ type BeginRootfsTarStagingResponse struct { func (x *BeginRootfsTarStagingResponse) Reset() { *x = BeginRootfsTarStagingResponse{} - mi := &file_openshell_proto_msgTypes[40] + mi := &file_openshell_proto_msgTypes[41] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3036,7 +3082,7 @@ func (x *BeginRootfsTarStagingResponse) String() string { func (*BeginRootfsTarStagingResponse) ProtoMessage() {} func (x *BeginRootfsTarStagingResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[40] + mi := &file_openshell_proto_msgTypes[41] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3049,7 +3095,7 @@ func (x *BeginRootfsTarStagingResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use BeginRootfsTarStagingResponse.ProtoReflect.Descriptor instead. func (*BeginRootfsTarStagingResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{40} + return file_openshell_proto_rawDescGZIP(), []int{41} } func (x *BeginRootfsTarStagingResponse) GetStagingToken() string { @@ -3093,7 +3139,7 @@ type GetSandboxRequest struct { func (x *GetSandboxRequest) Reset() { *x = GetSandboxRequest{} - mi := &file_openshell_proto_msgTypes[41] + mi := &file_openshell_proto_msgTypes[42] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3105,7 +3151,7 @@ func (x *GetSandboxRequest) String() string { func (*GetSandboxRequest) ProtoMessage() {} func (x *GetSandboxRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[41] + mi := &file_openshell_proto_msgTypes[42] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3118,7 +3164,7 @@ func (x *GetSandboxRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetSandboxRequest.ProtoReflect.Descriptor instead. func (*GetSandboxRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{41} + return file_openshell_proto_rawDescGZIP(), []int{42} } func (x *GetSandboxRequest) GetName() string { @@ -3152,7 +3198,7 @@ type ListSandboxesRequest struct { func (x *ListSandboxesRequest) Reset() { *x = ListSandboxesRequest{} - mi := &file_openshell_proto_msgTypes[42] + mi := &file_openshell_proto_msgTypes[43] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3164,7 +3210,7 @@ func (x *ListSandboxesRequest) String() string { func (*ListSandboxesRequest) ProtoMessage() {} func (x *ListSandboxesRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[42] + mi := &file_openshell_proto_msgTypes[43] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3177,7 +3223,7 @@ func (x *ListSandboxesRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListSandboxesRequest.ProtoReflect.Descriptor instead. func (*ListSandboxesRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{42} + return file_openshell_proto_rawDescGZIP(), []int{43} } func (x *ListSandboxesRequest) GetLimit() uint32 { @@ -3228,7 +3274,7 @@ type ListSandboxProvidersRequest struct { func (x *ListSandboxProvidersRequest) Reset() { *x = ListSandboxProvidersRequest{} - mi := &file_openshell_proto_msgTypes[43] + mi := &file_openshell_proto_msgTypes[44] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3240,7 +3286,7 @@ func (x *ListSandboxProvidersRequest) String() string { func (*ListSandboxProvidersRequest) ProtoMessage() {} func (x *ListSandboxProvidersRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[43] + mi := &file_openshell_proto_msgTypes[44] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3253,7 +3299,7 @@ func (x *ListSandboxProvidersRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListSandboxProvidersRequest.ProtoReflect.Descriptor instead. func (*ListSandboxProvidersRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{43} + return file_openshell_proto_rawDescGZIP(), []int{44} } func (x *ListSandboxProvidersRequest) GetSandboxName() string { @@ -3290,7 +3336,7 @@ type AttachSandboxProviderRequest struct { func (x *AttachSandboxProviderRequest) Reset() { *x = AttachSandboxProviderRequest{} - mi := &file_openshell_proto_msgTypes[44] + mi := &file_openshell_proto_msgTypes[45] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3302,7 +3348,7 @@ func (x *AttachSandboxProviderRequest) String() string { func (*AttachSandboxProviderRequest) ProtoMessage() {} func (x *AttachSandboxProviderRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[44] + mi := &file_openshell_proto_msgTypes[45] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3315,7 +3361,7 @@ func (x *AttachSandboxProviderRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use AttachSandboxProviderRequest.ProtoReflect.Descriptor instead. func (*AttachSandboxProviderRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{44} + return file_openshell_proto_rawDescGZIP(), []int{45} } func (x *AttachSandboxProviderRequest) GetSandboxName() string { @@ -3366,7 +3412,7 @@ type DetachSandboxProviderRequest struct { func (x *DetachSandboxProviderRequest) Reset() { *x = DetachSandboxProviderRequest{} - mi := &file_openshell_proto_msgTypes[45] + mi := &file_openshell_proto_msgTypes[46] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3378,7 +3424,7 @@ func (x *DetachSandboxProviderRequest) String() string { func (*DetachSandboxProviderRequest) ProtoMessage() {} func (x *DetachSandboxProviderRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[45] + mi := &file_openshell_proto_msgTypes[46] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3391,7 +3437,7 @@ func (x *DetachSandboxProviderRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use DetachSandboxProviderRequest.ProtoReflect.Descriptor instead. func (*DetachSandboxProviderRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{45} + return file_openshell_proto_rawDescGZIP(), []int{46} } func (x *DetachSandboxProviderRequest) GetSandboxName() string { @@ -3435,7 +3481,7 @@ type DeleteSandboxRequest struct { func (x *DeleteSandboxRequest) Reset() { *x = DeleteSandboxRequest{} - mi := &file_openshell_proto_msgTypes[46] + mi := &file_openshell_proto_msgTypes[47] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3447,7 +3493,7 @@ func (x *DeleteSandboxRequest) String() string { func (*DeleteSandboxRequest) ProtoMessage() {} func (x *DeleteSandboxRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[46] + mi := &file_openshell_proto_msgTypes[47] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3460,7 +3506,7 @@ func (x *DeleteSandboxRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteSandboxRequest.ProtoReflect.Descriptor instead. func (*DeleteSandboxRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{46} + return file_openshell_proto_rawDescGZIP(), []int{47} } func (x *DeleteSandboxRequest) GetName() string { @@ -3490,7 +3536,7 @@ type StopSandboxRequest struct { func (x *StopSandboxRequest) Reset() { *x = StopSandboxRequest{} - mi := &file_openshell_proto_msgTypes[47] + mi := &file_openshell_proto_msgTypes[48] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3502,7 +3548,7 @@ func (x *StopSandboxRequest) String() string { func (*StopSandboxRequest) ProtoMessage() {} func (x *StopSandboxRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[47] + mi := &file_openshell_proto_msgTypes[48] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3515,7 +3561,7 @@ func (x *StopSandboxRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use StopSandboxRequest.ProtoReflect.Descriptor instead. func (*StopSandboxRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{47} + return file_openshell_proto_rawDescGZIP(), []int{48} } func (x *StopSandboxRequest) GetName() string { @@ -3545,7 +3591,7 @@ type StartSandboxRequest struct { func (x *StartSandboxRequest) Reset() { *x = StartSandboxRequest{} - mi := &file_openshell_proto_msgTypes[48] + mi := &file_openshell_proto_msgTypes[49] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3557,7 +3603,7 @@ func (x *StartSandboxRequest) String() string { func (*StartSandboxRequest) ProtoMessage() {} func (x *StartSandboxRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[48] + mi := &file_openshell_proto_msgTypes[49] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3570,7 +3616,7 @@ func (x *StartSandboxRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use StartSandboxRequest.ProtoReflect.Descriptor instead. func (*StartSandboxRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{48} + return file_openshell_proto_rawDescGZIP(), []int{49} } func (x *StartSandboxRequest) GetName() string { @@ -3597,7 +3643,7 @@ type SandboxResponse struct { func (x *SandboxResponse) Reset() { *x = SandboxResponse{} - mi := &file_openshell_proto_msgTypes[49] + mi := &file_openshell_proto_msgTypes[50] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3609,7 +3655,7 @@ func (x *SandboxResponse) String() string { func (*SandboxResponse) ProtoMessage() {} func (x *SandboxResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[49] + mi := &file_openshell_proto_msgTypes[50] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3622,7 +3668,7 @@ func (x *SandboxResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use SandboxResponse.ProtoReflect.Descriptor instead. func (*SandboxResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{49} + return file_openshell_proto_rawDescGZIP(), []int{50} } func (x *SandboxResponse) GetSandbox() *Sandbox { @@ -3642,7 +3688,7 @@ type ListSandboxesResponse struct { func (x *ListSandboxesResponse) Reset() { *x = ListSandboxesResponse{} - mi := &file_openshell_proto_msgTypes[50] + mi := &file_openshell_proto_msgTypes[51] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3654,7 +3700,7 @@ func (x *ListSandboxesResponse) String() string { func (*ListSandboxesResponse) ProtoMessage() {} func (x *ListSandboxesResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[50] + mi := &file_openshell_proto_msgTypes[51] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3667,7 +3713,7 @@ func (x *ListSandboxesResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListSandboxesResponse.ProtoReflect.Descriptor instead. func (*ListSandboxesResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{50} + return file_openshell_proto_rawDescGZIP(), []int{51} } func (x *ListSandboxesResponse) GetSandboxes() []*Sandbox { @@ -3687,7 +3733,7 @@ type ListSandboxProvidersResponse struct { func (x *ListSandboxProvidersResponse) Reset() { *x = ListSandboxProvidersResponse{} - mi := &file_openshell_proto_msgTypes[51] + mi := &file_openshell_proto_msgTypes[52] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3699,7 +3745,7 @@ func (x *ListSandboxProvidersResponse) String() string { func (*ListSandboxProvidersResponse) ProtoMessage() {} func (x *ListSandboxProvidersResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[51] + mi := &file_openshell_proto_msgTypes[52] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3712,7 +3758,7 @@ func (x *ListSandboxProvidersResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListSandboxProvidersResponse.ProtoReflect.Descriptor instead. func (*ListSandboxProvidersResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{51} + return file_openshell_proto_rawDescGZIP(), []int{52} } func (x *ListSandboxProvidersResponse) GetProviders() []*datamodelv1.Provider { @@ -3734,7 +3780,7 @@ type AttachSandboxProviderResponse struct { func (x *AttachSandboxProviderResponse) Reset() { *x = AttachSandboxProviderResponse{} - mi := &file_openshell_proto_msgTypes[52] + mi := &file_openshell_proto_msgTypes[53] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3746,7 +3792,7 @@ func (x *AttachSandboxProviderResponse) String() string { func (*AttachSandboxProviderResponse) ProtoMessage() {} func (x *AttachSandboxProviderResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[52] + mi := &file_openshell_proto_msgTypes[53] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3759,7 +3805,7 @@ func (x *AttachSandboxProviderResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use AttachSandboxProviderResponse.ProtoReflect.Descriptor instead. func (*AttachSandboxProviderResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{52} + return file_openshell_proto_rawDescGZIP(), []int{53} } func (x *AttachSandboxProviderResponse) GetSandbox() *Sandbox { @@ -3788,7 +3834,7 @@ type DetachSandboxProviderResponse struct { func (x *DetachSandboxProviderResponse) Reset() { *x = DetachSandboxProviderResponse{} - mi := &file_openshell_proto_msgTypes[53] + mi := &file_openshell_proto_msgTypes[54] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3800,7 +3846,7 @@ func (x *DetachSandboxProviderResponse) String() string { func (*DetachSandboxProviderResponse) ProtoMessage() {} func (x *DetachSandboxProviderResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[53] + mi := &file_openshell_proto_msgTypes[54] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3813,7 +3859,7 @@ func (x *DetachSandboxProviderResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use DetachSandboxProviderResponse.ProtoReflect.Descriptor instead. func (*DetachSandboxProviderResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{53} + return file_openshell_proto_rawDescGZIP(), []int{54} } func (x *DetachSandboxProviderResponse) GetSandbox() *Sandbox { @@ -3840,7 +3886,7 @@ type DeleteSandboxResponse struct { func (x *DeleteSandboxResponse) Reset() { *x = DeleteSandboxResponse{} - mi := &file_openshell_proto_msgTypes[54] + mi := &file_openshell_proto_msgTypes[55] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3852,7 +3898,7 @@ func (x *DeleteSandboxResponse) String() string { func (*DeleteSandboxResponse) ProtoMessage() {} func (x *DeleteSandboxResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[54] + mi := &file_openshell_proto_msgTypes[55] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3865,7 +3911,7 @@ func (x *DeleteSandboxResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteSandboxResponse.ProtoReflect.Descriptor instead. func (*DeleteSandboxResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{54} + return file_openshell_proto_rawDescGZIP(), []int{55} } func (x *DeleteSandboxResponse) GetDeleted() bool { @@ -3886,7 +3932,7 @@ type CreateSshSessionRequest struct { func (x *CreateSshSessionRequest) Reset() { *x = CreateSshSessionRequest{} - mi := &file_openshell_proto_msgTypes[55] + mi := &file_openshell_proto_msgTypes[56] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3898,7 +3944,7 @@ func (x *CreateSshSessionRequest) String() string { func (*CreateSshSessionRequest) ProtoMessage() {} func (x *CreateSshSessionRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[55] + mi := &file_openshell_proto_msgTypes[56] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3911,7 +3957,7 @@ func (x *CreateSshSessionRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use CreateSshSessionRequest.ProtoReflect.Descriptor instead. func (*CreateSshSessionRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{55} + return file_openshell_proto_rawDescGZIP(), []int{56} } func (x *CreateSshSessionRequest) GetSandboxId() string { @@ -3954,7 +4000,7 @@ type CreateSshSessionResponse struct { func (x *CreateSshSessionResponse) Reset() { *x = CreateSshSessionResponse{} - mi := &file_openshell_proto_msgTypes[56] + mi := &file_openshell_proto_msgTypes[57] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3966,7 +4012,7 @@ func (x *CreateSshSessionResponse) String() string { func (*CreateSshSessionResponse) ProtoMessage() {} func (x *CreateSshSessionResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[56] + mi := &file_openshell_proto_msgTypes[57] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3979,7 +4025,7 @@ func (x *CreateSshSessionResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use CreateSshSessionResponse.ProtoReflect.Descriptor instead. func (*CreateSshSessionResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{56} + return file_openshell_proto_rawDescGZIP(), []int{57} } func (x *CreateSshSessionResponse) GetSandboxId() string { @@ -4050,7 +4096,7 @@ type ExposeServiceRequest struct { func (x *ExposeServiceRequest) Reset() { *x = ExposeServiceRequest{} - mi := &file_openshell_proto_msgTypes[57] + mi := &file_openshell_proto_msgTypes[58] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4062,7 +4108,7 @@ func (x *ExposeServiceRequest) String() string { func (*ExposeServiceRequest) ProtoMessage() {} func (x *ExposeServiceRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[57] + mi := &file_openshell_proto_msgTypes[58] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4075,7 +4121,7 @@ func (x *ExposeServiceRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ExposeServiceRequest.ProtoReflect.Descriptor instead. func (*ExposeServiceRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{57} + return file_openshell_proto_rawDescGZIP(), []int{58} } func (x *ExposeServiceRequest) GetSandbox() string { @@ -4128,7 +4174,7 @@ type GetServiceRequest struct { func (x *GetServiceRequest) Reset() { *x = GetServiceRequest{} - mi := &file_openshell_proto_msgTypes[58] + mi := &file_openshell_proto_msgTypes[59] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4140,7 +4186,7 @@ func (x *GetServiceRequest) String() string { func (*GetServiceRequest) ProtoMessage() {} func (x *GetServiceRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[58] + mi := &file_openshell_proto_msgTypes[59] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4153,7 +4199,7 @@ func (x *GetServiceRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetServiceRequest.ProtoReflect.Descriptor instead. func (*GetServiceRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{58} + return file_openshell_proto_rawDescGZIP(), []int{59} } func (x *GetServiceRequest) GetSandbox() string { @@ -4196,7 +4242,7 @@ type ListServicesRequest struct { func (x *ListServicesRequest) Reset() { *x = ListServicesRequest{} - mi := &file_openshell_proto_msgTypes[59] + mi := &file_openshell_proto_msgTypes[60] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4208,7 +4254,7 @@ func (x *ListServicesRequest) String() string { func (*ListServicesRequest) ProtoMessage() {} func (x *ListServicesRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[59] + mi := &file_openshell_proto_msgTypes[60] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4221,7 +4267,7 @@ func (x *ListServicesRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListServicesRequest.ProtoReflect.Descriptor instead. func (*ListServicesRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{59} + return file_openshell_proto_rawDescGZIP(), []int{60} } func (x *ListServicesRequest) GetSandbox() string { @@ -4269,7 +4315,7 @@ type ListServicesResponse struct { func (x *ListServicesResponse) Reset() { *x = ListServicesResponse{} - mi := &file_openshell_proto_msgTypes[60] + mi := &file_openshell_proto_msgTypes[61] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4281,7 +4327,7 @@ func (x *ListServicesResponse) String() string { func (*ListServicesResponse) ProtoMessage() {} func (x *ListServicesResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[60] + mi := &file_openshell_proto_msgTypes[61] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4294,7 +4340,7 @@ func (x *ListServicesResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListServicesResponse.ProtoReflect.Descriptor instead. func (*ListServicesResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{60} + return file_openshell_proto_rawDescGZIP(), []int{61} } func (x *ListServicesResponse) GetServices() []*ServiceEndpointResponse { @@ -4319,7 +4365,7 @@ type DeleteServiceRequest struct { func (x *DeleteServiceRequest) Reset() { *x = DeleteServiceRequest{} - mi := &file_openshell_proto_msgTypes[61] + mi := &file_openshell_proto_msgTypes[62] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4331,7 +4377,7 @@ func (x *DeleteServiceRequest) String() string { func (*DeleteServiceRequest) ProtoMessage() {} func (x *DeleteServiceRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[61] + mi := &file_openshell_proto_msgTypes[62] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4344,7 +4390,7 @@ func (x *DeleteServiceRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteServiceRequest.ProtoReflect.Descriptor instead. func (*DeleteServiceRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{61} + return file_openshell_proto_rawDescGZIP(), []int{62} } func (x *DeleteServiceRequest) GetSandbox() string { @@ -4379,7 +4425,7 @@ type DeleteServiceResponse struct { func (x *DeleteServiceResponse) Reset() { *x = DeleteServiceResponse{} - mi := &file_openshell_proto_msgTypes[62] + mi := &file_openshell_proto_msgTypes[63] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4391,7 +4437,7 @@ func (x *DeleteServiceResponse) String() string { func (*DeleteServiceResponse) ProtoMessage() {} func (x *DeleteServiceResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[62] + mi := &file_openshell_proto_msgTypes[63] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4404,7 +4450,7 @@ func (x *DeleteServiceResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteServiceResponse.ProtoReflect.Descriptor instead. func (*DeleteServiceResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{62} + return file_openshell_proto_rawDescGZIP(), []int{63} } func (x *DeleteServiceResponse) GetDeleted() bool { @@ -4435,7 +4481,7 @@ type ServiceEndpoint struct { func (x *ServiceEndpoint) Reset() { *x = ServiceEndpoint{} - mi := &file_openshell_proto_msgTypes[63] + mi := &file_openshell_proto_msgTypes[64] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4447,7 +4493,7 @@ func (x *ServiceEndpoint) String() string { func (*ServiceEndpoint) ProtoMessage() {} func (x *ServiceEndpoint) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[63] + mi := &file_openshell_proto_msgTypes[64] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4460,7 +4506,7 @@ func (x *ServiceEndpoint) ProtoReflect() protoreflect.Message { // Deprecated: Use ServiceEndpoint.ProtoReflect.Descriptor instead. func (*ServiceEndpoint) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{63} + return file_openshell_proto_rawDescGZIP(), []int{64} } func (x *ServiceEndpoint) GetMetadata() *datamodelv1.ObjectMeta { @@ -4516,7 +4562,7 @@ type ServiceEndpointResponse struct { func (x *ServiceEndpointResponse) Reset() { *x = ServiceEndpointResponse{} - mi := &file_openshell_proto_msgTypes[64] + mi := &file_openshell_proto_msgTypes[65] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4528,7 +4574,7 @@ func (x *ServiceEndpointResponse) String() string { func (*ServiceEndpointResponse) ProtoMessage() {} func (x *ServiceEndpointResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[64] + mi := &file_openshell_proto_msgTypes[65] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4541,7 +4587,7 @@ func (x *ServiceEndpointResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ServiceEndpointResponse.ProtoReflect.Descriptor instead. func (*ServiceEndpointResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{64} + return file_openshell_proto_rawDescGZIP(), []int{65} } func (x *ServiceEndpointResponse) GetEndpoint() *ServiceEndpoint { @@ -4569,7 +4615,7 @@ type RevokeSshSessionRequest struct { func (x *RevokeSshSessionRequest) Reset() { *x = RevokeSshSessionRequest{} - mi := &file_openshell_proto_msgTypes[65] + mi := &file_openshell_proto_msgTypes[66] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4581,7 +4627,7 @@ func (x *RevokeSshSessionRequest) String() string { func (*RevokeSshSessionRequest) ProtoMessage() {} func (x *RevokeSshSessionRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[65] + mi := &file_openshell_proto_msgTypes[66] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4594,7 +4640,7 @@ func (x *RevokeSshSessionRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use RevokeSshSessionRequest.ProtoReflect.Descriptor instead. func (*RevokeSshSessionRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{65} + return file_openshell_proto_rawDescGZIP(), []int{66} } func (x *RevokeSshSessionRequest) GetToken() string { @@ -4615,7 +4661,7 @@ type RevokeSshSessionResponse struct { func (x *RevokeSshSessionResponse) Reset() { *x = RevokeSshSessionResponse{} - mi := &file_openshell_proto_msgTypes[66] + mi := &file_openshell_proto_msgTypes[67] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4627,7 +4673,7 @@ func (x *RevokeSshSessionResponse) String() string { func (*RevokeSshSessionResponse) ProtoMessage() {} func (x *RevokeSshSessionResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[66] + mi := &file_openshell_proto_msgTypes[67] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4640,7 +4686,7 @@ func (x *RevokeSshSessionResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use RevokeSshSessionResponse.ProtoReflect.Descriptor instead. func (*RevokeSshSessionResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{66} + return file_openshell_proto_rawDescGZIP(), []int{67} } func (x *RevokeSshSessionResponse) GetRevoked() bool { @@ -4683,7 +4729,7 @@ type ExecSandboxRequest struct { func (x *ExecSandboxRequest) Reset() { *x = ExecSandboxRequest{} - mi := &file_openshell_proto_msgTypes[67] + mi := &file_openshell_proto_msgTypes[68] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4695,7 +4741,7 @@ func (x *ExecSandboxRequest) String() string { func (*ExecSandboxRequest) ProtoMessage() {} func (x *ExecSandboxRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[67] + mi := &file_openshell_proto_msgTypes[68] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4708,7 +4754,7 @@ func (x *ExecSandboxRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ExecSandboxRequest.ProtoReflect.Descriptor instead. func (*ExecSandboxRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{67} + return file_openshell_proto_rawDescGZIP(), []int{68} } func (x *ExecSandboxRequest) GetSandboxId() string { @@ -4791,7 +4837,7 @@ type ExecSandboxStdout struct { func (x *ExecSandboxStdout) Reset() { *x = ExecSandboxStdout{} - mi := &file_openshell_proto_msgTypes[68] + mi := &file_openshell_proto_msgTypes[69] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4803,7 +4849,7 @@ func (x *ExecSandboxStdout) String() string { func (*ExecSandboxStdout) ProtoMessage() {} func (x *ExecSandboxStdout) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[68] + mi := &file_openshell_proto_msgTypes[69] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4816,7 +4862,7 @@ func (x *ExecSandboxStdout) ProtoReflect() protoreflect.Message { // Deprecated: Use ExecSandboxStdout.ProtoReflect.Descriptor instead. func (*ExecSandboxStdout) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{68} + return file_openshell_proto_rawDescGZIP(), []int{69} } func (x *ExecSandboxStdout) GetData() []byte { @@ -4836,7 +4882,7 @@ type ExecSandboxStderr struct { func (x *ExecSandboxStderr) Reset() { *x = ExecSandboxStderr{} - mi := &file_openshell_proto_msgTypes[69] + mi := &file_openshell_proto_msgTypes[70] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4848,7 +4894,7 @@ func (x *ExecSandboxStderr) String() string { func (*ExecSandboxStderr) ProtoMessage() {} func (x *ExecSandboxStderr) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[69] + mi := &file_openshell_proto_msgTypes[70] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4861,7 +4907,7 @@ func (x *ExecSandboxStderr) ProtoReflect() protoreflect.Message { // Deprecated: Use ExecSandboxStderr.ProtoReflect.Descriptor instead. func (*ExecSandboxStderr) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{69} + return file_openshell_proto_rawDescGZIP(), []int{70} } func (x *ExecSandboxStderr) GetData() []byte { @@ -4881,7 +4927,7 @@ type ExecSandboxExit struct { func (x *ExecSandboxExit) Reset() { *x = ExecSandboxExit{} - mi := &file_openshell_proto_msgTypes[70] + mi := &file_openshell_proto_msgTypes[71] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4893,7 +4939,7 @@ func (x *ExecSandboxExit) String() string { func (*ExecSandboxExit) ProtoMessage() {} func (x *ExecSandboxExit) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[70] + mi := &file_openshell_proto_msgTypes[71] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4906,7 +4952,7 @@ func (x *ExecSandboxExit) ProtoReflect() protoreflect.Message { // Deprecated: Use ExecSandboxExit.ProtoReflect.Descriptor instead. func (*ExecSandboxExit) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{70} + return file_openshell_proto_rawDescGZIP(), []int{71} } func (x *ExecSandboxExit) GetExitCode() int32 { @@ -4931,7 +4977,7 @@ type ExecSandboxEvent struct { func (x *ExecSandboxEvent) Reset() { *x = ExecSandboxEvent{} - mi := &file_openshell_proto_msgTypes[71] + mi := &file_openshell_proto_msgTypes[72] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4943,7 +4989,7 @@ func (x *ExecSandboxEvent) String() string { func (*ExecSandboxEvent) ProtoMessage() {} func (x *ExecSandboxEvent) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[71] + mi := &file_openshell_proto_msgTypes[72] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4956,7 +5002,7 @@ func (x *ExecSandboxEvent) ProtoReflect() protoreflect.Message { // Deprecated: Use ExecSandboxEvent.ProtoReflect.Descriptor instead. func (*ExecSandboxEvent) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{71} + return file_openshell_proto_rawDescGZIP(), []int{72} } func (x *ExecSandboxEvent) GetPayload() isExecSandboxEvent_Payload { @@ -5038,7 +5084,7 @@ type TcpForwardInit struct { func (x *TcpForwardInit) Reset() { *x = TcpForwardInit{} - mi := &file_openshell_proto_msgTypes[72] + mi := &file_openshell_proto_msgTypes[73] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5050,7 +5096,7 @@ func (x *TcpForwardInit) String() string { func (*TcpForwardInit) ProtoMessage() {} func (x *TcpForwardInit) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[72] + mi := &file_openshell_proto_msgTypes[73] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5063,7 +5109,7 @@ func (x *TcpForwardInit) ProtoReflect() protoreflect.Message { // Deprecated: Use TcpForwardInit.ProtoReflect.Descriptor instead. func (*TcpForwardInit) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{72} + return file_openshell_proto_rawDescGZIP(), []int{73} } func (x *TcpForwardInit) GetSandboxId() string { @@ -5142,7 +5188,7 @@ type TcpForwardFrame struct { func (x *TcpForwardFrame) Reset() { *x = TcpForwardFrame{} - mi := &file_openshell_proto_msgTypes[73] + mi := &file_openshell_proto_msgTypes[74] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5154,7 +5200,7 @@ func (x *TcpForwardFrame) String() string { func (*TcpForwardFrame) ProtoMessage() {} func (x *TcpForwardFrame) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[73] + mi := &file_openshell_proto_msgTypes[74] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5167,7 +5213,7 @@ func (x *TcpForwardFrame) ProtoReflect() protoreflect.Message { // Deprecated: Use TcpForwardFrame.ProtoReflect.Descriptor instead. func (*TcpForwardFrame) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{73} + return file_openshell_proto_rawDescGZIP(), []int{74} } func (x *TcpForwardFrame) GetPayload() isTcpForwardFrame_Payload { @@ -5226,7 +5272,7 @@ type ExecSandboxInput struct { func (x *ExecSandboxInput) Reset() { *x = ExecSandboxInput{} - mi := &file_openshell_proto_msgTypes[74] + mi := &file_openshell_proto_msgTypes[75] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5238,7 +5284,7 @@ func (x *ExecSandboxInput) String() string { func (*ExecSandboxInput) ProtoMessage() {} func (x *ExecSandboxInput) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[74] + mi := &file_openshell_proto_msgTypes[75] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5251,7 +5297,7 @@ func (x *ExecSandboxInput) ProtoReflect() protoreflect.Message { // Deprecated: Use ExecSandboxInput.ProtoReflect.Descriptor instead. func (*ExecSandboxInput) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{74} + return file_openshell_proto_rawDescGZIP(), []int{75} } func (x *ExecSandboxInput) GetPayload() isExecSandboxInput_Payload { @@ -5324,7 +5370,7 @@ type ExecSandboxWindowResize struct { func (x *ExecSandboxWindowResize) Reset() { *x = ExecSandboxWindowResize{} - mi := &file_openshell_proto_msgTypes[75] + mi := &file_openshell_proto_msgTypes[76] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5336,7 +5382,7 @@ func (x *ExecSandboxWindowResize) String() string { func (*ExecSandboxWindowResize) ProtoMessage() {} func (x *ExecSandboxWindowResize) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[75] + mi := &file_openshell_proto_msgTypes[76] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5349,7 +5395,7 @@ func (x *ExecSandboxWindowResize) ProtoReflect() protoreflect.Message { // Deprecated: Use ExecSandboxWindowResize.ProtoReflect.Descriptor instead. func (*ExecSandboxWindowResize) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{75} + return file_openshell_proto_rawDescGZIP(), []int{76} } func (x *ExecSandboxWindowResize) GetCols() uint32 { @@ -5386,7 +5432,7 @@ type SshSession struct { func (x *SshSession) Reset() { *x = SshSession{} - mi := &file_openshell_proto_msgTypes[76] + mi := &file_openshell_proto_msgTypes[77] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5398,7 +5444,7 @@ func (x *SshSession) String() string { func (*SshSession) ProtoMessage() {} func (x *SshSession) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[76] + mi := &file_openshell_proto_msgTypes[77] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5411,7 +5457,7 @@ func (x *SshSession) ProtoReflect() protoreflect.Message { // Deprecated: Use SshSession.ProtoReflect.Descriptor instead. func (*SshSession) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{76} + return file_openshell_proto_rawDescGZIP(), []int{77} } func (x *SshSession) GetMetadata() *datamodelv1.ObjectMeta { @@ -5480,7 +5526,7 @@ type WatchSandboxRequest struct { func (x *WatchSandboxRequest) Reset() { *x = WatchSandboxRequest{} - mi := &file_openshell_proto_msgTypes[77] + mi := &file_openshell_proto_msgTypes[78] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5492,7 +5538,7 @@ func (x *WatchSandboxRequest) String() string { func (*WatchSandboxRequest) ProtoMessage() {} func (x *WatchSandboxRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[77] + mi := &file_openshell_proto_msgTypes[78] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5505,7 +5551,7 @@ func (x *WatchSandboxRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use WatchSandboxRequest.ProtoReflect.Descriptor instead. func (*WatchSandboxRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{77} + return file_openshell_proto_rawDescGZIP(), []int{78} } func (x *WatchSandboxRequest) GetId() string { @@ -5595,7 +5641,7 @@ type SandboxStreamEvent struct { func (x *SandboxStreamEvent) Reset() { *x = SandboxStreamEvent{} - mi := &file_openshell_proto_msgTypes[78] + mi := &file_openshell_proto_msgTypes[79] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5607,7 +5653,7 @@ func (x *SandboxStreamEvent) String() string { func (*SandboxStreamEvent) ProtoMessage() {} func (x *SandboxStreamEvent) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[78] + mi := &file_openshell_proto_msgTypes[79] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5620,7 +5666,7 @@ func (x *SandboxStreamEvent) ProtoReflect() protoreflect.Message { // Deprecated: Use SandboxStreamEvent.ProtoReflect.Descriptor instead. func (*SandboxStreamEvent) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{78} + return file_openshell_proto_rawDescGZIP(), []int{79} } func (x *SandboxStreamEvent) GetPayload() isSandboxStreamEvent_Payload { @@ -5733,7 +5779,7 @@ type SandboxLogLine struct { func (x *SandboxLogLine) Reset() { *x = SandboxLogLine{} - mi := &file_openshell_proto_msgTypes[79] + mi := &file_openshell_proto_msgTypes[80] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5745,7 +5791,7 @@ func (x *SandboxLogLine) String() string { func (*SandboxLogLine) ProtoMessage() {} func (x *SandboxLogLine) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[79] + mi := &file_openshell_proto_msgTypes[80] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5758,7 +5804,7 @@ func (x *SandboxLogLine) ProtoReflect() protoreflect.Message { // Deprecated: Use SandboxLogLine.ProtoReflect.Descriptor instead. func (*SandboxLogLine) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{79} + return file_openshell_proto_rawDescGZIP(), []int{80} } func (x *SandboxLogLine) GetSandboxId() string { @@ -5819,7 +5865,7 @@ type SandboxStreamWarning struct { func (x *SandboxStreamWarning) Reset() { *x = SandboxStreamWarning{} - mi := &file_openshell_proto_msgTypes[80] + mi := &file_openshell_proto_msgTypes[81] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5831,7 +5877,7 @@ func (x *SandboxStreamWarning) String() string { func (*SandboxStreamWarning) ProtoMessage() {} func (x *SandboxStreamWarning) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[80] + mi := &file_openshell_proto_msgTypes[81] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5844,7 +5890,7 @@ func (x *SandboxStreamWarning) ProtoReflect() protoreflect.Message { // Deprecated: Use SandboxStreamWarning.ProtoReflect.Descriptor instead. func (*SandboxStreamWarning) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{80} + return file_openshell_proto_rawDescGZIP(), []int{81} } func (x *SandboxStreamWarning) GetMessage() string { @@ -5866,7 +5912,7 @@ type CreateProviderRequest struct { func (x *CreateProviderRequest) Reset() { *x = CreateProviderRequest{} - mi := &file_openshell_proto_msgTypes[81] + mi := &file_openshell_proto_msgTypes[82] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5878,7 +5924,7 @@ func (x *CreateProviderRequest) String() string { func (*CreateProviderRequest) ProtoMessage() {} func (x *CreateProviderRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[81] + mi := &file_openshell_proto_msgTypes[82] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5891,7 +5937,7 @@ func (x *CreateProviderRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use CreateProviderRequest.ProtoReflect.Descriptor instead. func (*CreateProviderRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{81} + return file_openshell_proto_rawDescGZIP(), []int{82} } func (x *CreateProviderRequest) GetProvider() *datamodelv1.Provider { @@ -5920,7 +5966,7 @@ type GetProviderRequest struct { func (x *GetProviderRequest) Reset() { *x = GetProviderRequest{} - mi := &file_openshell_proto_msgTypes[82] + mi := &file_openshell_proto_msgTypes[83] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5932,7 +5978,7 @@ func (x *GetProviderRequest) String() string { func (*GetProviderRequest) ProtoMessage() {} func (x *GetProviderRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[82] + mi := &file_openshell_proto_msgTypes[83] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5945,7 +5991,7 @@ func (x *GetProviderRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetProviderRequest.ProtoReflect.Descriptor instead. func (*GetProviderRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{82} + return file_openshell_proto_rawDescGZIP(), []int{83} } func (x *GetProviderRequest) GetName() string { @@ -5977,7 +6023,7 @@ type ListProvidersRequest struct { func (x *ListProvidersRequest) Reset() { *x = ListProvidersRequest{} - mi := &file_openshell_proto_msgTypes[83] + mi := &file_openshell_proto_msgTypes[84] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5989,7 +6035,7 @@ func (x *ListProvidersRequest) String() string { func (*ListProvidersRequest) ProtoMessage() {} func (x *ListProvidersRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[83] + mi := &file_openshell_proto_msgTypes[84] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6002,7 +6048,7 @@ func (x *ListProvidersRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListProvidersRequest.ProtoReflect.Descriptor instead. func (*ListProvidersRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{83} + return file_openshell_proto_rawDescGZIP(), []int{84} } func (x *ListProvidersRequest) GetLimit() uint32 { @@ -6048,7 +6094,7 @@ type UpdateProviderRequest struct { func (x *UpdateProviderRequest) Reset() { *x = UpdateProviderRequest{} - mi := &file_openshell_proto_msgTypes[84] + mi := &file_openshell_proto_msgTypes[85] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6060,7 +6106,7 @@ func (x *UpdateProviderRequest) String() string { func (*UpdateProviderRequest) ProtoMessage() {} func (x *UpdateProviderRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[84] + mi := &file_openshell_proto_msgTypes[85] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6073,7 +6119,7 @@ func (x *UpdateProviderRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use UpdateProviderRequest.ProtoReflect.Descriptor instead. func (*UpdateProviderRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{84} + return file_openshell_proto_rawDescGZIP(), []int{85} } func (x *UpdateProviderRequest) GetProvider() *datamodelv1.Provider { @@ -6109,7 +6155,7 @@ type DeleteProviderRequest struct { func (x *DeleteProviderRequest) Reset() { *x = DeleteProviderRequest{} - mi := &file_openshell_proto_msgTypes[85] + mi := &file_openshell_proto_msgTypes[86] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6121,7 +6167,7 @@ func (x *DeleteProviderRequest) String() string { func (*DeleteProviderRequest) ProtoMessage() {} func (x *DeleteProviderRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[85] + mi := &file_openshell_proto_msgTypes[86] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6134,7 +6180,7 @@ func (x *DeleteProviderRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteProviderRequest.ProtoReflect.Descriptor instead. func (*DeleteProviderRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{85} + return file_openshell_proto_rawDescGZIP(), []int{86} } func (x *DeleteProviderRequest) GetName() string { @@ -6161,7 +6207,7 @@ type ProviderResponse struct { func (x *ProviderResponse) Reset() { *x = ProviderResponse{} - mi := &file_openshell_proto_msgTypes[86] + mi := &file_openshell_proto_msgTypes[87] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6173,7 +6219,7 @@ func (x *ProviderResponse) String() string { func (*ProviderResponse) ProtoMessage() {} func (x *ProviderResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[86] + mi := &file_openshell_proto_msgTypes[87] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6186,7 +6232,7 @@ func (x *ProviderResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ProviderResponse.ProtoReflect.Descriptor instead. func (*ProviderResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{86} + return file_openshell_proto_rawDescGZIP(), []int{87} } func (x *ProviderResponse) GetProvider() *datamodelv1.Provider { @@ -6206,7 +6252,7 @@ type ListProvidersResponse struct { func (x *ListProvidersResponse) Reset() { *x = ListProvidersResponse{} - mi := &file_openshell_proto_msgTypes[87] + mi := &file_openshell_proto_msgTypes[88] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6218,7 +6264,7 @@ func (x *ListProvidersResponse) String() string { func (*ListProvidersResponse) ProtoMessage() {} func (x *ListProvidersResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[87] + mi := &file_openshell_proto_msgTypes[88] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6231,7 +6277,7 @@ func (x *ListProvidersResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListProvidersResponse.ProtoReflect.Descriptor instead. func (*ListProvidersResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{87} + return file_openshell_proto_rawDescGZIP(), []int{88} } func (x *ListProvidersResponse) GetProviders() []*datamodelv1.Provider { @@ -6255,7 +6301,7 @@ type ListProviderProfilesRequest struct { func (x *ListProviderProfilesRequest) Reset() { *x = ListProviderProfilesRequest{} - mi := &file_openshell_proto_msgTypes[88] + mi := &file_openshell_proto_msgTypes[89] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6267,7 +6313,7 @@ func (x *ListProviderProfilesRequest) String() string { func (*ListProviderProfilesRequest) ProtoMessage() {} func (x *ListProviderProfilesRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[88] + mi := &file_openshell_proto_msgTypes[89] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6280,7 +6326,7 @@ func (x *ListProviderProfilesRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListProviderProfilesRequest.ProtoReflect.Descriptor instead. func (*ListProviderProfilesRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{88} + return file_openshell_proto_rawDescGZIP(), []int{89} } func (x *ListProviderProfilesRequest) GetLimit() uint32 { @@ -6318,7 +6364,7 @@ type GetProviderProfileRequest struct { func (x *GetProviderProfileRequest) Reset() { *x = GetProviderProfileRequest{} - mi := &file_openshell_proto_msgTypes[89] + mi := &file_openshell_proto_msgTypes[90] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6330,7 +6376,7 @@ func (x *GetProviderProfileRequest) String() string { func (*GetProviderProfileRequest) ProtoMessage() {} func (x *GetProviderProfileRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[89] + mi := &file_openshell_proto_msgTypes[90] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6343,7 +6389,7 @@ func (x *GetProviderProfileRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetProviderProfileRequest.ProtoReflect.Descriptor instead. func (*GetProviderProfileRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{89} + return file_openshell_proto_rawDescGZIP(), []int{90} } func (x *GetProviderProfileRequest) GetId() string { @@ -6371,7 +6417,7 @@ type ProviderProfileImportItem struct { func (x *ProviderProfileImportItem) Reset() { *x = ProviderProfileImportItem{} - mi := &file_openshell_proto_msgTypes[90] + mi := &file_openshell_proto_msgTypes[91] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6383,7 +6429,7 @@ func (x *ProviderProfileImportItem) String() string { func (*ProviderProfileImportItem) ProtoMessage() {} func (x *ProviderProfileImportItem) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[90] + mi := &file_openshell_proto_msgTypes[91] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6396,7 +6442,7 @@ func (x *ProviderProfileImportItem) ProtoReflect() protoreflect.Message { // Deprecated: Use ProviderProfileImportItem.ProtoReflect.Descriptor instead. func (*ProviderProfileImportItem) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{90} + return file_openshell_proto_rawDescGZIP(), []int{91} } func (x *ProviderProfileImportItem) GetProfile() *ProviderProfile { @@ -6427,7 +6473,7 @@ type ProviderProfileDiagnostic struct { func (x *ProviderProfileDiagnostic) Reset() { *x = ProviderProfileDiagnostic{} - mi := &file_openshell_proto_msgTypes[91] + mi := &file_openshell_proto_msgTypes[92] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6439,7 +6485,7 @@ func (x *ProviderProfileDiagnostic) String() string { func (*ProviderProfileDiagnostic) ProtoMessage() {} func (x *ProviderProfileDiagnostic) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[91] + mi := &file_openshell_proto_msgTypes[92] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6452,7 +6498,7 @@ func (x *ProviderProfileDiagnostic) ProtoReflect() protoreflect.Message { // Deprecated: Use ProviderProfileDiagnostic.ProtoReflect.Descriptor instead. func (*ProviderProfileDiagnostic) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{91} + return file_openshell_proto_rawDescGZIP(), []int{92} } func (x *ProviderProfileDiagnostic) GetSource() string { @@ -6509,7 +6555,7 @@ type ProviderCredentialTokenGrantAudienceOverride struct { func (x *ProviderCredentialTokenGrantAudienceOverride) Reset() { *x = ProviderCredentialTokenGrantAudienceOverride{} - mi := &file_openshell_proto_msgTypes[92] + mi := &file_openshell_proto_msgTypes[93] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6521,7 +6567,7 @@ func (x *ProviderCredentialTokenGrantAudienceOverride) String() string { func (*ProviderCredentialTokenGrantAudienceOverride) ProtoMessage() {} func (x *ProviderCredentialTokenGrantAudienceOverride) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[92] + mi := &file_openshell_proto_msgTypes[93] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6534,7 +6580,7 @@ func (x *ProviderCredentialTokenGrantAudienceOverride) ProtoReflect() protorefle // Deprecated: Use ProviderCredentialTokenGrantAudienceOverride.ProtoReflect.Descriptor instead. func (*ProviderCredentialTokenGrantAudienceOverride) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{92} + return file_openshell_proto_rawDescGZIP(), []int{93} } func (x *ProviderCredentialTokenGrantAudienceOverride) GetHost() string { @@ -6588,7 +6634,7 @@ type ProviderCredentialTokenGrantSubjectToken struct { func (x *ProviderCredentialTokenGrantSubjectToken) Reset() { *x = ProviderCredentialTokenGrantSubjectToken{} - mi := &file_openshell_proto_msgTypes[93] + mi := &file_openshell_proto_msgTypes[94] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6600,7 +6646,7 @@ func (x *ProviderCredentialTokenGrantSubjectToken) String() string { func (*ProviderCredentialTokenGrantSubjectToken) ProtoMessage() {} func (x *ProviderCredentialTokenGrantSubjectToken) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[93] + mi := &file_openshell_proto_msgTypes[94] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6613,7 +6659,7 @@ func (x *ProviderCredentialTokenGrantSubjectToken) ProtoReflect() protoreflect.M // Deprecated: Use ProviderCredentialTokenGrantSubjectToken.ProtoReflect.Descriptor instead. func (*ProviderCredentialTokenGrantSubjectToken) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{93} + return file_openshell_proto_rawDescGZIP(), []int{94} } func (x *ProviderCredentialTokenGrantSubjectToken) GetSource() string { @@ -6670,7 +6716,7 @@ type ProviderCredentialTokenGrant struct { func (x *ProviderCredentialTokenGrant) Reset() { *x = ProviderCredentialTokenGrant{} - mi := &file_openshell_proto_msgTypes[94] + mi := &file_openshell_proto_msgTypes[95] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6682,7 +6728,7 @@ func (x *ProviderCredentialTokenGrant) String() string { func (*ProviderCredentialTokenGrant) ProtoMessage() {} func (x *ProviderCredentialTokenGrant) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[94] + mi := &file_openshell_proto_msgTypes[95] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6695,7 +6741,7 @@ func (x *ProviderCredentialTokenGrant) ProtoReflect() protoreflect.Message { // Deprecated: Use ProviderCredentialTokenGrant.ProtoReflect.Descriptor instead. func (*ProviderCredentialTokenGrant) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{94} + return file_openshell_proto_rawDescGZIP(), []int{95} } func (x *ProviderCredentialTokenGrant) GetTokenEndpoint() string { @@ -6787,7 +6833,7 @@ type ProviderProfileCredential struct { func (x *ProviderProfileCredential) Reset() { *x = ProviderProfileCredential{} - mi := &file_openshell_proto_msgTypes[95] + mi := &file_openshell_proto_msgTypes[96] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6799,7 +6845,7 @@ func (x *ProviderProfileCredential) String() string { func (*ProviderProfileCredential) ProtoMessage() {} func (x *ProviderProfileCredential) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[95] + mi := &file_openshell_proto_msgTypes[96] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6812,7 +6858,7 @@ func (x *ProviderProfileCredential) ProtoReflect() protoreflect.Message { // Deprecated: Use ProviderProfileCredential.ProtoReflect.Descriptor instead. func (*ProviderProfileCredential) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{95} + return file_openshell_proto_rawDescGZIP(), []int{96} } func (x *ProviderProfileCredential) GetName() string { @@ -6897,7 +6943,7 @@ type ProviderCredentialRefreshMaterial struct { func (x *ProviderCredentialRefreshMaterial) Reset() { *x = ProviderCredentialRefreshMaterial{} - mi := &file_openshell_proto_msgTypes[96] + mi := &file_openshell_proto_msgTypes[97] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6909,7 +6955,7 @@ func (x *ProviderCredentialRefreshMaterial) String() string { func (*ProviderCredentialRefreshMaterial) ProtoMessage() {} func (x *ProviderCredentialRefreshMaterial) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[96] + mi := &file_openshell_proto_msgTypes[97] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6922,7 +6968,7 @@ func (x *ProviderCredentialRefreshMaterial) ProtoReflect() protoreflect.Message // Deprecated: Use ProviderCredentialRefreshMaterial.ProtoReflect.Descriptor instead. func (*ProviderCredentialRefreshMaterial) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{96} + return file_openshell_proto_rawDescGZIP(), []int{97} } func (x *ProviderCredentialRefreshMaterial) GetName() string { @@ -6967,7 +7013,7 @@ type ProviderCredentialRefreshOutput struct { func (x *ProviderCredentialRefreshOutput) Reset() { *x = ProviderCredentialRefreshOutput{} - mi := &file_openshell_proto_msgTypes[97] + mi := &file_openshell_proto_msgTypes[98] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6979,7 +7025,7 @@ func (x *ProviderCredentialRefreshOutput) String() string { func (*ProviderCredentialRefreshOutput) ProtoMessage() {} func (x *ProviderCredentialRefreshOutput) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[97] + mi := &file_openshell_proto_msgTypes[98] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6992,7 +7038,7 @@ func (x *ProviderCredentialRefreshOutput) ProtoReflect() protoreflect.Message { // Deprecated: Use ProviderCredentialRefreshOutput.ProtoReflect.Descriptor instead. func (*ProviderCredentialRefreshOutput) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{97} + return file_openshell_proto_rawDescGZIP(), []int{98} } func (x *ProviderCredentialRefreshOutput) GetOutput() string { @@ -7024,7 +7070,7 @@ type ProviderCredentialRefresh struct { func (x *ProviderCredentialRefresh) Reset() { *x = ProviderCredentialRefresh{} - mi := &file_openshell_proto_msgTypes[98] + mi := &file_openshell_proto_msgTypes[99] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7036,7 +7082,7 @@ func (x *ProviderCredentialRefresh) String() string { func (*ProviderCredentialRefresh) ProtoMessage() {} func (x *ProviderCredentialRefresh) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[98] + mi := &file_openshell_proto_msgTypes[99] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7049,7 +7095,7 @@ func (x *ProviderCredentialRefresh) ProtoReflect() protoreflect.Message { // Deprecated: Use ProviderCredentialRefresh.ProtoReflect.Descriptor instead. func (*ProviderCredentialRefresh) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{98} + return file_openshell_proto_rawDescGZIP(), []int{99} } func (x *ProviderCredentialRefresh) GetStrategy() ProviderCredentialRefreshStrategy { @@ -7132,7 +7178,7 @@ type ProviderCredentialRefreshStatus struct { func (x *ProviderCredentialRefreshStatus) Reset() { *x = ProviderCredentialRefreshStatus{} - mi := &file_openshell_proto_msgTypes[99] + mi := &file_openshell_proto_msgTypes[100] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7144,7 +7190,7 @@ func (x *ProviderCredentialRefreshStatus) String() string { func (*ProviderCredentialRefreshStatus) ProtoMessage() {} func (x *ProviderCredentialRefreshStatus) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[99] + mi := &file_openshell_proto_msgTypes[100] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7157,7 +7203,7 @@ func (x *ProviderCredentialRefreshStatus) ProtoReflect() protoreflect.Message { // Deprecated: Use ProviderCredentialRefreshStatus.ProtoReflect.Descriptor instead. func (*ProviderCredentialRefreshStatus) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{99} + return file_openshell_proto_rawDescGZIP(), []int{100} } func (x *ProviderCredentialRefreshStatus) GetProviderName() string { @@ -7262,7 +7308,7 @@ type ProviderProfileDiscovery struct { func (x *ProviderProfileDiscovery) Reset() { *x = ProviderProfileDiscovery{} - mi := &file_openshell_proto_msgTypes[100] + mi := &file_openshell_proto_msgTypes[101] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7274,7 +7320,7 @@ func (x *ProviderProfileDiscovery) String() string { func (*ProviderProfileDiscovery) ProtoMessage() {} func (x *ProviderProfileDiscovery) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[100] + mi := &file_openshell_proto_msgTypes[101] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7287,7 +7333,7 @@ func (x *ProviderProfileDiscovery) ProtoReflect() protoreflect.Message { // Deprecated: Use ProviderProfileDiscovery.ProtoReflect.Descriptor instead. func (*ProviderProfileDiscovery) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{100} + return file_openshell_proto_rawDescGZIP(), []int{101} } func (x *ProviderProfileDiscovery) GetCredentials() []string { @@ -7351,7 +7397,7 @@ type StoredProviderCredentialRefreshState struct { func (x *StoredProviderCredentialRefreshState) Reset() { *x = StoredProviderCredentialRefreshState{} - mi := &file_openshell_proto_msgTypes[101] + mi := &file_openshell_proto_msgTypes[102] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7363,7 +7409,7 @@ func (x *StoredProviderCredentialRefreshState) String() string { func (*StoredProviderCredentialRefreshState) ProtoMessage() {} func (x *StoredProviderCredentialRefreshState) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[101] + mi := &file_openshell_proto_msgTypes[102] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7376,7 +7422,7 @@ func (x *StoredProviderCredentialRefreshState) ProtoReflect() protoreflect.Messa // Deprecated: Use StoredProviderCredentialRefreshState.ProtoReflect.Descriptor instead. func (*StoredProviderCredentialRefreshState) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{101} + return file_openshell_proto_rawDescGZIP(), []int{102} } func (x *StoredProviderCredentialRefreshState) GetMetadata() *datamodelv1.ObjectMeta { @@ -7559,7 +7605,7 @@ type StoredRefreshMaterialDeletion struct { func (x *StoredRefreshMaterialDeletion) Reset() { *x = StoredRefreshMaterialDeletion{} - mi := &file_openshell_proto_msgTypes[102] + mi := &file_openshell_proto_msgTypes[103] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7571,7 +7617,7 @@ func (x *StoredRefreshMaterialDeletion) String() string { func (*StoredRefreshMaterialDeletion) ProtoMessage() {} func (x *StoredRefreshMaterialDeletion) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[102] + mi := &file_openshell_proto_msgTypes[103] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7584,7 +7630,7 @@ func (x *StoredRefreshMaterialDeletion) ProtoReflect() protoreflect.Message { // Deprecated: Use StoredRefreshMaterialDeletion.ProtoReflect.Descriptor instead. func (*StoredRefreshMaterialDeletion) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{102} + return file_openshell_proto_rawDescGZIP(), []int{103} } func (x *StoredRefreshMaterialDeletion) GetMaterialKey() string { @@ -7613,7 +7659,7 @@ type GetProviderRefreshStatusRequest struct { func (x *GetProviderRefreshStatusRequest) Reset() { *x = GetProviderRefreshStatusRequest{} - mi := &file_openshell_proto_msgTypes[103] + mi := &file_openshell_proto_msgTypes[104] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7625,7 +7671,7 @@ func (x *GetProviderRefreshStatusRequest) String() string { func (*GetProviderRefreshStatusRequest) ProtoMessage() {} func (x *GetProviderRefreshStatusRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[103] + mi := &file_openshell_proto_msgTypes[104] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7638,7 +7684,7 @@ func (x *GetProviderRefreshStatusRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetProviderRefreshStatusRequest.ProtoReflect.Descriptor instead. func (*GetProviderRefreshStatusRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{103} + return file_openshell_proto_rawDescGZIP(), []int{104} } func (x *GetProviderRefreshStatusRequest) GetProvider() string { @@ -7671,7 +7717,7 @@ type GetProviderRefreshStatusResponse struct { func (x *GetProviderRefreshStatusResponse) Reset() { *x = GetProviderRefreshStatusResponse{} - mi := &file_openshell_proto_msgTypes[104] + mi := &file_openshell_proto_msgTypes[105] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7683,7 +7729,7 @@ func (x *GetProviderRefreshStatusResponse) String() string { func (*GetProviderRefreshStatusResponse) ProtoMessage() {} func (x *GetProviderRefreshStatusResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[104] + mi := &file_openshell_proto_msgTypes[105] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7696,7 +7742,7 @@ func (x *GetProviderRefreshStatusResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use GetProviderRefreshStatusResponse.ProtoReflect.Descriptor instead. func (*GetProviderRefreshStatusResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{104} + return file_openshell_proto_rawDescGZIP(), []int{105} } func (x *GetProviderRefreshStatusResponse) GetCredentials() []*ProviderCredentialRefreshStatus { @@ -7725,7 +7771,7 @@ type ConfigureProviderRefreshRequest struct { func (x *ConfigureProviderRefreshRequest) Reset() { *x = ConfigureProviderRefreshRequest{} - mi := &file_openshell_proto_msgTypes[105] + mi := &file_openshell_proto_msgTypes[106] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7737,7 +7783,7 @@ func (x *ConfigureProviderRefreshRequest) String() string { func (*ConfigureProviderRefreshRequest) ProtoMessage() {} func (x *ConfigureProviderRefreshRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[105] + mi := &file_openshell_proto_msgTypes[106] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7750,7 +7796,7 @@ func (x *ConfigureProviderRefreshRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ConfigureProviderRefreshRequest.ProtoReflect.Descriptor instead. func (*ConfigureProviderRefreshRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{105} + return file_openshell_proto_rawDescGZIP(), []int{106} } func (x *ConfigureProviderRefreshRequest) GetProvider() string { @@ -7811,7 +7857,7 @@ type ConfigureProviderRefreshResponse struct { func (x *ConfigureProviderRefreshResponse) Reset() { *x = ConfigureProviderRefreshResponse{} - mi := &file_openshell_proto_msgTypes[106] + mi := &file_openshell_proto_msgTypes[107] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7823,7 +7869,7 @@ func (x *ConfigureProviderRefreshResponse) String() string { func (*ConfigureProviderRefreshResponse) ProtoMessage() {} func (x *ConfigureProviderRefreshResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[106] + mi := &file_openshell_proto_msgTypes[107] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7836,7 +7882,7 @@ func (x *ConfigureProviderRefreshResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ConfigureProviderRefreshResponse.ProtoReflect.Descriptor instead. func (*ConfigureProviderRefreshResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{106} + return file_openshell_proto_rawDescGZIP(), []int{107} } func (x *ConfigureProviderRefreshResponse) GetStatus() *ProviderCredentialRefreshStatus { @@ -7858,7 +7904,7 @@ type RotateProviderCredentialRequest struct { func (x *RotateProviderCredentialRequest) Reset() { *x = RotateProviderCredentialRequest{} - mi := &file_openshell_proto_msgTypes[107] + mi := &file_openshell_proto_msgTypes[108] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7870,7 +7916,7 @@ func (x *RotateProviderCredentialRequest) String() string { func (*RotateProviderCredentialRequest) ProtoMessage() {} func (x *RotateProviderCredentialRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[107] + mi := &file_openshell_proto_msgTypes[108] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7883,7 +7929,7 @@ func (x *RotateProviderCredentialRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use RotateProviderCredentialRequest.ProtoReflect.Descriptor instead. func (*RotateProviderCredentialRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{107} + return file_openshell_proto_rawDescGZIP(), []int{108} } func (x *RotateProviderCredentialRequest) GetProvider() string { @@ -7916,7 +7962,7 @@ type RotateProviderCredentialResponse struct { func (x *RotateProviderCredentialResponse) Reset() { *x = RotateProviderCredentialResponse{} - mi := &file_openshell_proto_msgTypes[108] + mi := &file_openshell_proto_msgTypes[109] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7928,7 +7974,7 @@ func (x *RotateProviderCredentialResponse) String() string { func (*RotateProviderCredentialResponse) ProtoMessage() {} func (x *RotateProviderCredentialResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[108] + mi := &file_openshell_proto_msgTypes[109] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7941,7 +7987,7 @@ func (x *RotateProviderCredentialResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use RotateProviderCredentialResponse.ProtoReflect.Descriptor instead. func (*RotateProviderCredentialResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{108} + return file_openshell_proto_rawDescGZIP(), []int{109} } func (x *RotateProviderCredentialResponse) GetStatus() *ProviderCredentialRefreshStatus { @@ -7963,7 +8009,7 @@ type DeleteProviderRefreshRequest struct { func (x *DeleteProviderRefreshRequest) Reset() { *x = DeleteProviderRefreshRequest{} - mi := &file_openshell_proto_msgTypes[109] + mi := &file_openshell_proto_msgTypes[110] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7975,7 +8021,7 @@ func (x *DeleteProviderRefreshRequest) String() string { func (*DeleteProviderRefreshRequest) ProtoMessage() {} func (x *DeleteProviderRefreshRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[109] + mi := &file_openshell_proto_msgTypes[110] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7988,7 +8034,7 @@ func (x *DeleteProviderRefreshRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteProviderRefreshRequest.ProtoReflect.Descriptor instead. func (*DeleteProviderRefreshRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{109} + return file_openshell_proto_rawDescGZIP(), []int{110} } func (x *DeleteProviderRefreshRequest) GetProvider() string { @@ -8021,7 +8067,7 @@ type DeleteProviderRefreshResponse struct { func (x *DeleteProviderRefreshResponse) Reset() { *x = DeleteProviderRefreshResponse{} - mi := &file_openshell_proto_msgTypes[110] + mi := &file_openshell_proto_msgTypes[111] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8033,7 +8079,7 @@ func (x *DeleteProviderRefreshResponse) String() string { func (*DeleteProviderRefreshResponse) ProtoMessage() {} func (x *DeleteProviderRefreshResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[110] + mi := &file_openshell_proto_msgTypes[111] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8046,7 +8092,7 @@ func (x *DeleteProviderRefreshResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteProviderRefreshResponse.ProtoReflect.Descriptor instead. func (*DeleteProviderRefreshResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{110} + return file_openshell_proto_rawDescGZIP(), []int{111} } func (x *DeleteProviderRefreshResponse) GetDeleted() bool { @@ -8086,7 +8132,7 @@ type ProviderProfile struct { func (x *ProviderProfile) Reset() { *x = ProviderProfile{} - mi := &file_openshell_proto_msgTypes[111] + mi := &file_openshell_proto_msgTypes[112] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8098,7 +8144,7 @@ func (x *ProviderProfile) String() string { func (*ProviderProfile) ProtoMessage() {} func (x *ProviderProfile) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[111] + mi := &file_openshell_proto_msgTypes[112] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8111,7 +8157,7 @@ func (x *ProviderProfile) ProtoReflect() protoreflect.Message { // Deprecated: Use ProviderProfile.ProtoReflect.Descriptor instead. func (*ProviderProfile) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{111} + return file_openshell_proto_rawDescGZIP(), []int{112} } func (x *ProviderProfile) GetId() string { @@ -8216,7 +8262,7 @@ type StoredProviderProfile struct { func (x *StoredProviderProfile) Reset() { *x = StoredProviderProfile{} - mi := &file_openshell_proto_msgTypes[112] + mi := &file_openshell_proto_msgTypes[113] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8228,7 +8274,7 @@ func (x *StoredProviderProfile) String() string { func (*StoredProviderProfile) ProtoMessage() {} func (x *StoredProviderProfile) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[112] + mi := &file_openshell_proto_msgTypes[113] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8241,7 +8287,7 @@ func (x *StoredProviderProfile) ProtoReflect() protoreflect.Message { // Deprecated: Use StoredProviderProfile.ProtoReflect.Descriptor instead. func (*StoredProviderProfile) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{112} + return file_openshell_proto_rawDescGZIP(), []int{113} } func (x *StoredProviderProfile) GetMetadata() *datamodelv1.ObjectMeta { @@ -8268,7 +8314,7 @@ type ProviderProfileResponse struct { func (x *ProviderProfileResponse) Reset() { *x = ProviderProfileResponse{} - mi := &file_openshell_proto_msgTypes[113] + mi := &file_openshell_proto_msgTypes[114] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8280,7 +8326,7 @@ func (x *ProviderProfileResponse) String() string { func (*ProviderProfileResponse) ProtoMessage() {} func (x *ProviderProfileResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[113] + mi := &file_openshell_proto_msgTypes[114] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8293,7 +8339,7 @@ func (x *ProviderProfileResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ProviderProfileResponse.ProtoReflect.Descriptor instead. func (*ProviderProfileResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{113} + return file_openshell_proto_rawDescGZIP(), []int{114} } func (x *ProviderProfileResponse) GetProfile() *ProviderProfile { @@ -8313,7 +8359,7 @@ type ListProviderProfilesResponse struct { func (x *ListProviderProfilesResponse) Reset() { *x = ListProviderProfilesResponse{} - mi := &file_openshell_proto_msgTypes[114] + mi := &file_openshell_proto_msgTypes[115] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8325,7 +8371,7 @@ func (x *ListProviderProfilesResponse) String() string { func (*ListProviderProfilesResponse) ProtoMessage() {} func (x *ListProviderProfilesResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[114] + mi := &file_openshell_proto_msgTypes[115] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8338,7 +8384,7 @@ func (x *ListProviderProfilesResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListProviderProfilesResponse.ProtoReflect.Descriptor instead. func (*ListProviderProfilesResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{114} + return file_openshell_proto_rawDescGZIP(), []int{115} } func (x *ListProviderProfilesResponse) GetProfiles() []*ProviderProfile { @@ -8361,7 +8407,7 @@ type ImportProviderProfilesRequest struct { func (x *ImportProviderProfilesRequest) Reset() { *x = ImportProviderProfilesRequest{} - mi := &file_openshell_proto_msgTypes[115] + mi := &file_openshell_proto_msgTypes[116] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8373,7 +8419,7 @@ func (x *ImportProviderProfilesRequest) String() string { func (*ImportProviderProfilesRequest) ProtoMessage() {} func (x *ImportProviderProfilesRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[115] + mi := &file_openshell_proto_msgTypes[116] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8386,7 +8432,7 @@ func (x *ImportProviderProfilesRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ImportProviderProfilesRequest.ProtoReflect.Descriptor instead. func (*ImportProviderProfilesRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{115} + return file_openshell_proto_rawDescGZIP(), []int{116} } func (x *ImportProviderProfilesRequest) GetProfiles() []*ProviderProfileImportItem { @@ -8415,7 +8461,7 @@ type ImportProviderProfilesResponse struct { func (x *ImportProviderProfilesResponse) Reset() { *x = ImportProviderProfilesResponse{} - mi := &file_openshell_proto_msgTypes[116] + mi := &file_openshell_proto_msgTypes[117] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8427,7 +8473,7 @@ func (x *ImportProviderProfilesResponse) String() string { func (*ImportProviderProfilesResponse) ProtoMessage() {} func (x *ImportProviderProfilesResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[116] + mi := &file_openshell_proto_msgTypes[117] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8440,7 +8486,7 @@ func (x *ImportProviderProfilesResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ImportProviderProfilesResponse.ProtoReflect.Descriptor instead. func (*ImportProviderProfilesResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{116} + return file_openshell_proto_rawDescGZIP(), []int{117} } func (x *ImportProviderProfilesResponse) GetDiagnostics() []*ProviderProfileDiagnostic { @@ -8484,7 +8530,7 @@ type UpdateProviderProfilesRequest struct { func (x *UpdateProviderProfilesRequest) Reset() { *x = UpdateProviderProfilesRequest{} - mi := &file_openshell_proto_msgTypes[117] + mi := &file_openshell_proto_msgTypes[118] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8496,7 +8542,7 @@ func (x *UpdateProviderProfilesRequest) String() string { func (*UpdateProviderProfilesRequest) ProtoMessage() {} func (x *UpdateProviderProfilesRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[117] + mi := &file_openshell_proto_msgTypes[118] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8509,7 +8555,7 @@ func (x *UpdateProviderProfilesRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use UpdateProviderProfilesRequest.ProtoReflect.Descriptor instead. func (*UpdateProviderProfilesRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{117} + return file_openshell_proto_rawDescGZIP(), []int{118} } func (x *UpdateProviderProfilesRequest) GetProfile() *ProviderProfileImportItem { @@ -8552,7 +8598,7 @@ type UpdateProviderProfilesResponse struct { func (x *UpdateProviderProfilesResponse) Reset() { *x = UpdateProviderProfilesResponse{} - mi := &file_openshell_proto_msgTypes[118] + mi := &file_openshell_proto_msgTypes[119] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8564,7 +8610,7 @@ func (x *UpdateProviderProfilesResponse) String() string { func (*UpdateProviderProfilesResponse) ProtoMessage() {} func (x *UpdateProviderProfilesResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[118] + mi := &file_openshell_proto_msgTypes[119] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8577,7 +8623,7 @@ func (x *UpdateProviderProfilesResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use UpdateProviderProfilesResponse.ProtoReflect.Descriptor instead. func (*UpdateProviderProfilesResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{118} + return file_openshell_proto_rawDescGZIP(), []int{119} } func (x *UpdateProviderProfilesResponse) GetDiagnostics() []*ProviderProfileDiagnostic { @@ -8614,7 +8660,7 @@ type LintProviderProfilesRequest struct { func (x *LintProviderProfilesRequest) Reset() { *x = LintProviderProfilesRequest{} - mi := &file_openshell_proto_msgTypes[119] + mi := &file_openshell_proto_msgTypes[120] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8626,7 +8672,7 @@ func (x *LintProviderProfilesRequest) String() string { func (*LintProviderProfilesRequest) ProtoMessage() {} func (x *LintProviderProfilesRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[119] + mi := &file_openshell_proto_msgTypes[120] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8639,7 +8685,7 @@ func (x *LintProviderProfilesRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use LintProviderProfilesRequest.ProtoReflect.Descriptor instead. func (*LintProviderProfilesRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{119} + return file_openshell_proto_rawDescGZIP(), []int{120} } func (x *LintProviderProfilesRequest) GetProfiles() []*ProviderProfileImportItem { @@ -8667,7 +8713,7 @@ type LintProviderProfilesResponse struct { func (x *LintProviderProfilesResponse) Reset() { *x = LintProviderProfilesResponse{} - mi := &file_openshell_proto_msgTypes[120] + mi := &file_openshell_proto_msgTypes[121] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8679,7 +8725,7 @@ func (x *LintProviderProfilesResponse) String() string { func (*LintProviderProfilesResponse) ProtoMessage() {} func (x *LintProviderProfilesResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[120] + mi := &file_openshell_proto_msgTypes[121] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8692,7 +8738,7 @@ func (x *LintProviderProfilesResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use LintProviderProfilesResponse.ProtoReflect.Descriptor instead. func (*LintProviderProfilesResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{120} + return file_openshell_proto_rawDescGZIP(), []int{121} } func (x *LintProviderProfilesResponse) GetDiagnostics() []*ProviderProfileDiagnostic { @@ -8719,7 +8765,7 @@ type DeleteProviderResponse struct { func (x *DeleteProviderResponse) Reset() { *x = DeleteProviderResponse{} - mi := &file_openshell_proto_msgTypes[121] + mi := &file_openshell_proto_msgTypes[122] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8731,7 +8777,7 @@ func (x *DeleteProviderResponse) String() string { func (*DeleteProviderResponse) ProtoMessage() {} func (x *DeleteProviderResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[121] + mi := &file_openshell_proto_msgTypes[122] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8744,7 +8790,7 @@ func (x *DeleteProviderResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteProviderResponse.ProtoReflect.Descriptor instead. func (*DeleteProviderResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{121} + return file_openshell_proto_rawDescGZIP(), []int{122} } func (x *DeleteProviderResponse) GetDeleted() bool { @@ -8767,7 +8813,7 @@ type DeleteProviderProfileRequest struct { func (x *DeleteProviderProfileRequest) Reset() { *x = DeleteProviderProfileRequest{} - mi := &file_openshell_proto_msgTypes[122] + mi := &file_openshell_proto_msgTypes[123] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8779,7 +8825,7 @@ func (x *DeleteProviderProfileRequest) String() string { func (*DeleteProviderProfileRequest) ProtoMessage() {} func (x *DeleteProviderProfileRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[122] + mi := &file_openshell_proto_msgTypes[123] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8792,7 +8838,7 @@ func (x *DeleteProviderProfileRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteProviderProfileRequest.ProtoReflect.Descriptor instead. func (*DeleteProviderProfileRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{122} + return file_openshell_proto_rawDescGZIP(), []int{123} } func (x *DeleteProviderProfileRequest) GetId() string { @@ -8819,7 +8865,7 @@ type DeleteProviderProfileResponse struct { func (x *DeleteProviderProfileResponse) Reset() { *x = DeleteProviderProfileResponse{} - mi := &file_openshell_proto_msgTypes[123] + mi := &file_openshell_proto_msgTypes[124] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8831,7 +8877,7 @@ func (x *DeleteProviderProfileResponse) String() string { func (*DeleteProviderProfileResponse) ProtoMessage() {} func (x *DeleteProviderProfileResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[123] + mi := &file_openshell_proto_msgTypes[124] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8844,7 +8890,7 @@ func (x *DeleteProviderProfileResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteProviderProfileResponse.ProtoReflect.Descriptor instead. func (*DeleteProviderProfileResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{123} + return file_openshell_proto_rawDescGZIP(), []int{124} } func (x *DeleteProviderProfileResponse) GetDeleted() bool { @@ -8869,7 +8915,7 @@ type GetSandboxProviderEnvironmentRequest struct { func (x *GetSandboxProviderEnvironmentRequest) Reset() { *x = GetSandboxProviderEnvironmentRequest{} - mi := &file_openshell_proto_msgTypes[124] + mi := &file_openshell_proto_msgTypes[125] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8881,7 +8927,7 @@ func (x *GetSandboxProviderEnvironmentRequest) String() string { func (*GetSandboxProviderEnvironmentRequest) ProtoMessage() {} func (x *GetSandboxProviderEnvironmentRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[124] + mi := &file_openshell_proto_msgTypes[125] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8894,7 +8940,7 @@ func (x *GetSandboxProviderEnvironmentRequest) ProtoReflect() protoreflect.Messa // Deprecated: Use GetSandboxProviderEnvironmentRequest.ProtoReflect.Descriptor instead. func (*GetSandboxProviderEnvironmentRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{124} + return file_openshell_proto_rawDescGZIP(), []int{125} } func (x *GetSandboxProviderEnvironmentRequest) GetSandboxId() string { @@ -8923,7 +8969,7 @@ type StaticCredentialEndpointBinding struct { func (x *StaticCredentialEndpointBinding) Reset() { *x = StaticCredentialEndpointBinding{} - mi := &file_openshell_proto_msgTypes[125] + mi := &file_openshell_proto_msgTypes[126] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8935,7 +8981,7 @@ func (x *StaticCredentialEndpointBinding) String() string { func (*StaticCredentialEndpointBinding) ProtoMessage() {} func (x *StaticCredentialEndpointBinding) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[125] + mi := &file_openshell_proto_msgTypes[126] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8948,7 +8994,7 @@ func (x *StaticCredentialEndpointBinding) ProtoReflect() protoreflect.Message { // Deprecated: Use StaticCredentialEndpointBinding.ProtoReflect.Descriptor instead. func (*StaticCredentialEndpointBinding) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{125} + return file_openshell_proto_rawDescGZIP(), []int{126} } func (x *StaticCredentialEndpointBinding) GetHost() string { @@ -8992,7 +9038,7 @@ type StaticCredentialBinding struct { func (x *StaticCredentialBinding) Reset() { *x = StaticCredentialBinding{} - mi := &file_openshell_proto_msgTypes[126] + mi := &file_openshell_proto_msgTypes[127] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9004,7 +9050,7 @@ func (x *StaticCredentialBinding) String() string { func (*StaticCredentialBinding) ProtoMessage() {} func (x *StaticCredentialBinding) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[126] + mi := &file_openshell_proto_msgTypes[127] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9017,7 +9063,7 @@ func (x *StaticCredentialBinding) ProtoReflect() protoreflect.Message { // Deprecated: Use StaticCredentialBinding.ProtoReflect.Descriptor instead. func (*StaticCredentialBinding) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{126} + return file_openshell_proto_rawDescGZIP(), []int{127} } func (x *StaticCredentialBinding) GetEndpoints() []*StaticCredentialEndpointBinding { @@ -9068,7 +9114,7 @@ type GetSandboxProviderEnvironmentResponse struct { func (x *GetSandboxProviderEnvironmentResponse) Reset() { *x = GetSandboxProviderEnvironmentResponse{} - mi := &file_openshell_proto_msgTypes[127] + mi := &file_openshell_proto_msgTypes[128] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9080,7 +9126,7 @@ func (x *GetSandboxProviderEnvironmentResponse) String() string { func (*GetSandboxProviderEnvironmentResponse) ProtoMessage() {} func (x *GetSandboxProviderEnvironmentResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[127] + mi := &file_openshell_proto_msgTypes[128] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9093,7 +9139,7 @@ func (x *GetSandboxProviderEnvironmentResponse) ProtoReflect() protoreflect.Mess // Deprecated: Use GetSandboxProviderEnvironmentResponse.ProtoReflect.Descriptor instead. func (*GetSandboxProviderEnvironmentResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{127} + return file_openshell_proto_rawDescGZIP(), []int{128} } func (x *GetSandboxProviderEnvironmentResponse) GetEnvironment() map[string]string { @@ -9155,7 +9201,7 @@ type ExchangeProviderSubjectTokenRequest struct { func (x *ExchangeProviderSubjectTokenRequest) Reset() { *x = ExchangeProviderSubjectTokenRequest{} - mi := &file_openshell_proto_msgTypes[128] + mi := &file_openshell_proto_msgTypes[129] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9167,7 +9213,7 @@ func (x *ExchangeProviderSubjectTokenRequest) String() string { func (*ExchangeProviderSubjectTokenRequest) ProtoMessage() {} func (x *ExchangeProviderSubjectTokenRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[128] + mi := &file_openshell_proto_msgTypes[129] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9180,7 +9226,7 @@ func (x *ExchangeProviderSubjectTokenRequest) ProtoReflect() protoreflect.Messag // Deprecated: Use ExchangeProviderSubjectTokenRequest.ProtoReflect.Descriptor instead. func (*ExchangeProviderSubjectTokenRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{128} + return file_openshell_proto_rawDescGZIP(), []int{129} } func (x *ExchangeProviderSubjectTokenRequest) GetSandboxId() string { @@ -9222,7 +9268,7 @@ type ExchangeProviderSubjectTokenResponse struct { func (x *ExchangeProviderSubjectTokenResponse) Reset() { *x = ExchangeProviderSubjectTokenResponse{} - mi := &file_openshell_proto_msgTypes[129] + mi := &file_openshell_proto_msgTypes[130] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9234,7 +9280,7 @@ func (x *ExchangeProviderSubjectTokenResponse) String() string { func (*ExchangeProviderSubjectTokenResponse) ProtoMessage() {} func (x *ExchangeProviderSubjectTokenResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[129] + mi := &file_openshell_proto_msgTypes[130] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9247,7 +9293,7 @@ func (x *ExchangeProviderSubjectTokenResponse) ProtoReflect() protoreflect.Messa // Deprecated: Use ExchangeProviderSubjectTokenResponse.ProtoReflect.Descriptor instead. func (*ExchangeProviderSubjectTokenResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{129} + return file_openshell_proto_rawDescGZIP(), []int{130} } func (x *ExchangeProviderSubjectTokenResponse) GetAccessToken() string { @@ -9318,7 +9364,7 @@ type UpdateConfigRequest struct { func (x *UpdateConfigRequest) Reset() { *x = UpdateConfigRequest{} - mi := &file_openshell_proto_msgTypes[130] + mi := &file_openshell_proto_msgTypes[131] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9330,7 +9376,7 @@ func (x *UpdateConfigRequest) String() string { func (*UpdateConfigRequest) ProtoMessage() {} func (x *UpdateConfigRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[130] + mi := &file_openshell_proto_msgTypes[131] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9343,7 +9389,7 @@ func (x *UpdateConfigRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use UpdateConfigRequest.ProtoReflect.Descriptor instead. func (*UpdateConfigRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{130} + return file_openshell_proto_rawDescGZIP(), []int{131} } func (x *UpdateConfigRequest) GetName() string { @@ -9433,7 +9479,7 @@ type PolicyMergeOperation struct { func (x *PolicyMergeOperation) Reset() { *x = PolicyMergeOperation{} - mi := &file_openshell_proto_msgTypes[131] + mi := &file_openshell_proto_msgTypes[132] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9445,7 +9491,7 @@ func (x *PolicyMergeOperation) String() string { func (*PolicyMergeOperation) ProtoMessage() {} func (x *PolicyMergeOperation) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[131] + mi := &file_openshell_proto_msgTypes[132] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9458,7 +9504,7 @@ func (x *PolicyMergeOperation) ProtoReflect() protoreflect.Message { // Deprecated: Use PolicyMergeOperation.ProtoReflect.Descriptor instead. func (*PolicyMergeOperation) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{131} + return file_openshell_proto_rawDescGZIP(), []int{132} } func (x *PolicyMergeOperation) GetOperation() isPolicyMergeOperation_Operation { @@ -9572,7 +9618,7 @@ type AddNetworkRule struct { func (x *AddNetworkRule) Reset() { *x = AddNetworkRule{} - mi := &file_openshell_proto_msgTypes[132] + mi := &file_openshell_proto_msgTypes[133] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9584,7 +9630,7 @@ func (x *AddNetworkRule) String() string { func (*AddNetworkRule) ProtoMessage() {} func (x *AddNetworkRule) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[132] + mi := &file_openshell_proto_msgTypes[133] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9597,7 +9643,7 @@ func (x *AddNetworkRule) ProtoReflect() protoreflect.Message { // Deprecated: Use AddNetworkRule.ProtoReflect.Descriptor instead. func (*AddNetworkRule) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{132} + return file_openshell_proto_rawDescGZIP(), []int{133} } func (x *AddNetworkRule) GetRuleName() string { @@ -9625,7 +9671,7 @@ type RemoveNetworkEndpoint struct { func (x *RemoveNetworkEndpoint) Reset() { *x = RemoveNetworkEndpoint{} - mi := &file_openshell_proto_msgTypes[133] + mi := &file_openshell_proto_msgTypes[134] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9637,7 +9683,7 @@ func (x *RemoveNetworkEndpoint) String() string { func (*RemoveNetworkEndpoint) ProtoMessage() {} func (x *RemoveNetworkEndpoint) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[133] + mi := &file_openshell_proto_msgTypes[134] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9650,7 +9696,7 @@ func (x *RemoveNetworkEndpoint) ProtoReflect() protoreflect.Message { // Deprecated: Use RemoveNetworkEndpoint.ProtoReflect.Descriptor instead. func (*RemoveNetworkEndpoint) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{133} + return file_openshell_proto_rawDescGZIP(), []int{134} } func (x *RemoveNetworkEndpoint) GetRuleName() string { @@ -9683,7 +9729,7 @@ type RemoveNetworkRule struct { func (x *RemoveNetworkRule) Reset() { *x = RemoveNetworkRule{} - mi := &file_openshell_proto_msgTypes[134] + mi := &file_openshell_proto_msgTypes[135] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9695,7 +9741,7 @@ func (x *RemoveNetworkRule) String() string { func (*RemoveNetworkRule) ProtoMessage() {} func (x *RemoveNetworkRule) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[134] + mi := &file_openshell_proto_msgTypes[135] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9708,7 +9754,7 @@ func (x *RemoveNetworkRule) ProtoReflect() protoreflect.Message { // Deprecated: Use RemoveNetworkRule.ProtoReflect.Descriptor instead. func (*RemoveNetworkRule) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{134} + return file_openshell_proto_rawDescGZIP(), []int{135} } func (x *RemoveNetworkRule) GetRuleName() string { @@ -9729,7 +9775,7 @@ type AddDenyRules struct { func (x *AddDenyRules) Reset() { *x = AddDenyRules{} - mi := &file_openshell_proto_msgTypes[135] + mi := &file_openshell_proto_msgTypes[136] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9741,7 +9787,7 @@ func (x *AddDenyRules) String() string { func (*AddDenyRules) ProtoMessage() {} func (x *AddDenyRules) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[135] + mi := &file_openshell_proto_msgTypes[136] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9754,7 +9800,7 @@ func (x *AddDenyRules) ProtoReflect() protoreflect.Message { // Deprecated: Use AddDenyRules.ProtoReflect.Descriptor instead. func (*AddDenyRules) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{135} + return file_openshell_proto_rawDescGZIP(), []int{136} } func (x *AddDenyRules) GetHost() string { @@ -9789,7 +9835,7 @@ type AddAllowRules struct { func (x *AddAllowRules) Reset() { *x = AddAllowRules{} - mi := &file_openshell_proto_msgTypes[136] + mi := &file_openshell_proto_msgTypes[137] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9801,7 +9847,7 @@ func (x *AddAllowRules) String() string { func (*AddAllowRules) ProtoMessage() {} func (x *AddAllowRules) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[136] + mi := &file_openshell_proto_msgTypes[137] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9814,7 +9860,7 @@ func (x *AddAllowRules) ProtoReflect() protoreflect.Message { // Deprecated: Use AddAllowRules.ProtoReflect.Descriptor instead. func (*AddAllowRules) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{136} + return file_openshell_proto_rawDescGZIP(), []int{137} } func (x *AddAllowRules) GetHost() string { @@ -9848,7 +9894,7 @@ type RemoveNetworkBinary struct { func (x *RemoveNetworkBinary) Reset() { *x = RemoveNetworkBinary{} - mi := &file_openshell_proto_msgTypes[137] + mi := &file_openshell_proto_msgTypes[138] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9860,7 +9906,7 @@ func (x *RemoveNetworkBinary) String() string { func (*RemoveNetworkBinary) ProtoMessage() {} func (x *RemoveNetworkBinary) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[137] + mi := &file_openshell_proto_msgTypes[138] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9873,7 +9919,7 @@ func (x *RemoveNetworkBinary) ProtoReflect() protoreflect.Message { // Deprecated: Use RemoveNetworkBinary.ProtoReflect.Descriptor instead. func (*RemoveNetworkBinary) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{137} + return file_openshell_proto_rawDescGZIP(), []int{138} } func (x *RemoveNetworkBinary) GetRuleName() string { @@ -9909,7 +9955,7 @@ type UpdateConfigResponse struct { func (x *UpdateConfigResponse) Reset() { *x = UpdateConfigResponse{} - mi := &file_openshell_proto_msgTypes[138] + mi := &file_openshell_proto_msgTypes[139] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9921,7 +9967,7 @@ func (x *UpdateConfigResponse) String() string { func (*UpdateConfigResponse) ProtoMessage() {} func (x *UpdateConfigResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[138] + mi := &file_openshell_proto_msgTypes[139] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9934,7 +9980,7 @@ func (x *UpdateConfigResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use UpdateConfigResponse.ProtoReflect.Descriptor instead. func (*UpdateConfigResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{138} + return file_openshell_proto_rawDescGZIP(), []int{139} } func (x *UpdateConfigResponse) GetVersion() uint32 { @@ -9989,7 +10035,7 @@ type GetSandboxPolicyStatusRequest struct { func (x *GetSandboxPolicyStatusRequest) Reset() { *x = GetSandboxPolicyStatusRequest{} - mi := &file_openshell_proto_msgTypes[139] + mi := &file_openshell_proto_msgTypes[140] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10001,7 +10047,7 @@ func (x *GetSandboxPolicyStatusRequest) String() string { func (*GetSandboxPolicyStatusRequest) ProtoMessage() {} func (x *GetSandboxPolicyStatusRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[139] + mi := &file_openshell_proto_msgTypes[140] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10014,7 +10060,7 @@ func (x *GetSandboxPolicyStatusRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetSandboxPolicyStatusRequest.ProtoReflect.Descriptor instead. func (*GetSandboxPolicyStatusRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{139} + return file_openshell_proto_rawDescGZIP(), []int{140} } func (x *GetSandboxPolicyStatusRequest) GetName() string { @@ -10058,7 +10104,7 @@ type GetSandboxPolicyStatusResponse struct { func (x *GetSandboxPolicyStatusResponse) Reset() { *x = GetSandboxPolicyStatusResponse{} - mi := &file_openshell_proto_msgTypes[140] + mi := &file_openshell_proto_msgTypes[141] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10070,7 +10116,7 @@ func (x *GetSandboxPolicyStatusResponse) String() string { func (*GetSandboxPolicyStatusResponse) ProtoMessage() {} func (x *GetSandboxPolicyStatusResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[140] + mi := &file_openshell_proto_msgTypes[141] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10083,7 +10129,7 @@ func (x *GetSandboxPolicyStatusResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use GetSandboxPolicyStatusResponse.ProtoReflect.Descriptor instead. func (*GetSandboxPolicyStatusResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{140} + return file_openshell_proto_rawDescGZIP(), []int{141} } func (x *GetSandboxPolicyStatusResponse) GetRevision() *SandboxPolicyRevision { @@ -10117,7 +10163,7 @@ type ListSandboxPoliciesRequest struct { func (x *ListSandboxPoliciesRequest) Reset() { *x = ListSandboxPoliciesRequest{} - mi := &file_openshell_proto_msgTypes[141] + mi := &file_openshell_proto_msgTypes[142] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10129,7 +10175,7 @@ func (x *ListSandboxPoliciesRequest) String() string { func (*ListSandboxPoliciesRequest) ProtoMessage() {} func (x *ListSandboxPoliciesRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[141] + mi := &file_openshell_proto_msgTypes[142] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10142,7 +10188,7 @@ func (x *ListSandboxPoliciesRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListSandboxPoliciesRequest.ProtoReflect.Descriptor instead. func (*ListSandboxPoliciesRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{141} + return file_openshell_proto_rawDescGZIP(), []int{142} } func (x *ListSandboxPoliciesRequest) GetName() string { @@ -10192,7 +10238,7 @@ type ListSandboxPoliciesResponse struct { func (x *ListSandboxPoliciesResponse) Reset() { *x = ListSandboxPoliciesResponse{} - mi := &file_openshell_proto_msgTypes[142] + mi := &file_openshell_proto_msgTypes[143] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10204,7 +10250,7 @@ func (x *ListSandboxPoliciesResponse) String() string { func (*ListSandboxPoliciesResponse) ProtoMessage() {} func (x *ListSandboxPoliciesResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[142] + mi := &file_openshell_proto_msgTypes[143] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10217,7 +10263,7 @@ func (x *ListSandboxPoliciesResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListSandboxPoliciesResponse.ProtoReflect.Descriptor instead. func (*ListSandboxPoliciesResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{142} + return file_openshell_proto_rawDescGZIP(), []int{143} } func (x *ListSandboxPoliciesResponse) GetRevisions() []*SandboxPolicyRevision { @@ -10244,7 +10290,7 @@ type ReportPolicyStatusRequest struct { func (x *ReportPolicyStatusRequest) Reset() { *x = ReportPolicyStatusRequest{} - mi := &file_openshell_proto_msgTypes[143] + mi := &file_openshell_proto_msgTypes[144] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10256,7 +10302,7 @@ func (x *ReportPolicyStatusRequest) String() string { func (*ReportPolicyStatusRequest) ProtoMessage() {} func (x *ReportPolicyStatusRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[143] + mi := &file_openshell_proto_msgTypes[144] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10269,7 +10315,7 @@ func (x *ReportPolicyStatusRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ReportPolicyStatusRequest.ProtoReflect.Descriptor instead. func (*ReportPolicyStatusRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{143} + return file_openshell_proto_rawDescGZIP(), []int{144} } func (x *ReportPolicyStatusRequest) GetSandboxId() string { @@ -10309,7 +10355,7 @@ type ReportPolicyStatusResponse struct { func (x *ReportPolicyStatusResponse) Reset() { *x = ReportPolicyStatusResponse{} - mi := &file_openshell_proto_msgTypes[144] + mi := &file_openshell_proto_msgTypes[145] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10321,7 +10367,7 @@ func (x *ReportPolicyStatusResponse) String() string { func (*ReportPolicyStatusResponse) ProtoMessage() {} func (x *ReportPolicyStatusResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[144] + mi := &file_openshell_proto_msgTypes[145] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10334,7 +10380,7 @@ func (x *ReportPolicyStatusResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ReportPolicyStatusResponse.ProtoReflect.Descriptor instead. func (*ReportPolicyStatusResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{144} + return file_openshell_proto_rawDescGZIP(), []int{145} } // A versioned policy revision with metadata. @@ -10367,7 +10413,7 @@ type SandboxPolicyRevision struct { func (x *SandboxPolicyRevision) Reset() { *x = SandboxPolicyRevision{} - mi := &file_openshell_proto_msgTypes[145] + mi := &file_openshell_proto_msgTypes[146] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10379,7 +10425,7 @@ func (x *SandboxPolicyRevision) String() string { func (*SandboxPolicyRevision) ProtoMessage() {} func (x *SandboxPolicyRevision) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[145] + mi := &file_openshell_proto_msgTypes[146] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10392,7 +10438,7 @@ func (x *SandboxPolicyRevision) ProtoReflect() protoreflect.Message { // Deprecated: Use SandboxPolicyRevision.ProtoReflect.Descriptor instead. func (*SandboxPolicyRevision) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{145} + return file_openshell_proto_rawDescGZIP(), []int{146} } func (x *SandboxPolicyRevision) GetVersion() uint32 { @@ -10472,7 +10518,7 @@ type GetSandboxLogsRequest struct { func (x *GetSandboxLogsRequest) Reset() { *x = GetSandboxLogsRequest{} - mi := &file_openshell_proto_msgTypes[146] + mi := &file_openshell_proto_msgTypes[147] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10484,7 +10530,7 @@ func (x *GetSandboxLogsRequest) String() string { func (*GetSandboxLogsRequest) ProtoMessage() {} func (x *GetSandboxLogsRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[146] + mi := &file_openshell_proto_msgTypes[147] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10497,7 +10543,7 @@ func (x *GetSandboxLogsRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetSandboxLogsRequest.ProtoReflect.Descriptor instead. func (*GetSandboxLogsRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{146} + return file_openshell_proto_rawDescGZIP(), []int{147} } func (x *GetSandboxLogsRequest) GetSandboxId() string { @@ -10555,7 +10601,7 @@ type PushSandboxLogsRequest struct { func (x *PushSandboxLogsRequest) Reset() { *x = PushSandboxLogsRequest{} - mi := &file_openshell_proto_msgTypes[147] + mi := &file_openshell_proto_msgTypes[148] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10567,7 +10613,7 @@ func (x *PushSandboxLogsRequest) String() string { func (*PushSandboxLogsRequest) ProtoMessage() {} func (x *PushSandboxLogsRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[147] + mi := &file_openshell_proto_msgTypes[148] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10580,7 +10626,7 @@ func (x *PushSandboxLogsRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use PushSandboxLogsRequest.ProtoReflect.Descriptor instead. func (*PushSandboxLogsRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{147} + return file_openshell_proto_rawDescGZIP(), []int{148} } func (x *PushSandboxLogsRequest) GetSandboxId() string { @@ -10606,7 +10652,7 @@ type PushSandboxLogsResponse struct { func (x *PushSandboxLogsResponse) Reset() { *x = PushSandboxLogsResponse{} - mi := &file_openshell_proto_msgTypes[148] + mi := &file_openshell_proto_msgTypes[149] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10618,7 +10664,7 @@ func (x *PushSandboxLogsResponse) String() string { func (*PushSandboxLogsResponse) ProtoMessage() {} func (x *PushSandboxLogsResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[148] + mi := &file_openshell_proto_msgTypes[149] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10631,7 +10677,7 @@ func (x *PushSandboxLogsResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use PushSandboxLogsResponse.ProtoReflect.Descriptor instead. func (*PushSandboxLogsResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{148} + return file_openshell_proto_rawDescGZIP(), []int{149} } // Get sandbox logs response. @@ -10647,7 +10693,7 @@ type GetSandboxLogsResponse struct { func (x *GetSandboxLogsResponse) Reset() { *x = GetSandboxLogsResponse{} - mi := &file_openshell_proto_msgTypes[149] + mi := &file_openshell_proto_msgTypes[150] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10659,7 +10705,7 @@ func (x *GetSandboxLogsResponse) String() string { func (*GetSandboxLogsResponse) ProtoMessage() {} func (x *GetSandboxLogsResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[149] + mi := &file_openshell_proto_msgTypes[150] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10672,7 +10718,7 @@ func (x *GetSandboxLogsResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use GetSandboxLogsResponse.ProtoReflect.Descriptor instead. func (*GetSandboxLogsResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{149} + return file_openshell_proto_rawDescGZIP(), []int{150} } func (x *GetSandboxLogsResponse) GetLogs() []*SandboxLogLine { @@ -10705,7 +10751,7 @@ type SupervisorMessage struct { func (x *SupervisorMessage) Reset() { *x = SupervisorMessage{} - mi := &file_openshell_proto_msgTypes[150] + mi := &file_openshell_proto_msgTypes[151] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10717,7 +10763,7 @@ func (x *SupervisorMessage) String() string { func (*SupervisorMessage) ProtoMessage() {} func (x *SupervisorMessage) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[150] + mi := &file_openshell_proto_msgTypes[151] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10730,7 +10776,7 @@ func (x *SupervisorMessage) ProtoReflect() protoreflect.Message { // Deprecated: Use SupervisorMessage.ProtoReflect.Descriptor instead. func (*SupervisorMessage) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{150} + return file_openshell_proto_rawDescGZIP(), []int{151} } func (x *SupervisorMessage) GetPayload() isSupervisorMessage_Payload { @@ -10821,7 +10867,7 @@ type GatewayMessage struct { func (x *GatewayMessage) Reset() { *x = GatewayMessage{} - mi := &file_openshell_proto_msgTypes[151] + mi := &file_openshell_proto_msgTypes[152] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10833,7 +10879,7 @@ func (x *GatewayMessage) String() string { func (*GatewayMessage) ProtoMessage() {} func (x *GatewayMessage) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[151] + mi := &file_openshell_proto_msgTypes[152] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10846,7 +10892,7 @@ func (x *GatewayMessage) ProtoReflect() protoreflect.Message { // Deprecated: Use GatewayMessage.ProtoReflect.Descriptor instead. func (*GatewayMessage) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{151} + return file_openshell_proto_rawDescGZIP(), []int{152} } func (x *GatewayMessage) GetPayload() isGatewayMessage_Payload { @@ -10948,7 +10994,7 @@ type SupervisorHello struct { func (x *SupervisorHello) Reset() { *x = SupervisorHello{} - mi := &file_openshell_proto_msgTypes[152] + mi := &file_openshell_proto_msgTypes[153] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10960,7 +11006,7 @@ func (x *SupervisorHello) String() string { func (*SupervisorHello) ProtoMessage() {} func (x *SupervisorHello) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[152] + mi := &file_openshell_proto_msgTypes[153] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10973,7 +11019,7 @@ func (x *SupervisorHello) ProtoReflect() protoreflect.Message { // Deprecated: Use SupervisorHello.ProtoReflect.Descriptor instead. func (*SupervisorHello) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{152} + return file_openshell_proto_rawDescGZIP(), []int{153} } func (x *SupervisorHello) GetSandboxId() string { @@ -11003,7 +11049,7 @@ type SessionAccepted struct { func (x *SessionAccepted) Reset() { *x = SessionAccepted{} - mi := &file_openshell_proto_msgTypes[153] + mi := &file_openshell_proto_msgTypes[154] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11015,7 +11061,7 @@ func (x *SessionAccepted) String() string { func (*SessionAccepted) ProtoMessage() {} func (x *SessionAccepted) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[153] + mi := &file_openshell_proto_msgTypes[154] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11028,7 +11074,7 @@ func (x *SessionAccepted) ProtoReflect() protoreflect.Message { // Deprecated: Use SessionAccepted.ProtoReflect.Descriptor instead. func (*SessionAccepted) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{153} + return file_openshell_proto_rawDescGZIP(), []int{154} } func (x *SessionAccepted) GetSessionId() string { @@ -11056,7 +11102,7 @@ type SessionRejected struct { func (x *SessionRejected) Reset() { *x = SessionRejected{} - mi := &file_openshell_proto_msgTypes[154] + mi := &file_openshell_proto_msgTypes[155] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11068,7 +11114,7 @@ func (x *SessionRejected) String() string { func (*SessionRejected) ProtoMessage() {} func (x *SessionRejected) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[154] + mi := &file_openshell_proto_msgTypes[155] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11081,7 +11127,7 @@ func (x *SessionRejected) ProtoReflect() protoreflect.Message { // Deprecated: Use SessionRejected.ProtoReflect.Descriptor instead. func (*SessionRejected) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{154} + return file_openshell_proto_rawDescGZIP(), []int{155} } func (x *SessionRejected) GetReason() string { @@ -11100,7 +11146,7 @@ type SupervisorHeartbeat struct { func (x *SupervisorHeartbeat) Reset() { *x = SupervisorHeartbeat{} - mi := &file_openshell_proto_msgTypes[155] + mi := &file_openshell_proto_msgTypes[156] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11112,7 +11158,7 @@ func (x *SupervisorHeartbeat) String() string { func (*SupervisorHeartbeat) ProtoMessage() {} func (x *SupervisorHeartbeat) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[155] + mi := &file_openshell_proto_msgTypes[156] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11125,7 +11171,7 @@ func (x *SupervisorHeartbeat) ProtoReflect() protoreflect.Message { // Deprecated: Use SupervisorHeartbeat.ProtoReflect.Descriptor instead. func (*SupervisorHeartbeat) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{155} + return file_openshell_proto_rawDescGZIP(), []int{156} } // Gateway heartbeat. @@ -11137,7 +11183,7 @@ type GatewayHeartbeat struct { func (x *GatewayHeartbeat) Reset() { *x = GatewayHeartbeat{} - mi := &file_openshell_proto_msgTypes[156] + mi := &file_openshell_proto_msgTypes[157] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11149,7 +11195,7 @@ func (x *GatewayHeartbeat) String() string { func (*GatewayHeartbeat) ProtoMessage() {} func (x *GatewayHeartbeat) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[156] + mi := &file_openshell_proto_msgTypes[157] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11162,7 +11208,7 @@ func (x *GatewayHeartbeat) ProtoReflect() protoreflect.Message { // Deprecated: Use GatewayHeartbeat.ProtoReflect.Descriptor instead. func (*GatewayHeartbeat) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{156} + return file_openshell_proto_rawDescGZIP(), []int{157} } // Terminal result reported before the supervisor shuts down. A successful RPC @@ -11179,7 +11225,7 @@ type ReportMainProcessExitRequest struct { func (x *ReportMainProcessExitRequest) Reset() { *x = ReportMainProcessExitRequest{} - mi := &file_openshell_proto_msgTypes[157] + mi := &file_openshell_proto_msgTypes[158] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11191,7 +11237,7 @@ func (x *ReportMainProcessExitRequest) String() string { func (*ReportMainProcessExitRequest) ProtoMessage() {} func (x *ReportMainProcessExitRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[157] + mi := &file_openshell_proto_msgTypes[158] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11204,7 +11250,7 @@ func (x *ReportMainProcessExitRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ReportMainProcessExitRequest.ProtoReflect.Descriptor instead. func (*ReportMainProcessExitRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{157} + return file_openshell_proto_rawDescGZIP(), []int{158} } func (x *ReportMainProcessExitRequest) GetSandboxId() string { @@ -11236,7 +11282,7 @@ type ReportMainProcessExitResponse struct { func (x *ReportMainProcessExitResponse) Reset() { *x = ReportMainProcessExitResponse{} - mi := &file_openshell_proto_msgTypes[158] + mi := &file_openshell_proto_msgTypes[159] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11248,7 +11294,7 @@ func (x *ReportMainProcessExitResponse) String() string { func (*ReportMainProcessExitResponse) ProtoMessage() {} func (x *ReportMainProcessExitResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[158] + mi := &file_openshell_proto_msgTypes[159] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11261,7 +11307,7 @@ func (x *ReportMainProcessExitResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ReportMainProcessExitResponse.ProtoReflect.Descriptor instead. func (*ReportMainProcessExitResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{158} + return file_openshell_proto_rawDescGZIP(), []int{159} } // Terminal-delivery completion reported after all expected foreground SSH @@ -11276,7 +11322,7 @@ type FinalizeMainProcessExitRequest struct { func (x *FinalizeMainProcessExitRequest) Reset() { *x = FinalizeMainProcessExitRequest{} - mi := &file_openshell_proto_msgTypes[159] + mi := &file_openshell_proto_msgTypes[160] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11288,7 +11334,7 @@ func (x *FinalizeMainProcessExitRequest) String() string { func (*FinalizeMainProcessExitRequest) ProtoMessage() {} func (x *FinalizeMainProcessExitRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[159] + mi := &file_openshell_proto_msgTypes[160] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11301,7 +11347,7 @@ func (x *FinalizeMainProcessExitRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use FinalizeMainProcessExitRequest.ProtoReflect.Descriptor instead. func (*FinalizeMainProcessExitRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{159} + return file_openshell_proto_rawDescGZIP(), []int{160} } func (x *FinalizeMainProcessExitRequest) GetSandboxId() string { @@ -11326,7 +11372,7 @@ type FinalizeMainProcessExitResponse struct { func (x *FinalizeMainProcessExitResponse) Reset() { *x = FinalizeMainProcessExitResponse{} - mi := &file_openshell_proto_msgTypes[160] + mi := &file_openshell_proto_msgTypes[161] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11338,7 +11384,7 @@ func (x *FinalizeMainProcessExitResponse) String() string { func (*FinalizeMainProcessExitResponse) ProtoMessage() {} func (x *FinalizeMainProcessExitResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[160] + mi := &file_openshell_proto_msgTypes[161] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11351,7 +11397,7 @@ func (x *FinalizeMainProcessExitResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use FinalizeMainProcessExitResponse.ProtoReflect.Descriptor instead. func (*FinalizeMainProcessExitResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{160} + return file_openshell_proto_rawDescGZIP(), []int{161} } // Gateway requests the supervisor to open a relay channel. @@ -11380,7 +11426,7 @@ type RelayOpen struct { func (x *RelayOpen) Reset() { *x = RelayOpen{} - mi := &file_openshell_proto_msgTypes[161] + mi := &file_openshell_proto_msgTypes[162] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11392,7 +11438,7 @@ func (x *RelayOpen) String() string { func (*RelayOpen) ProtoMessage() {} func (x *RelayOpen) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[161] + mi := &file_openshell_proto_msgTypes[162] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11405,7 +11451,7 @@ func (x *RelayOpen) ProtoReflect() protoreflect.Message { // Deprecated: Use RelayOpen.ProtoReflect.Descriptor instead. func (*RelayOpen) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{161} + return file_openshell_proto_rawDescGZIP(), []int{162} } func (x *RelayOpen) GetChannelId() string { @@ -11472,7 +11518,7 @@ type SshRelayTarget struct { func (x *SshRelayTarget) Reset() { *x = SshRelayTarget{} - mi := &file_openshell_proto_msgTypes[162] + mi := &file_openshell_proto_msgTypes[163] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11484,7 +11530,7 @@ func (x *SshRelayTarget) String() string { func (*SshRelayTarget) ProtoMessage() {} func (x *SshRelayTarget) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[162] + mi := &file_openshell_proto_msgTypes[163] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11497,7 +11543,7 @@ func (x *SshRelayTarget) ProtoReflect() protoreflect.Message { // Deprecated: Use SshRelayTarget.ProtoReflect.Descriptor instead. func (*SshRelayTarget) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{162} + return file_openshell_proto_rawDescGZIP(), []int{163} } // TCP target dialed by the supervisor from inside the sandbox. @@ -11513,7 +11559,7 @@ type TcpRelayTarget struct { func (x *TcpRelayTarget) Reset() { *x = TcpRelayTarget{} - mi := &file_openshell_proto_msgTypes[163] + mi := &file_openshell_proto_msgTypes[164] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11525,7 +11571,7 @@ func (x *TcpRelayTarget) String() string { func (*TcpRelayTarget) ProtoMessage() {} func (x *TcpRelayTarget) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[163] + mi := &file_openshell_proto_msgTypes[164] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11538,7 +11584,7 @@ func (x *TcpRelayTarget) ProtoReflect() protoreflect.Message { // Deprecated: Use TcpRelayTarget.ProtoReflect.Descriptor instead. func (*TcpRelayTarget) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{163} + return file_openshell_proto_rawDescGZIP(), []int{164} } func (x *TcpRelayTarget) GetHost() string { @@ -11566,7 +11612,7 @@ type RelayInit struct { func (x *RelayInit) Reset() { *x = RelayInit{} - mi := &file_openshell_proto_msgTypes[164] + mi := &file_openshell_proto_msgTypes[165] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11578,7 +11624,7 @@ func (x *RelayInit) String() string { func (*RelayInit) ProtoMessage() {} func (x *RelayInit) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[164] + mi := &file_openshell_proto_msgTypes[165] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11591,7 +11637,7 @@ func (x *RelayInit) ProtoReflect() protoreflect.Message { // Deprecated: Use RelayInit.ProtoReflect.Descriptor instead. func (*RelayInit) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{164} + return file_openshell_proto_rawDescGZIP(), []int{165} } func (x *RelayInit) GetChannelId() string { @@ -11618,7 +11664,7 @@ type RelayFrame struct { func (x *RelayFrame) Reset() { *x = RelayFrame{} - mi := &file_openshell_proto_msgTypes[165] + mi := &file_openshell_proto_msgTypes[166] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11630,7 +11676,7 @@ func (x *RelayFrame) String() string { func (*RelayFrame) ProtoMessage() {} func (x *RelayFrame) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[165] + mi := &file_openshell_proto_msgTypes[166] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11643,7 +11689,7 @@ func (x *RelayFrame) ProtoReflect() protoreflect.Message { // Deprecated: Use RelayFrame.ProtoReflect.Descriptor instead. func (*RelayFrame) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{165} + return file_openshell_proto_rawDescGZIP(), []int{166} } func (x *RelayFrame) GetPayload() isRelayFrame_Payload { @@ -11702,7 +11748,7 @@ type RelayOpenResult struct { func (x *RelayOpenResult) Reset() { *x = RelayOpenResult{} - mi := &file_openshell_proto_msgTypes[166] + mi := &file_openshell_proto_msgTypes[167] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11714,7 +11760,7 @@ func (x *RelayOpenResult) String() string { func (*RelayOpenResult) ProtoMessage() {} func (x *RelayOpenResult) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[166] + mi := &file_openshell_proto_msgTypes[167] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11727,7 +11773,7 @@ func (x *RelayOpenResult) ProtoReflect() protoreflect.Message { // Deprecated: Use RelayOpenResult.ProtoReflect.Descriptor instead. func (*RelayOpenResult) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{166} + return file_openshell_proto_rawDescGZIP(), []int{167} } func (x *RelayOpenResult) GetChannelId() string { @@ -11764,7 +11810,7 @@ type RelayClose struct { func (x *RelayClose) Reset() { *x = RelayClose{} - mi := &file_openshell_proto_msgTypes[167] + mi := &file_openshell_proto_msgTypes[168] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11776,7 +11822,7 @@ func (x *RelayClose) String() string { func (*RelayClose) ProtoMessage() {} func (x *RelayClose) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[167] + mi := &file_openshell_proto_msgTypes[168] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11789,7 +11835,7 @@ func (x *RelayClose) ProtoReflect() protoreflect.Message { // Deprecated: Use RelayClose.ProtoReflect.Descriptor instead. func (*RelayClose) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{167} + return file_openshell_proto_rawDescGZIP(), []int{168} } func (x *RelayClose) GetChannelId() string { @@ -11823,7 +11869,7 @@ type L7RequestSample struct { func (x *L7RequestSample) Reset() { *x = L7RequestSample{} - mi := &file_openshell_proto_msgTypes[168] + mi := &file_openshell_proto_msgTypes[169] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11835,7 +11881,7 @@ func (x *L7RequestSample) String() string { func (*L7RequestSample) ProtoMessage() {} func (x *L7RequestSample) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[168] + mi := &file_openshell_proto_msgTypes[169] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11848,7 +11894,7 @@ func (x *L7RequestSample) ProtoReflect() protoreflect.Message { // Deprecated: Use L7RequestSample.ProtoReflect.Descriptor instead. func (*L7RequestSample) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{168} + return file_openshell_proto_rawDescGZIP(), []int{169} } func (x *L7RequestSample) GetMethod() string { @@ -11922,7 +11968,7 @@ type DenialSummary struct { func (x *DenialSummary) Reset() { *x = DenialSummary{} - mi := &file_openshell_proto_msgTypes[169] + mi := &file_openshell_proto_msgTypes[170] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11934,7 +11980,7 @@ func (x *DenialSummary) String() string { func (*DenialSummary) ProtoMessage() {} func (x *DenialSummary) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[169] + mi := &file_openshell_proto_msgTypes[170] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11947,7 +11993,7 @@ func (x *DenialSummary) ProtoReflect() protoreflect.Message { // Deprecated: Use DenialSummary.ProtoReflect.Descriptor instead. func (*DenialSummary) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{169} + return file_openshell_proto_rawDescGZIP(), []int{170} } func (x *DenialSummary) GetSandboxId() string { @@ -12082,7 +12128,7 @@ type DenialGroupCount struct { func (x *DenialGroupCount) Reset() { *x = DenialGroupCount{} - mi := &file_openshell_proto_msgTypes[170] + mi := &file_openshell_proto_msgTypes[171] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12094,7 +12140,7 @@ func (x *DenialGroupCount) String() string { func (*DenialGroupCount) ProtoMessage() {} func (x *DenialGroupCount) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[170] + mi := &file_openshell_proto_msgTypes[171] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12107,7 +12153,7 @@ func (x *DenialGroupCount) ProtoReflect() protoreflect.Message { // Deprecated: Use DenialGroupCount.ProtoReflect.Descriptor instead. func (*DenialGroupCount) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{170} + return file_openshell_proto_rawDescGZIP(), []int{171} } func (x *DenialGroupCount) GetDenyGroup() string { @@ -12140,7 +12186,7 @@ type NetworkActivitySummary struct { func (x *NetworkActivitySummary) Reset() { *x = NetworkActivitySummary{} - mi := &file_openshell_proto_msgTypes[171] + mi := &file_openshell_proto_msgTypes[172] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12152,7 +12198,7 @@ func (x *NetworkActivitySummary) String() string { func (*NetworkActivitySummary) ProtoMessage() {} func (x *NetworkActivitySummary) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[171] + mi := &file_openshell_proto_msgTypes[172] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12165,7 +12211,7 @@ func (x *NetworkActivitySummary) ProtoReflect() protoreflect.Message { // Deprecated: Use NetworkActivitySummary.ProtoReflect.Descriptor instead. func (*NetworkActivitySummary) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{171} + return file_openshell_proto_rawDescGZIP(), []int{172} } func (x *NetworkActivitySummary) GetNetworkActivityCount() uint32 { @@ -12253,7 +12299,7 @@ type PolicyChunk struct { func (x *PolicyChunk) Reset() { *x = PolicyChunk{} - mi := &file_openshell_proto_msgTypes[172] + mi := &file_openshell_proto_msgTypes[173] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12265,7 +12311,7 @@ func (x *PolicyChunk) String() string { func (*PolicyChunk) ProtoMessage() {} func (x *PolicyChunk) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[172] + mi := &file_openshell_proto_msgTypes[173] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12278,7 +12324,7 @@ func (x *PolicyChunk) ProtoReflect() protoreflect.Message { // Deprecated: Use PolicyChunk.ProtoReflect.Descriptor instead. func (*PolicyChunk) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{172} + return file_openshell_proto_rawDescGZIP(), []int{173} } func (x *PolicyChunk) GetId() string { @@ -12466,7 +12512,7 @@ type DraftPolicyUpdate struct { func (x *DraftPolicyUpdate) Reset() { *x = DraftPolicyUpdate{} - mi := &file_openshell_proto_msgTypes[173] + mi := &file_openshell_proto_msgTypes[174] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12478,7 +12524,7 @@ func (x *DraftPolicyUpdate) String() string { func (*DraftPolicyUpdate) ProtoMessage() {} func (x *DraftPolicyUpdate) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[173] + mi := &file_openshell_proto_msgTypes[174] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12491,7 +12537,7 @@ func (x *DraftPolicyUpdate) ProtoReflect() protoreflect.Message { // Deprecated: Use DraftPolicyUpdate.ProtoReflect.Descriptor instead. func (*DraftPolicyUpdate) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{173} + return file_openshell_proto_rawDescGZIP(), []int{174} } func (x *DraftPolicyUpdate) GetDraftVersion() uint64 { @@ -12549,7 +12595,7 @@ type SubmitPolicyAnalysisRequest struct { func (x *SubmitPolicyAnalysisRequest) Reset() { *x = SubmitPolicyAnalysisRequest{} - mi := &file_openshell_proto_msgTypes[174] + mi := &file_openshell_proto_msgTypes[175] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12561,7 +12607,7 @@ func (x *SubmitPolicyAnalysisRequest) String() string { func (*SubmitPolicyAnalysisRequest) ProtoMessage() {} func (x *SubmitPolicyAnalysisRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[174] + mi := &file_openshell_proto_msgTypes[175] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12574,7 +12620,7 @@ func (x *SubmitPolicyAnalysisRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use SubmitPolicyAnalysisRequest.ProtoReflect.Descriptor instead. func (*SubmitPolicyAnalysisRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{174} + return file_openshell_proto_rawDescGZIP(), []int{175} } func (x *SubmitPolicyAnalysisRequest) GetSummaries() []*DenialSummary { @@ -12637,7 +12683,7 @@ type SubmitPolicyAnalysisResponse struct { func (x *SubmitPolicyAnalysisResponse) Reset() { *x = SubmitPolicyAnalysisResponse{} - mi := &file_openshell_proto_msgTypes[175] + mi := &file_openshell_proto_msgTypes[176] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12649,7 +12695,7 @@ func (x *SubmitPolicyAnalysisResponse) String() string { func (*SubmitPolicyAnalysisResponse) ProtoMessage() {} func (x *SubmitPolicyAnalysisResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[175] + mi := &file_openshell_proto_msgTypes[176] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12662,7 +12708,7 @@ func (x *SubmitPolicyAnalysisResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use SubmitPolicyAnalysisResponse.ProtoReflect.Descriptor instead. func (*SubmitPolicyAnalysisResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{175} + return file_openshell_proto_rawDescGZIP(), []int{176} } func (x *SubmitPolicyAnalysisResponse) GetAcceptedChunks() uint32 { @@ -12708,7 +12754,7 @@ type GetDraftPolicyRequest struct { func (x *GetDraftPolicyRequest) Reset() { *x = GetDraftPolicyRequest{} - mi := &file_openshell_proto_msgTypes[176] + mi := &file_openshell_proto_msgTypes[177] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12720,7 +12766,7 @@ func (x *GetDraftPolicyRequest) String() string { func (*GetDraftPolicyRequest) ProtoMessage() {} func (x *GetDraftPolicyRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[176] + mi := &file_openshell_proto_msgTypes[177] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12733,7 +12779,7 @@ func (x *GetDraftPolicyRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetDraftPolicyRequest.ProtoReflect.Descriptor instead. func (*GetDraftPolicyRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{176} + return file_openshell_proto_rawDescGZIP(), []int{177} } func (x *GetDraftPolicyRequest) GetName() string { @@ -12773,7 +12819,7 @@ type GetDraftPolicyResponse struct { func (x *GetDraftPolicyResponse) Reset() { *x = GetDraftPolicyResponse{} - mi := &file_openshell_proto_msgTypes[177] + mi := &file_openshell_proto_msgTypes[178] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12785,7 +12831,7 @@ func (x *GetDraftPolicyResponse) String() string { func (*GetDraftPolicyResponse) ProtoMessage() {} func (x *GetDraftPolicyResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[177] + mi := &file_openshell_proto_msgTypes[178] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12798,7 +12844,7 @@ func (x *GetDraftPolicyResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use GetDraftPolicyResponse.ProtoReflect.Descriptor instead. func (*GetDraftPolicyResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{177} + return file_openshell_proto_rawDescGZIP(), []int{178} } func (x *GetDraftPolicyResponse) GetChunks() []*PolicyChunk { @@ -12847,7 +12893,7 @@ type ApproveDraftChunkRequest struct { func (x *ApproveDraftChunkRequest) Reset() { *x = ApproveDraftChunkRequest{} - mi := &file_openshell_proto_msgTypes[178] + mi := &file_openshell_proto_msgTypes[179] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12859,7 +12905,7 @@ func (x *ApproveDraftChunkRequest) String() string { func (*ApproveDraftChunkRequest) ProtoMessage() {} func (x *ApproveDraftChunkRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[178] + mi := &file_openshell_proto_msgTypes[179] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12872,7 +12918,7 @@ func (x *ApproveDraftChunkRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ApproveDraftChunkRequest.ProtoReflect.Descriptor instead. func (*ApproveDraftChunkRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{178} + return file_openshell_proto_rawDescGZIP(), []int{179} } func (x *ApproveDraftChunkRequest) GetName() string { @@ -12915,7 +12961,7 @@ type ApproveDraftChunkResponse struct { func (x *ApproveDraftChunkResponse) Reset() { *x = ApproveDraftChunkResponse{} - mi := &file_openshell_proto_msgTypes[179] + mi := &file_openshell_proto_msgTypes[180] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12927,7 +12973,7 @@ func (x *ApproveDraftChunkResponse) String() string { func (*ApproveDraftChunkResponse) ProtoMessage() {} func (x *ApproveDraftChunkResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[179] + mi := &file_openshell_proto_msgTypes[180] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12940,7 +12986,7 @@ func (x *ApproveDraftChunkResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ApproveDraftChunkResponse.ProtoReflect.Descriptor instead. func (*ApproveDraftChunkResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{179} + return file_openshell_proto_rawDescGZIP(), []int{180} } func (x *ApproveDraftChunkResponse) GetPolicyVersion() uint32 { @@ -12974,7 +13020,7 @@ type RejectDraftChunkRequest struct { func (x *RejectDraftChunkRequest) Reset() { *x = RejectDraftChunkRequest{} - mi := &file_openshell_proto_msgTypes[180] + mi := &file_openshell_proto_msgTypes[181] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12986,7 +13032,7 @@ func (x *RejectDraftChunkRequest) String() string { func (*RejectDraftChunkRequest) ProtoMessage() {} func (x *RejectDraftChunkRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[180] + mi := &file_openshell_proto_msgTypes[181] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12999,7 +13045,7 @@ func (x *RejectDraftChunkRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use RejectDraftChunkRequest.ProtoReflect.Descriptor instead. func (*RejectDraftChunkRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{180} + return file_openshell_proto_rawDescGZIP(), []int{181} } func (x *RejectDraftChunkRequest) GetName() string { @@ -13038,7 +13084,7 @@ type RejectDraftChunkResponse struct { func (x *RejectDraftChunkResponse) Reset() { *x = RejectDraftChunkResponse{} - mi := &file_openshell_proto_msgTypes[181] + mi := &file_openshell_proto_msgTypes[182] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13050,7 +13096,7 @@ func (x *RejectDraftChunkResponse) String() string { func (*RejectDraftChunkResponse) ProtoMessage() {} func (x *RejectDraftChunkResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[181] + mi := &file_openshell_proto_msgTypes[182] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13063,7 +13109,7 @@ func (x *RejectDraftChunkResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use RejectDraftChunkResponse.ProtoReflect.Descriptor instead. func (*RejectDraftChunkResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{181} + return file_openshell_proto_rawDescGZIP(), []int{182} } // Approve all pending chunks. @@ -13077,7 +13123,7 @@ type DraftChunkApproval struct { func (x *DraftChunkApproval) Reset() { *x = DraftChunkApproval{} - mi := &file_openshell_proto_msgTypes[182] + mi := &file_openshell_proto_msgTypes[183] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13089,7 +13135,7 @@ func (x *DraftChunkApproval) String() string { func (*DraftChunkApproval) ProtoMessage() {} func (x *DraftChunkApproval) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[182] + mi := &file_openshell_proto_msgTypes[183] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13102,7 +13148,7 @@ func (x *DraftChunkApproval) ProtoReflect() protoreflect.Message { // Deprecated: Use DraftChunkApproval.ProtoReflect.Descriptor instead. func (*DraftChunkApproval) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{182} + return file_openshell_proto_rawDescGZIP(), []int{183} } func (x *DraftChunkApproval) GetChunkId() string { @@ -13136,7 +13182,7 @@ type ApproveAllDraftChunksRequest struct { func (x *ApproveAllDraftChunksRequest) Reset() { *x = ApproveAllDraftChunksRequest{} - mi := &file_openshell_proto_msgTypes[183] + mi := &file_openshell_proto_msgTypes[184] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13148,7 +13194,7 @@ func (x *ApproveAllDraftChunksRequest) String() string { func (*ApproveAllDraftChunksRequest) ProtoMessage() {} func (x *ApproveAllDraftChunksRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[183] + mi := &file_openshell_proto_msgTypes[184] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13161,7 +13207,7 @@ func (x *ApproveAllDraftChunksRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ApproveAllDraftChunksRequest.ProtoReflect.Descriptor instead. func (*ApproveAllDraftChunksRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{183} + return file_openshell_proto_rawDescGZIP(), []int{184} } func (x *ApproveAllDraftChunksRequest) GetName() string { @@ -13209,7 +13255,7 @@ type ApproveAllDraftChunksResponse struct { func (x *ApproveAllDraftChunksResponse) Reset() { *x = ApproveAllDraftChunksResponse{} - mi := &file_openshell_proto_msgTypes[184] + mi := &file_openshell_proto_msgTypes[185] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13221,7 +13267,7 @@ func (x *ApproveAllDraftChunksResponse) String() string { func (*ApproveAllDraftChunksResponse) ProtoMessage() {} func (x *ApproveAllDraftChunksResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[184] + mi := &file_openshell_proto_msgTypes[185] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13234,7 +13280,7 @@ func (x *ApproveAllDraftChunksResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ApproveAllDraftChunksResponse.ProtoReflect.Descriptor instead. func (*ApproveAllDraftChunksResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{184} + return file_openshell_proto_rawDescGZIP(), []int{185} } func (x *ApproveAllDraftChunksResponse) GetPolicyVersion() uint32 { @@ -13282,7 +13328,7 @@ type EditDraftChunkRequest struct { func (x *EditDraftChunkRequest) Reset() { *x = EditDraftChunkRequest{} - mi := &file_openshell_proto_msgTypes[185] + mi := &file_openshell_proto_msgTypes[186] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13294,7 +13340,7 @@ func (x *EditDraftChunkRequest) String() string { func (*EditDraftChunkRequest) ProtoMessage() {} func (x *EditDraftChunkRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[185] + mi := &file_openshell_proto_msgTypes[186] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13307,7 +13353,7 @@ func (x *EditDraftChunkRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use EditDraftChunkRequest.ProtoReflect.Descriptor instead. func (*EditDraftChunkRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{185} + return file_openshell_proto_rawDescGZIP(), []int{186} } func (x *EditDraftChunkRequest) GetName() string { @@ -13346,7 +13392,7 @@ type EditDraftChunkResponse struct { func (x *EditDraftChunkResponse) Reset() { *x = EditDraftChunkResponse{} - mi := &file_openshell_proto_msgTypes[186] + mi := &file_openshell_proto_msgTypes[187] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13358,7 +13404,7 @@ func (x *EditDraftChunkResponse) String() string { func (*EditDraftChunkResponse) ProtoMessage() {} func (x *EditDraftChunkResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[186] + mi := &file_openshell_proto_msgTypes[187] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13371,7 +13417,7 @@ func (x *EditDraftChunkResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use EditDraftChunkResponse.ProtoReflect.Descriptor instead. func (*EditDraftChunkResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{186} + return file_openshell_proto_rawDescGZIP(), []int{187} } // Reverse an approval (remove merged rule from active policy). @@ -13389,7 +13435,7 @@ type UndoDraftChunkRequest struct { func (x *UndoDraftChunkRequest) Reset() { *x = UndoDraftChunkRequest{} - mi := &file_openshell_proto_msgTypes[187] + mi := &file_openshell_proto_msgTypes[188] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13401,7 +13447,7 @@ func (x *UndoDraftChunkRequest) String() string { func (*UndoDraftChunkRequest) ProtoMessage() {} func (x *UndoDraftChunkRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[187] + mi := &file_openshell_proto_msgTypes[188] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13414,7 +13460,7 @@ func (x *UndoDraftChunkRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use UndoDraftChunkRequest.ProtoReflect.Descriptor instead. func (*UndoDraftChunkRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{187} + return file_openshell_proto_rawDescGZIP(), []int{188} } func (x *UndoDraftChunkRequest) GetName() string { @@ -13450,7 +13496,7 @@ type UndoDraftChunkResponse struct { func (x *UndoDraftChunkResponse) Reset() { *x = UndoDraftChunkResponse{} - mi := &file_openshell_proto_msgTypes[188] + mi := &file_openshell_proto_msgTypes[189] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13462,7 +13508,7 @@ func (x *UndoDraftChunkResponse) String() string { func (*UndoDraftChunkResponse) ProtoMessage() {} func (x *UndoDraftChunkResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[188] + mi := &file_openshell_proto_msgTypes[189] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13475,7 +13521,7 @@ func (x *UndoDraftChunkResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use UndoDraftChunkResponse.ProtoReflect.Descriptor instead. func (*UndoDraftChunkResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{188} + return file_openshell_proto_rawDescGZIP(), []int{189} } func (x *UndoDraftChunkResponse) GetPolicyVersion() uint32 { @@ -13505,7 +13551,7 @@ type ClearDraftChunksRequest struct { func (x *ClearDraftChunksRequest) Reset() { *x = ClearDraftChunksRequest{} - mi := &file_openshell_proto_msgTypes[189] + mi := &file_openshell_proto_msgTypes[190] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13517,7 +13563,7 @@ func (x *ClearDraftChunksRequest) String() string { func (*ClearDraftChunksRequest) ProtoMessage() {} func (x *ClearDraftChunksRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[189] + mi := &file_openshell_proto_msgTypes[190] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13530,7 +13576,7 @@ func (x *ClearDraftChunksRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ClearDraftChunksRequest.ProtoReflect.Descriptor instead. func (*ClearDraftChunksRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{189} + return file_openshell_proto_rawDescGZIP(), []int{190} } func (x *ClearDraftChunksRequest) GetName() string { @@ -13557,7 +13603,7 @@ type ClearDraftChunksResponse struct { func (x *ClearDraftChunksResponse) Reset() { *x = ClearDraftChunksResponse{} - mi := &file_openshell_proto_msgTypes[190] + mi := &file_openshell_proto_msgTypes[191] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13569,7 +13615,7 @@ func (x *ClearDraftChunksResponse) String() string { func (*ClearDraftChunksResponse) ProtoMessage() {} func (x *ClearDraftChunksResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[190] + mi := &file_openshell_proto_msgTypes[191] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13582,7 +13628,7 @@ func (x *ClearDraftChunksResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ClearDraftChunksResponse.ProtoReflect.Descriptor instead. func (*ClearDraftChunksResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{190} + return file_openshell_proto_rawDescGZIP(), []int{191} } func (x *ClearDraftChunksResponse) GetChunksCleared() uint32 { @@ -13605,7 +13651,7 @@ type GetDraftHistoryRequest struct { func (x *GetDraftHistoryRequest) Reset() { *x = GetDraftHistoryRequest{} - mi := &file_openshell_proto_msgTypes[191] + mi := &file_openshell_proto_msgTypes[192] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13617,7 +13663,7 @@ func (x *GetDraftHistoryRequest) String() string { func (*GetDraftHistoryRequest) ProtoMessage() {} func (x *GetDraftHistoryRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[191] + mi := &file_openshell_proto_msgTypes[192] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13630,7 +13676,7 @@ func (x *GetDraftHistoryRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetDraftHistoryRequest.ProtoReflect.Descriptor instead. func (*GetDraftHistoryRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{191} + return file_openshell_proto_rawDescGZIP(), []int{192} } func (x *GetDraftHistoryRequest) GetName() string { @@ -13664,7 +13710,7 @@ type DraftHistoryEntry struct { func (x *DraftHistoryEntry) Reset() { *x = DraftHistoryEntry{} - mi := &file_openshell_proto_msgTypes[192] + mi := &file_openshell_proto_msgTypes[193] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13676,7 +13722,7 @@ func (x *DraftHistoryEntry) String() string { func (*DraftHistoryEntry) ProtoMessage() {} func (x *DraftHistoryEntry) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[192] + mi := &file_openshell_proto_msgTypes[193] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13689,7 +13735,7 @@ func (x *DraftHistoryEntry) ProtoReflect() protoreflect.Message { // Deprecated: Use DraftHistoryEntry.ProtoReflect.Descriptor instead. func (*DraftHistoryEntry) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{192} + return file_openshell_proto_rawDescGZIP(), []int{193} } func (x *DraftHistoryEntry) GetTimestampMs() int64 { @@ -13730,7 +13776,7 @@ type GetDraftHistoryResponse struct { func (x *GetDraftHistoryResponse) Reset() { *x = GetDraftHistoryResponse{} - mi := &file_openshell_proto_msgTypes[193] + mi := &file_openshell_proto_msgTypes[194] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13742,7 +13788,7 @@ func (x *GetDraftHistoryResponse) String() string { func (*GetDraftHistoryResponse) ProtoMessage() {} func (x *GetDraftHistoryResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[193] + mi := &file_openshell_proto_msgTypes[194] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13755,7 +13801,7 @@ func (x *GetDraftHistoryResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use GetDraftHistoryResponse.ProtoReflect.Descriptor instead. func (*GetDraftHistoryResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{193} + return file_openshell_proto_rawDescGZIP(), []int{194} } func (x *GetDraftHistoryResponse) GetEntries() []*DraftHistoryEntry { @@ -13784,7 +13830,7 @@ type PolicyRevisionPayload struct { func (x *PolicyRevisionPayload) Reset() { *x = PolicyRevisionPayload{} - mi := &file_openshell_proto_msgTypes[194] + mi := &file_openshell_proto_msgTypes[195] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13796,7 +13842,7 @@ func (x *PolicyRevisionPayload) String() string { func (*PolicyRevisionPayload) ProtoMessage() {} func (x *PolicyRevisionPayload) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[194] + mi := &file_openshell_proto_msgTypes[195] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13809,7 +13855,7 @@ func (x *PolicyRevisionPayload) ProtoReflect() protoreflect.Message { // Deprecated: Use PolicyRevisionPayload.ProtoReflect.Descriptor instead. func (*PolicyRevisionPayload) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{194} + return file_openshell_proto_rawDescGZIP(), []int{195} } func (x *PolicyRevisionPayload) GetPolicy() *sandboxv1.SandboxPolicy { @@ -13888,7 +13934,7 @@ type DraftChunkPayload struct { func (x *DraftChunkPayload) Reset() { *x = DraftChunkPayload{} - mi := &file_openshell_proto_msgTypes[195] + mi := &file_openshell_proto_msgTypes[196] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13900,7 +13946,7 @@ func (x *DraftChunkPayload) String() string { func (*DraftChunkPayload) ProtoMessage() {} func (x *DraftChunkPayload) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[195] + mi := &file_openshell_proto_msgTypes[196] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13913,7 +13959,7 @@ func (x *DraftChunkPayload) ProtoReflect() protoreflect.Message { // Deprecated: Use DraftChunkPayload.ProtoReflect.Descriptor instead. func (*DraftChunkPayload) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{195} + return file_openshell_proto_rawDescGZIP(), []int{196} } func (x *DraftChunkPayload) GetRuleName() string { @@ -14061,7 +14107,7 @@ type StoredPolicyRevision struct { func (x *StoredPolicyRevision) Reset() { *x = StoredPolicyRevision{} - mi := &file_openshell_proto_msgTypes[196] + mi := &file_openshell_proto_msgTypes[197] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14073,7 +14119,7 @@ func (x *StoredPolicyRevision) String() string { func (*StoredPolicyRevision) ProtoMessage() {} func (x *StoredPolicyRevision) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[196] + mi := &file_openshell_proto_msgTypes[197] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14086,7 +14132,7 @@ func (x *StoredPolicyRevision) ProtoReflect() protoreflect.Message { // Deprecated: Use StoredPolicyRevision.ProtoReflect.Descriptor instead. func (*StoredPolicyRevision) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{196} + return file_openshell_proto_rawDescGZIP(), []int{197} } func (x *StoredPolicyRevision) GetId() string { @@ -14195,7 +14241,7 @@ type StoredDraftChunk struct { func (x *StoredDraftChunk) Reset() { *x = StoredDraftChunk{} - mi := &file_openshell_proto_msgTypes[197] + mi := &file_openshell_proto_msgTypes[198] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14207,7 +14253,7 @@ func (x *StoredDraftChunk) String() string { func (*StoredDraftChunk) ProtoMessage() {} func (x *StoredDraftChunk) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[197] + mi := &file_openshell_proto_msgTypes[198] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14220,7 +14266,7 @@ func (x *StoredDraftChunk) ProtoReflect() protoreflect.Message { // Deprecated: Use StoredDraftChunk.ProtoReflect.Descriptor instead. func (*StoredDraftChunk) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{197} + return file_openshell_proto_rawDescGZIP(), []int{198} } func (x *StoredDraftChunk) GetId() string { @@ -14411,7 +14457,7 @@ type CreateWorkspaceRequest struct { func (x *CreateWorkspaceRequest) Reset() { *x = CreateWorkspaceRequest{} - mi := &file_openshell_proto_msgTypes[198] + mi := &file_openshell_proto_msgTypes[199] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14423,7 +14469,7 @@ func (x *CreateWorkspaceRequest) String() string { func (*CreateWorkspaceRequest) ProtoMessage() {} func (x *CreateWorkspaceRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[198] + mi := &file_openshell_proto_msgTypes[199] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14436,7 +14482,7 @@ func (x *CreateWorkspaceRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use CreateWorkspaceRequest.ProtoReflect.Descriptor instead. func (*CreateWorkspaceRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{198} + return file_openshell_proto_rawDescGZIP(), []int{199} } func (x *CreateWorkspaceRequest) GetName() string { @@ -14463,7 +14509,7 @@ type CreateWorkspaceResponse struct { func (x *CreateWorkspaceResponse) Reset() { *x = CreateWorkspaceResponse{} - mi := &file_openshell_proto_msgTypes[199] + mi := &file_openshell_proto_msgTypes[200] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14475,7 +14521,7 @@ func (x *CreateWorkspaceResponse) String() string { func (*CreateWorkspaceResponse) ProtoMessage() {} func (x *CreateWorkspaceResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[199] + mi := &file_openshell_proto_msgTypes[200] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14488,7 +14534,7 @@ func (x *CreateWorkspaceResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use CreateWorkspaceResponse.ProtoReflect.Descriptor instead. func (*CreateWorkspaceResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{199} + return file_openshell_proto_rawDescGZIP(), []int{200} } func (x *CreateWorkspaceResponse) GetWorkspace() *datamodelv1.Workspace { @@ -14509,7 +14555,7 @@ type GetWorkspaceRequest struct { func (x *GetWorkspaceRequest) Reset() { *x = GetWorkspaceRequest{} - mi := &file_openshell_proto_msgTypes[200] + mi := &file_openshell_proto_msgTypes[201] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14521,7 +14567,7 @@ func (x *GetWorkspaceRequest) String() string { func (*GetWorkspaceRequest) ProtoMessage() {} func (x *GetWorkspaceRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[200] + mi := &file_openshell_proto_msgTypes[201] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14534,7 +14580,7 @@ func (x *GetWorkspaceRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetWorkspaceRequest.ProtoReflect.Descriptor instead. func (*GetWorkspaceRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{200} + return file_openshell_proto_rawDescGZIP(), []int{201} } func (x *GetWorkspaceRequest) GetName() string { @@ -14554,7 +14600,7 @@ type GetWorkspaceResponse struct { func (x *GetWorkspaceResponse) Reset() { *x = GetWorkspaceResponse{} - mi := &file_openshell_proto_msgTypes[201] + mi := &file_openshell_proto_msgTypes[202] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14566,7 +14612,7 @@ func (x *GetWorkspaceResponse) String() string { func (*GetWorkspaceResponse) ProtoMessage() {} func (x *GetWorkspaceResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[201] + mi := &file_openshell_proto_msgTypes[202] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14579,7 +14625,7 @@ func (x *GetWorkspaceResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use GetWorkspaceResponse.ProtoReflect.Descriptor instead. func (*GetWorkspaceResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{201} + return file_openshell_proto_rawDescGZIP(), []int{202} } func (x *GetWorkspaceResponse) GetWorkspace() *datamodelv1.Workspace { @@ -14602,7 +14648,7 @@ type ListWorkspacesRequest struct { func (x *ListWorkspacesRequest) Reset() { *x = ListWorkspacesRequest{} - mi := &file_openshell_proto_msgTypes[202] + mi := &file_openshell_proto_msgTypes[203] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14614,7 +14660,7 @@ func (x *ListWorkspacesRequest) String() string { func (*ListWorkspacesRequest) ProtoMessage() {} func (x *ListWorkspacesRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[202] + mi := &file_openshell_proto_msgTypes[203] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14627,7 +14673,7 @@ func (x *ListWorkspacesRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListWorkspacesRequest.ProtoReflect.Descriptor instead. func (*ListWorkspacesRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{202} + return file_openshell_proto_rawDescGZIP(), []int{203} } func (x *ListWorkspacesRequest) GetLimit() uint32 { @@ -14661,7 +14707,7 @@ type ListWorkspacesResponse struct { func (x *ListWorkspacesResponse) Reset() { *x = ListWorkspacesResponse{} - mi := &file_openshell_proto_msgTypes[203] + mi := &file_openshell_proto_msgTypes[204] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14673,7 +14719,7 @@ func (x *ListWorkspacesResponse) String() string { func (*ListWorkspacesResponse) ProtoMessage() {} func (x *ListWorkspacesResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[203] + mi := &file_openshell_proto_msgTypes[204] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14686,7 +14732,7 @@ func (x *ListWorkspacesResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListWorkspacesResponse.ProtoReflect.Descriptor instead. func (*ListWorkspacesResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{203} + return file_openshell_proto_rawDescGZIP(), []int{204} } func (x *ListWorkspacesResponse) GetWorkspaces() []*datamodelv1.Workspace { @@ -14707,7 +14753,7 @@ type DeleteWorkspaceRequest struct { func (x *DeleteWorkspaceRequest) Reset() { *x = DeleteWorkspaceRequest{} - mi := &file_openshell_proto_msgTypes[204] + mi := &file_openshell_proto_msgTypes[205] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14719,7 +14765,7 @@ func (x *DeleteWorkspaceRequest) String() string { func (*DeleteWorkspaceRequest) ProtoMessage() {} func (x *DeleteWorkspaceRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[204] + mi := &file_openshell_proto_msgTypes[205] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14732,7 +14778,7 @@ func (x *DeleteWorkspaceRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteWorkspaceRequest.ProtoReflect.Descriptor instead. func (*DeleteWorkspaceRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{204} + return file_openshell_proto_rawDescGZIP(), []int{205} } func (x *DeleteWorkspaceRequest) GetName() string { @@ -14752,7 +14798,7 @@ type DeleteWorkspaceResponse struct { func (x *DeleteWorkspaceResponse) Reset() { *x = DeleteWorkspaceResponse{} - mi := &file_openshell_proto_msgTypes[205] + mi := &file_openshell_proto_msgTypes[206] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14764,7 +14810,7 @@ func (x *DeleteWorkspaceResponse) String() string { func (*DeleteWorkspaceResponse) ProtoMessage() {} func (x *DeleteWorkspaceResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[205] + mi := &file_openshell_proto_msgTypes[206] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14777,7 +14823,7 @@ func (x *DeleteWorkspaceResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteWorkspaceResponse.ProtoReflect.Descriptor instead. func (*DeleteWorkspaceResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{205} + return file_openshell_proto_rawDescGZIP(), []int{206} } func (x *DeleteWorkspaceResponse) GetDeleted() bool { @@ -14801,7 +14847,7 @@ type WorkspaceMember struct { func (x *WorkspaceMember) Reset() { *x = WorkspaceMember{} - mi := &file_openshell_proto_msgTypes[206] + mi := &file_openshell_proto_msgTypes[207] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14813,7 +14859,7 @@ func (x *WorkspaceMember) String() string { func (*WorkspaceMember) ProtoMessage() {} func (x *WorkspaceMember) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[206] + mi := &file_openshell_proto_msgTypes[207] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14826,7 +14872,7 @@ func (x *WorkspaceMember) ProtoReflect() protoreflect.Message { // Deprecated: Use WorkspaceMember.ProtoReflect.Descriptor instead. func (*WorkspaceMember) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{206} + return file_openshell_proto_rawDescGZIP(), []int{207} } func (x *WorkspaceMember) GetMetadata() *datamodelv1.ObjectMeta { @@ -14865,7 +14911,7 @@ type AddWorkspaceMemberRequest struct { func (x *AddWorkspaceMemberRequest) Reset() { *x = AddWorkspaceMemberRequest{} - mi := &file_openshell_proto_msgTypes[207] + mi := &file_openshell_proto_msgTypes[208] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14877,7 +14923,7 @@ func (x *AddWorkspaceMemberRequest) String() string { func (*AddWorkspaceMemberRequest) ProtoMessage() {} func (x *AddWorkspaceMemberRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[207] + mi := &file_openshell_proto_msgTypes[208] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14890,7 +14936,7 @@ func (x *AddWorkspaceMemberRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use AddWorkspaceMemberRequest.ProtoReflect.Descriptor instead. func (*AddWorkspaceMemberRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{207} + return file_openshell_proto_rawDescGZIP(), []int{208} } func (x *AddWorkspaceMemberRequest) GetWorkspace() string { @@ -14924,7 +14970,7 @@ type AddWorkspaceMemberResponse struct { func (x *AddWorkspaceMemberResponse) Reset() { *x = AddWorkspaceMemberResponse{} - mi := &file_openshell_proto_msgTypes[208] + mi := &file_openshell_proto_msgTypes[209] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14936,7 +14982,7 @@ func (x *AddWorkspaceMemberResponse) String() string { func (*AddWorkspaceMemberResponse) ProtoMessage() {} func (x *AddWorkspaceMemberResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[208] + mi := &file_openshell_proto_msgTypes[209] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14949,7 +14995,7 @@ func (x *AddWorkspaceMemberResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use AddWorkspaceMemberResponse.ProtoReflect.Descriptor instead. func (*AddWorkspaceMemberResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{208} + return file_openshell_proto_rawDescGZIP(), []int{209} } func (x *AddWorkspaceMemberResponse) GetMember() *WorkspaceMember { @@ -14972,7 +15018,7 @@ type RemoveWorkspaceMemberRequest struct { func (x *RemoveWorkspaceMemberRequest) Reset() { *x = RemoveWorkspaceMemberRequest{} - mi := &file_openshell_proto_msgTypes[209] + mi := &file_openshell_proto_msgTypes[210] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14984,7 +15030,7 @@ func (x *RemoveWorkspaceMemberRequest) String() string { func (*RemoveWorkspaceMemberRequest) ProtoMessage() {} func (x *RemoveWorkspaceMemberRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[209] + mi := &file_openshell_proto_msgTypes[210] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14997,7 +15043,7 @@ func (x *RemoveWorkspaceMemberRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use RemoveWorkspaceMemberRequest.ProtoReflect.Descriptor instead. func (*RemoveWorkspaceMemberRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{209} + return file_openshell_proto_rawDescGZIP(), []int{210} } func (x *RemoveWorkspaceMemberRequest) GetWorkspace() string { @@ -15024,7 +15070,7 @@ type RemoveWorkspaceMemberResponse struct { func (x *RemoveWorkspaceMemberResponse) Reset() { *x = RemoveWorkspaceMemberResponse{} - mi := &file_openshell_proto_msgTypes[210] + mi := &file_openshell_proto_msgTypes[211] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -15036,7 +15082,7 @@ func (x *RemoveWorkspaceMemberResponse) String() string { func (*RemoveWorkspaceMemberResponse) ProtoMessage() {} func (x *RemoveWorkspaceMemberResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[210] + mi := &file_openshell_proto_msgTypes[211] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15049,7 +15095,7 @@ func (x *RemoveWorkspaceMemberResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use RemoveWorkspaceMemberResponse.ProtoReflect.Descriptor instead. func (*RemoveWorkspaceMemberResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{210} + return file_openshell_proto_rawDescGZIP(), []int{211} } func (x *RemoveWorkspaceMemberResponse) GetRemoved() bool { @@ -15072,7 +15118,7 @@ type ListWorkspaceMembersRequest struct { func (x *ListWorkspaceMembersRequest) Reset() { *x = ListWorkspaceMembersRequest{} - mi := &file_openshell_proto_msgTypes[211] + mi := &file_openshell_proto_msgTypes[212] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -15084,7 +15130,7 @@ func (x *ListWorkspaceMembersRequest) String() string { func (*ListWorkspaceMembersRequest) ProtoMessage() {} func (x *ListWorkspaceMembersRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[211] + mi := &file_openshell_proto_msgTypes[212] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15097,7 +15143,7 @@ func (x *ListWorkspaceMembersRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListWorkspaceMembersRequest.ProtoReflect.Descriptor instead. func (*ListWorkspaceMembersRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{211} + return file_openshell_proto_rawDescGZIP(), []int{212} } func (x *ListWorkspaceMembersRequest) GetWorkspace() string { @@ -15131,7 +15177,7 @@ type ListWorkspaceMembersResponse struct { func (x *ListWorkspaceMembersResponse) Reset() { *x = ListWorkspaceMembersResponse{} - mi := &file_openshell_proto_msgTypes[212] + mi := &file_openshell_proto_msgTypes[213] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -15143,7 +15189,7 @@ func (x *ListWorkspaceMembersResponse) String() string { func (*ListWorkspaceMembersResponse) ProtoMessage() {} func (x *ListWorkspaceMembersResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[212] + mi := &file_openshell_proto_msgTypes[213] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15156,7 +15202,7 @@ func (x *ListWorkspaceMembersResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListWorkspaceMembersResponse.ProtoReflect.Descriptor instead. func (*ListWorkspaceMembersResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{212} + return file_openshell_proto_rawDescGZIP(), []int{213} } func (x *ListWorkspaceMembersResponse) GetMembers() []*WorkspaceMember { @@ -15184,7 +15230,7 @@ type ExtensionServiceCredential struct { func (x *ExtensionServiceCredential) Reset() { *x = ExtensionServiceCredential{} - mi := &file_openshell_proto_msgTypes[213] + mi := &file_openshell_proto_msgTypes[214] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -15196,7 +15242,7 @@ func (x *ExtensionServiceCredential) String() string { func (*ExtensionServiceCredential) ProtoMessage() {} func (x *ExtensionServiceCredential) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[213] + mi := &file_openshell_proto_msgTypes[214] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15209,7 +15255,7 @@ func (x *ExtensionServiceCredential) ProtoReflect() protoreflect.Message { // Deprecated: Use ExtensionServiceCredential.ProtoReflect.Descriptor instead. func (*ExtensionServiceCredential) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{213} + return file_openshell_proto_rawDescGZIP(), []int{214} } func (x *ExtensionServiceCredential) GetServiceName() string { @@ -15301,12 +15347,18 @@ const file_openshell_proto_rawDesc = "" + "\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" + "\x05value\x18\x02 \x01(\tR\x05value:\x028\x01J\x04\b\n" + "\x10\vJ\x04\b\v\x10\fR\n" + - "gpu_deviceR\x16proposal_approval_mode\"O\n" + + "gpu_deviceR\x16proposal_approval_mode\"\xca\x01\n" + "\x14ResourceRequirements\x127\n" + - "\x03gpu\x18\x01 \x01(\v2%.openshell.v1.GpuResourceRequirementsR\x03gpu\">\n" + + "\x03gpu\x18\x01 \x01(\v2%.openshell.v1.GpuResourceRequirementsR\x03gpu\x127\n" + + "\x03cpu\x18\x02 \x01(\v2%.openshell.v1.CpuResourceRequirementsR\x03cpu\x12@\n" + + "\x06memory\x18\x03 \x01(\v2(.openshell.v1.MemoryResourceRequirementsR\x06memory\">\n" + "\x17GpuResourceRequirements\x12\x19\n" + "\x05count\x18\x01 \x01(\rH\x00R\x05count\x88\x01\x01B\b\n" + - "\x06_count\"\xef\x05\n" + + "\x06_count\"/\n" + + "\x17CpuResourceRequirements\x12\x14\n" + + "\x05limit\x18\x01 \x01(\tR\x05limit\"2\n" + + "\x1aMemoryResourceRequirements\x12\x14\n" + + "\x05limit\x18\x01 \x01(\tR\x05limit\"\xef\x05\n" + "\x0fSandboxTemplate\x12\x14\n" + "\x05image\x18\x01 \x01(\tR\x05image\x12,\n" + "\x12runtime_class_name\x18\x02 \x01(\tR\x10runtimeClassName\x12!\n" + @@ -15335,18 +15387,14 @@ const file_openshell_proto_rawDesc = "" + "\x1bSandboxWorkloadTemplateSpec\x12?\n" + "\bworkload\x18\x01 \x01(\v2#.openshell.v1.SandboxWorkloadConfigR\bworkload\x12<\n" + "\rdriver_config\x18\x02 \x01(\v2\x17.google.protobuf.StructR\fdriverConfig\x12U\n" + - "\x15desired_service_level\x18\x03 \x01(\v2!.openshell.v1.SandboxServiceLevelR\x13desiredServiceLevel\"\x83\x02\n" + + "\x15desired_service_level\x18\x03 \x01(\v2!.openshell.v1.SandboxServiceLevelR\x13desiredServiceLevel\"\x87\x02\n" + "\x15SandboxWorkloadConfig\x12\x14\n" + "\x05image\x18\x01 \x01(\tR\x05image\x12V\n" + - "\venvironment\x18\x02 \x03(\v24.openshell.v1.SandboxWorkloadConfig.EnvironmentEntryR\venvironment\x12<\n" + - "\tresources\x18\x03 \x01(\v2\x1e.openshell.v1.SandboxResourcesR\tresources\x1a>\n" + + "\venvironment\x18\x02 \x03(\v24.openshell.v1.SandboxWorkloadConfig.EnvironmentEntryR\venvironment\x12@\n" + + "\tresources\x18\x03 \x01(\v2\".openshell.v1.ResourceRequirementsR\tresources\x1a>\n" + "\x10EnvironmentEntry\x12\x10\n" + "\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" + - "\x05value\x18\x02 \x01(\tR\x05value:\x028\x01\"u\n" + - "\x10SandboxResources\x12\x10\n" + - "\x03cpu\x18\x01 \x01(\tR\x03cpu\x12\x16\n" + - "\x06memory\x18\x02 \x01(\tR\x06memory\x127\n" + - "\x03gpu\x18\x03 \x01(\v2%.openshell.v1.GpuResourceRequirementsR\x03gpu\"M\n" + + "\x05value\x18\x02 \x01(\tR\x05value:\x028\x01\"M\n" + "\x13SandboxServiceLevel\x126\n" + "\astartup\x18\x01 \x01(\v2\x1c.openshell.v1.SandboxStartupR\astartup\"k\n" + "\x0eSandboxStartup\x12<\n" + @@ -16609,7 +16657,7 @@ func file_openshell_proto_rawDescGZIP() []byte { } var file_openshell_proto_enumTypes = make([]protoimpl.EnumInfo, 8) -var file_openshell_proto_msgTypes = make([]protoimpl.MessageInfo, 240) +var file_openshell_proto_msgTypes = make([]protoimpl.MessageInfo, 241) var file_openshell_proto_goTypes = []any{ (SandboxPhase)(0), // 0: openshell.v1.SandboxPhase (ProviderCredentialTokenGrantType)(0), // 1: openshell.v1.ProviderCredentialTokenGrantType @@ -16639,246 +16687,247 @@ var file_openshell_proto_goTypes = []any{ (*SandboxSpec)(nil), // 25: openshell.v1.SandboxSpec (*ResourceRequirements)(nil), // 26: openshell.v1.ResourceRequirements (*GpuResourceRequirements)(nil), // 27: openshell.v1.GpuResourceRequirements - (*SandboxTemplate)(nil), // 28: openshell.v1.SandboxTemplate - (*SandboxWorkloadTemplate)(nil), // 29: openshell.v1.SandboxWorkloadTemplate - (*SandboxWorkloadTemplateSpec)(nil), // 30: openshell.v1.SandboxWorkloadTemplateSpec - (*SandboxWorkloadConfig)(nil), // 31: openshell.v1.SandboxWorkloadConfig - (*SandboxResources)(nil), // 32: openshell.v1.SandboxResources - (*SandboxServiceLevel)(nil), // 33: openshell.v1.SandboxServiceLevel - (*SandboxStartup)(nil), // 34: openshell.v1.SandboxStartup - (*SandboxWorkloadTemplateProvenance)(nil), // 35: openshell.v1.SandboxWorkloadTemplateProvenance - (*SandboxStatus)(nil), // 36: openshell.v1.SandboxStatus - (*SandboxCondition)(nil), // 37: openshell.v1.SandboxCondition - (*PlatformEvent)(nil), // 38: openshell.v1.PlatformEvent - (*CreateSandboxRequest)(nil), // 39: openshell.v1.CreateSandboxRequest - (*CreateSandboxTemplateRequest)(nil), // 40: openshell.v1.CreateSandboxTemplateRequest - (*GetSandboxTemplateRequest)(nil), // 41: openshell.v1.GetSandboxTemplateRequest - (*ListSandboxTemplatesRequest)(nil), // 42: openshell.v1.ListSandboxTemplatesRequest - (*DeleteSandboxTemplateRequest)(nil), // 43: openshell.v1.DeleteSandboxTemplateRequest - (*SandboxTemplateResponse)(nil), // 44: openshell.v1.SandboxTemplateResponse - (*ListSandboxTemplatesResponse)(nil), // 45: openshell.v1.ListSandboxTemplatesResponse - (*DeleteSandboxTemplateResponse)(nil), // 46: openshell.v1.DeleteSandboxTemplateResponse - (*BeginRootfsTarStagingRequest)(nil), // 47: openshell.v1.BeginRootfsTarStagingRequest - (*BeginRootfsTarStagingResponse)(nil), // 48: openshell.v1.BeginRootfsTarStagingResponse - (*GetSandboxRequest)(nil), // 49: openshell.v1.GetSandboxRequest - (*ListSandboxesRequest)(nil), // 50: openshell.v1.ListSandboxesRequest - (*ListSandboxProvidersRequest)(nil), // 51: openshell.v1.ListSandboxProvidersRequest - (*AttachSandboxProviderRequest)(nil), // 52: openshell.v1.AttachSandboxProviderRequest - (*DetachSandboxProviderRequest)(nil), // 53: openshell.v1.DetachSandboxProviderRequest - (*DeleteSandboxRequest)(nil), // 54: openshell.v1.DeleteSandboxRequest - (*StopSandboxRequest)(nil), // 55: openshell.v1.StopSandboxRequest - (*StartSandboxRequest)(nil), // 56: openshell.v1.StartSandboxRequest - (*SandboxResponse)(nil), // 57: openshell.v1.SandboxResponse - (*ListSandboxesResponse)(nil), // 58: openshell.v1.ListSandboxesResponse - (*ListSandboxProvidersResponse)(nil), // 59: openshell.v1.ListSandboxProvidersResponse - (*AttachSandboxProviderResponse)(nil), // 60: openshell.v1.AttachSandboxProviderResponse - (*DetachSandboxProviderResponse)(nil), // 61: openshell.v1.DetachSandboxProviderResponse - (*DeleteSandboxResponse)(nil), // 62: openshell.v1.DeleteSandboxResponse - (*CreateSshSessionRequest)(nil), // 63: openshell.v1.CreateSshSessionRequest - (*CreateSshSessionResponse)(nil), // 64: openshell.v1.CreateSshSessionResponse - (*ExposeServiceRequest)(nil), // 65: openshell.v1.ExposeServiceRequest - (*GetServiceRequest)(nil), // 66: openshell.v1.GetServiceRequest - (*ListServicesRequest)(nil), // 67: openshell.v1.ListServicesRequest - (*ListServicesResponse)(nil), // 68: openshell.v1.ListServicesResponse - (*DeleteServiceRequest)(nil), // 69: openshell.v1.DeleteServiceRequest - (*DeleteServiceResponse)(nil), // 70: openshell.v1.DeleteServiceResponse - (*ServiceEndpoint)(nil), // 71: openshell.v1.ServiceEndpoint - (*ServiceEndpointResponse)(nil), // 72: openshell.v1.ServiceEndpointResponse - (*RevokeSshSessionRequest)(nil), // 73: openshell.v1.RevokeSshSessionRequest - (*RevokeSshSessionResponse)(nil), // 74: openshell.v1.RevokeSshSessionResponse - (*ExecSandboxRequest)(nil), // 75: openshell.v1.ExecSandboxRequest - (*ExecSandboxStdout)(nil), // 76: openshell.v1.ExecSandboxStdout - (*ExecSandboxStderr)(nil), // 77: openshell.v1.ExecSandboxStderr - (*ExecSandboxExit)(nil), // 78: openshell.v1.ExecSandboxExit - (*ExecSandboxEvent)(nil), // 79: openshell.v1.ExecSandboxEvent - (*TcpForwardInit)(nil), // 80: openshell.v1.TcpForwardInit - (*TcpForwardFrame)(nil), // 81: openshell.v1.TcpForwardFrame - (*ExecSandboxInput)(nil), // 82: openshell.v1.ExecSandboxInput - (*ExecSandboxWindowResize)(nil), // 83: openshell.v1.ExecSandboxWindowResize - (*SshSession)(nil), // 84: openshell.v1.SshSession - (*WatchSandboxRequest)(nil), // 85: openshell.v1.WatchSandboxRequest - (*SandboxStreamEvent)(nil), // 86: openshell.v1.SandboxStreamEvent - (*SandboxLogLine)(nil), // 87: openshell.v1.SandboxLogLine - (*SandboxStreamWarning)(nil), // 88: openshell.v1.SandboxStreamWarning - (*CreateProviderRequest)(nil), // 89: openshell.v1.CreateProviderRequest - (*GetProviderRequest)(nil), // 90: openshell.v1.GetProviderRequest - (*ListProvidersRequest)(nil), // 91: openshell.v1.ListProvidersRequest - (*UpdateProviderRequest)(nil), // 92: openshell.v1.UpdateProviderRequest - (*DeleteProviderRequest)(nil), // 93: openshell.v1.DeleteProviderRequest - (*ProviderResponse)(nil), // 94: openshell.v1.ProviderResponse - (*ListProvidersResponse)(nil), // 95: openshell.v1.ListProvidersResponse - (*ListProviderProfilesRequest)(nil), // 96: openshell.v1.ListProviderProfilesRequest - (*GetProviderProfileRequest)(nil), // 97: openshell.v1.GetProviderProfileRequest - (*ProviderProfileImportItem)(nil), // 98: openshell.v1.ProviderProfileImportItem - (*ProviderProfileDiagnostic)(nil), // 99: openshell.v1.ProviderProfileDiagnostic - (*ProviderCredentialTokenGrantAudienceOverride)(nil), // 100: openshell.v1.ProviderCredentialTokenGrantAudienceOverride - (*ProviderCredentialTokenGrantSubjectToken)(nil), // 101: openshell.v1.ProviderCredentialTokenGrantSubjectToken - (*ProviderCredentialTokenGrant)(nil), // 102: openshell.v1.ProviderCredentialTokenGrant - (*ProviderProfileCredential)(nil), // 103: openshell.v1.ProviderProfileCredential - (*ProviderCredentialRefreshMaterial)(nil), // 104: openshell.v1.ProviderCredentialRefreshMaterial - (*ProviderCredentialRefreshOutput)(nil), // 105: openshell.v1.ProviderCredentialRefreshOutput - (*ProviderCredentialRefresh)(nil), // 106: openshell.v1.ProviderCredentialRefresh - (*ProviderCredentialRefreshStatus)(nil), // 107: openshell.v1.ProviderCredentialRefreshStatus - (*ProviderProfileDiscovery)(nil), // 108: openshell.v1.ProviderProfileDiscovery - (*StoredProviderCredentialRefreshState)(nil), // 109: openshell.v1.StoredProviderCredentialRefreshState - (*StoredRefreshMaterialDeletion)(nil), // 110: openshell.v1.StoredRefreshMaterialDeletion - (*GetProviderRefreshStatusRequest)(nil), // 111: openshell.v1.GetProviderRefreshStatusRequest - (*GetProviderRefreshStatusResponse)(nil), // 112: openshell.v1.GetProviderRefreshStatusResponse - (*ConfigureProviderRefreshRequest)(nil), // 113: openshell.v1.ConfigureProviderRefreshRequest - (*ConfigureProviderRefreshResponse)(nil), // 114: openshell.v1.ConfigureProviderRefreshResponse - (*RotateProviderCredentialRequest)(nil), // 115: openshell.v1.RotateProviderCredentialRequest - (*RotateProviderCredentialResponse)(nil), // 116: openshell.v1.RotateProviderCredentialResponse - (*DeleteProviderRefreshRequest)(nil), // 117: openshell.v1.DeleteProviderRefreshRequest - (*DeleteProviderRefreshResponse)(nil), // 118: openshell.v1.DeleteProviderRefreshResponse - (*ProviderProfile)(nil), // 119: openshell.v1.ProviderProfile - (*StoredProviderProfile)(nil), // 120: openshell.v1.StoredProviderProfile - (*ProviderProfileResponse)(nil), // 121: openshell.v1.ProviderProfileResponse - (*ListProviderProfilesResponse)(nil), // 122: openshell.v1.ListProviderProfilesResponse - (*ImportProviderProfilesRequest)(nil), // 123: openshell.v1.ImportProviderProfilesRequest - (*ImportProviderProfilesResponse)(nil), // 124: openshell.v1.ImportProviderProfilesResponse - (*UpdateProviderProfilesRequest)(nil), // 125: openshell.v1.UpdateProviderProfilesRequest - (*UpdateProviderProfilesResponse)(nil), // 126: openshell.v1.UpdateProviderProfilesResponse - (*LintProviderProfilesRequest)(nil), // 127: openshell.v1.LintProviderProfilesRequest - (*LintProviderProfilesResponse)(nil), // 128: openshell.v1.LintProviderProfilesResponse - (*DeleteProviderResponse)(nil), // 129: openshell.v1.DeleteProviderResponse - (*DeleteProviderProfileRequest)(nil), // 130: openshell.v1.DeleteProviderProfileRequest - (*DeleteProviderProfileResponse)(nil), // 131: openshell.v1.DeleteProviderProfileResponse - (*GetSandboxProviderEnvironmentRequest)(nil), // 132: openshell.v1.GetSandboxProviderEnvironmentRequest - (*StaticCredentialEndpointBinding)(nil), // 133: openshell.v1.StaticCredentialEndpointBinding - (*StaticCredentialBinding)(nil), // 134: openshell.v1.StaticCredentialBinding - (*GetSandboxProviderEnvironmentResponse)(nil), // 135: openshell.v1.GetSandboxProviderEnvironmentResponse - (*ExchangeProviderSubjectTokenRequest)(nil), // 136: openshell.v1.ExchangeProviderSubjectTokenRequest - (*ExchangeProviderSubjectTokenResponse)(nil), // 137: openshell.v1.ExchangeProviderSubjectTokenResponse - (*UpdateConfigRequest)(nil), // 138: openshell.v1.UpdateConfigRequest - (*PolicyMergeOperation)(nil), // 139: openshell.v1.PolicyMergeOperation - (*AddNetworkRule)(nil), // 140: openshell.v1.AddNetworkRule - (*RemoveNetworkEndpoint)(nil), // 141: openshell.v1.RemoveNetworkEndpoint - (*RemoveNetworkRule)(nil), // 142: openshell.v1.RemoveNetworkRule - (*AddDenyRules)(nil), // 143: openshell.v1.AddDenyRules - (*AddAllowRules)(nil), // 144: openshell.v1.AddAllowRules - (*RemoveNetworkBinary)(nil), // 145: openshell.v1.RemoveNetworkBinary - (*UpdateConfigResponse)(nil), // 146: openshell.v1.UpdateConfigResponse - (*GetSandboxPolicyStatusRequest)(nil), // 147: openshell.v1.GetSandboxPolicyStatusRequest - (*GetSandboxPolicyStatusResponse)(nil), // 148: openshell.v1.GetSandboxPolicyStatusResponse - (*ListSandboxPoliciesRequest)(nil), // 149: openshell.v1.ListSandboxPoliciesRequest - (*ListSandboxPoliciesResponse)(nil), // 150: openshell.v1.ListSandboxPoliciesResponse - (*ReportPolicyStatusRequest)(nil), // 151: openshell.v1.ReportPolicyStatusRequest - (*ReportPolicyStatusResponse)(nil), // 152: openshell.v1.ReportPolicyStatusResponse - (*SandboxPolicyRevision)(nil), // 153: openshell.v1.SandboxPolicyRevision - (*GetSandboxLogsRequest)(nil), // 154: openshell.v1.GetSandboxLogsRequest - (*PushSandboxLogsRequest)(nil), // 155: openshell.v1.PushSandboxLogsRequest - (*PushSandboxLogsResponse)(nil), // 156: openshell.v1.PushSandboxLogsResponse - (*GetSandboxLogsResponse)(nil), // 157: openshell.v1.GetSandboxLogsResponse - (*SupervisorMessage)(nil), // 158: openshell.v1.SupervisorMessage - (*GatewayMessage)(nil), // 159: openshell.v1.GatewayMessage - (*SupervisorHello)(nil), // 160: openshell.v1.SupervisorHello - (*SessionAccepted)(nil), // 161: openshell.v1.SessionAccepted - (*SessionRejected)(nil), // 162: openshell.v1.SessionRejected - (*SupervisorHeartbeat)(nil), // 163: openshell.v1.SupervisorHeartbeat - (*GatewayHeartbeat)(nil), // 164: openshell.v1.GatewayHeartbeat - (*ReportMainProcessExitRequest)(nil), // 165: openshell.v1.ReportMainProcessExitRequest - (*ReportMainProcessExitResponse)(nil), // 166: openshell.v1.ReportMainProcessExitResponse - (*FinalizeMainProcessExitRequest)(nil), // 167: openshell.v1.FinalizeMainProcessExitRequest - (*FinalizeMainProcessExitResponse)(nil), // 168: openshell.v1.FinalizeMainProcessExitResponse - (*RelayOpen)(nil), // 169: openshell.v1.RelayOpen - (*SshRelayTarget)(nil), // 170: openshell.v1.SshRelayTarget - (*TcpRelayTarget)(nil), // 171: openshell.v1.TcpRelayTarget - (*RelayInit)(nil), // 172: openshell.v1.RelayInit - (*RelayFrame)(nil), // 173: openshell.v1.RelayFrame - (*RelayOpenResult)(nil), // 174: openshell.v1.RelayOpenResult - (*RelayClose)(nil), // 175: openshell.v1.RelayClose - (*L7RequestSample)(nil), // 176: openshell.v1.L7RequestSample - (*DenialSummary)(nil), // 177: openshell.v1.DenialSummary - (*DenialGroupCount)(nil), // 178: openshell.v1.DenialGroupCount - (*NetworkActivitySummary)(nil), // 179: openshell.v1.NetworkActivitySummary - (*PolicyChunk)(nil), // 180: openshell.v1.PolicyChunk - (*DraftPolicyUpdate)(nil), // 181: openshell.v1.DraftPolicyUpdate - (*SubmitPolicyAnalysisRequest)(nil), // 182: openshell.v1.SubmitPolicyAnalysisRequest - (*SubmitPolicyAnalysisResponse)(nil), // 183: openshell.v1.SubmitPolicyAnalysisResponse - (*GetDraftPolicyRequest)(nil), // 184: openshell.v1.GetDraftPolicyRequest - (*GetDraftPolicyResponse)(nil), // 185: openshell.v1.GetDraftPolicyResponse - (*ApproveDraftChunkRequest)(nil), // 186: openshell.v1.ApproveDraftChunkRequest - (*ApproveDraftChunkResponse)(nil), // 187: openshell.v1.ApproveDraftChunkResponse - (*RejectDraftChunkRequest)(nil), // 188: openshell.v1.RejectDraftChunkRequest - (*RejectDraftChunkResponse)(nil), // 189: openshell.v1.RejectDraftChunkResponse - (*DraftChunkApproval)(nil), // 190: openshell.v1.DraftChunkApproval - (*ApproveAllDraftChunksRequest)(nil), // 191: openshell.v1.ApproveAllDraftChunksRequest - (*ApproveAllDraftChunksResponse)(nil), // 192: openshell.v1.ApproveAllDraftChunksResponse - (*EditDraftChunkRequest)(nil), // 193: openshell.v1.EditDraftChunkRequest - (*EditDraftChunkResponse)(nil), // 194: openshell.v1.EditDraftChunkResponse - (*UndoDraftChunkRequest)(nil), // 195: openshell.v1.UndoDraftChunkRequest - (*UndoDraftChunkResponse)(nil), // 196: openshell.v1.UndoDraftChunkResponse - (*ClearDraftChunksRequest)(nil), // 197: openshell.v1.ClearDraftChunksRequest - (*ClearDraftChunksResponse)(nil), // 198: openshell.v1.ClearDraftChunksResponse - (*GetDraftHistoryRequest)(nil), // 199: openshell.v1.GetDraftHistoryRequest - (*DraftHistoryEntry)(nil), // 200: openshell.v1.DraftHistoryEntry - (*GetDraftHistoryResponse)(nil), // 201: openshell.v1.GetDraftHistoryResponse - (*PolicyRevisionPayload)(nil), // 202: openshell.v1.PolicyRevisionPayload - (*DraftChunkPayload)(nil), // 203: openshell.v1.DraftChunkPayload - (*StoredPolicyRevision)(nil), // 204: openshell.v1.StoredPolicyRevision - (*StoredDraftChunk)(nil), // 205: openshell.v1.StoredDraftChunk - (*CreateWorkspaceRequest)(nil), // 206: openshell.v1.CreateWorkspaceRequest - (*CreateWorkspaceResponse)(nil), // 207: openshell.v1.CreateWorkspaceResponse - (*GetWorkspaceRequest)(nil), // 208: openshell.v1.GetWorkspaceRequest - (*GetWorkspaceResponse)(nil), // 209: openshell.v1.GetWorkspaceResponse - (*ListWorkspacesRequest)(nil), // 210: openshell.v1.ListWorkspacesRequest - (*ListWorkspacesResponse)(nil), // 211: openshell.v1.ListWorkspacesResponse - (*DeleteWorkspaceRequest)(nil), // 212: openshell.v1.DeleteWorkspaceRequest - (*DeleteWorkspaceResponse)(nil), // 213: openshell.v1.DeleteWorkspaceResponse - (*WorkspaceMember)(nil), // 214: openshell.v1.WorkspaceMember - (*AddWorkspaceMemberRequest)(nil), // 215: openshell.v1.AddWorkspaceMemberRequest - (*AddWorkspaceMemberResponse)(nil), // 216: openshell.v1.AddWorkspaceMemberResponse - (*RemoveWorkspaceMemberRequest)(nil), // 217: openshell.v1.RemoveWorkspaceMemberRequest - (*RemoveWorkspaceMemberResponse)(nil), // 218: openshell.v1.RemoveWorkspaceMemberResponse - (*ListWorkspaceMembersRequest)(nil), // 219: openshell.v1.ListWorkspaceMembersRequest - (*ListWorkspaceMembersResponse)(nil), // 220: openshell.v1.ListWorkspaceMembersResponse - (*ExtensionServiceCredential)(nil), // 221: openshell.v1.ExtensionServiceCredential - nil, // 222: openshell.v1.SandboxSpec.EnvironmentEntry - nil, // 223: openshell.v1.SandboxTemplate.LabelsEntry - nil, // 224: openshell.v1.SandboxTemplate.AnnotationsEntry - nil, // 225: openshell.v1.SandboxTemplate.EnvironmentEntry - nil, // 226: openshell.v1.SandboxWorkloadConfig.EnvironmentEntry - nil, // 227: openshell.v1.PlatformEvent.MetadataEntry - nil, // 228: openshell.v1.CreateSandboxRequest.LabelsEntry - nil, // 229: openshell.v1.CreateSandboxRequest.AnnotationsEntry - nil, // 230: openshell.v1.ExecSandboxRequest.EnvironmentEntry - nil, // 231: openshell.v1.SandboxLogLine.FieldsEntry - nil, // 232: openshell.v1.UpdateProviderRequest.CredentialExpiresAtMsEntry - nil, // 233: openshell.v1.StoredProviderCredentialRefreshState.MaterialEntry - nil, // 234: openshell.v1.StoredProviderCredentialRefreshState.AdditionalOutputKeysEntry - nil, // 235: openshell.v1.StoredProviderCredentialRefreshState.SecretMaterialHandlesEntry - nil, // 236: openshell.v1.ConfigureProviderRefreshRequest.MaterialEntry - nil, // 237: openshell.v1.ProviderProfile.AnnotationsEntry - nil, // 238: openshell.v1.GetSandboxProviderEnvironmentResponse.EnvironmentEntry - nil, // 239: openshell.v1.GetSandboxProviderEnvironmentResponse.CredentialExpiresAtMsEntry - nil, // 240: openshell.v1.GetSandboxProviderEnvironmentResponse.DynamicCredentialsEntry - nil, // 241: openshell.v1.GetSandboxProviderEnvironmentResponse.StaticCredentialBindingsEntry - nil, // 242: openshell.v1.UpdateConfigRequest.AnnotationsEntry - nil, // 243: openshell.v1.UpdateConfigResponse.AnnotationsEntry - nil, // 244: openshell.v1.SandboxPolicyRevision.ProvenanceEntry - nil, // 245: openshell.v1.PolicyRevisionPayload.ProvenanceEntry - nil, // 246: openshell.v1.StoredPolicyRevision.ProvenanceEntry - nil, // 247: openshell.v1.CreateWorkspaceRequest.LabelsEntry - (*datamodelv1.ObjectMeta)(nil), // 248: openshell.datamodel.v1.ObjectMeta - (*sandboxv1.SandboxPolicy)(nil), // 249: openshell.sandbox.v1.SandboxPolicy - (*structpb.Struct)(nil), // 250: google.protobuf.Struct - (*durationpb.Duration)(nil), // 251: google.protobuf.Duration - (*datamodelv1.Provider)(nil), // 252: openshell.datamodel.v1.Provider - (*datamodelv1.CredentialHandle)(nil), // 253: openshell.datamodel.v1.CredentialHandle - (*sandboxv1.NetworkEndpoint)(nil), // 254: openshell.sandbox.v1.NetworkEndpoint - (*sandboxv1.NetworkBinary)(nil), // 255: openshell.sandbox.v1.NetworkBinary - (*sandboxv1.SettingValue)(nil), // 256: openshell.sandbox.v1.SettingValue - (*sandboxv1.NetworkPolicyRule)(nil), // 257: openshell.sandbox.v1.NetworkPolicyRule - (*sandboxv1.L7DenyRule)(nil), // 258: openshell.sandbox.v1.L7DenyRule - (*sandboxv1.L7Rule)(nil), // 259: openshell.sandbox.v1.L7Rule - (*datamodelv1.Workspace)(nil), // 260: openshell.datamodel.v1.Workspace - (*sandboxv1.GetSandboxConfigRequest)(nil), // 261: openshell.sandbox.v1.GetSandboxConfigRequest - (*sandboxv1.GetGatewayConfigRequest)(nil), // 262: openshell.sandbox.v1.GetGatewayConfigRequest - (*sandboxv1.GetSandboxConfigResponse)(nil), // 263: openshell.sandbox.v1.GetSandboxConfigResponse - (*sandboxv1.GetGatewayConfigResponse)(nil), // 264: openshell.sandbox.v1.GetGatewayConfigResponse + (*CpuResourceRequirements)(nil), // 28: openshell.v1.CpuResourceRequirements + (*MemoryResourceRequirements)(nil), // 29: openshell.v1.MemoryResourceRequirements + (*SandboxTemplate)(nil), // 30: openshell.v1.SandboxTemplate + (*SandboxWorkloadTemplate)(nil), // 31: openshell.v1.SandboxWorkloadTemplate + (*SandboxWorkloadTemplateSpec)(nil), // 32: openshell.v1.SandboxWorkloadTemplateSpec + (*SandboxWorkloadConfig)(nil), // 33: openshell.v1.SandboxWorkloadConfig + (*SandboxServiceLevel)(nil), // 34: openshell.v1.SandboxServiceLevel + (*SandboxStartup)(nil), // 35: openshell.v1.SandboxStartup + (*SandboxWorkloadTemplateProvenance)(nil), // 36: openshell.v1.SandboxWorkloadTemplateProvenance + (*SandboxStatus)(nil), // 37: openshell.v1.SandboxStatus + (*SandboxCondition)(nil), // 38: openshell.v1.SandboxCondition + (*PlatformEvent)(nil), // 39: openshell.v1.PlatformEvent + (*CreateSandboxRequest)(nil), // 40: openshell.v1.CreateSandboxRequest + (*CreateSandboxTemplateRequest)(nil), // 41: openshell.v1.CreateSandboxTemplateRequest + (*GetSandboxTemplateRequest)(nil), // 42: openshell.v1.GetSandboxTemplateRequest + (*ListSandboxTemplatesRequest)(nil), // 43: openshell.v1.ListSandboxTemplatesRequest + (*DeleteSandboxTemplateRequest)(nil), // 44: openshell.v1.DeleteSandboxTemplateRequest + (*SandboxTemplateResponse)(nil), // 45: openshell.v1.SandboxTemplateResponse + (*ListSandboxTemplatesResponse)(nil), // 46: openshell.v1.ListSandboxTemplatesResponse + (*DeleteSandboxTemplateResponse)(nil), // 47: openshell.v1.DeleteSandboxTemplateResponse + (*BeginRootfsTarStagingRequest)(nil), // 48: openshell.v1.BeginRootfsTarStagingRequest + (*BeginRootfsTarStagingResponse)(nil), // 49: openshell.v1.BeginRootfsTarStagingResponse + (*GetSandboxRequest)(nil), // 50: openshell.v1.GetSandboxRequest + (*ListSandboxesRequest)(nil), // 51: openshell.v1.ListSandboxesRequest + (*ListSandboxProvidersRequest)(nil), // 52: openshell.v1.ListSandboxProvidersRequest + (*AttachSandboxProviderRequest)(nil), // 53: openshell.v1.AttachSandboxProviderRequest + (*DetachSandboxProviderRequest)(nil), // 54: openshell.v1.DetachSandboxProviderRequest + (*DeleteSandboxRequest)(nil), // 55: openshell.v1.DeleteSandboxRequest + (*StopSandboxRequest)(nil), // 56: openshell.v1.StopSandboxRequest + (*StartSandboxRequest)(nil), // 57: openshell.v1.StartSandboxRequest + (*SandboxResponse)(nil), // 58: openshell.v1.SandboxResponse + (*ListSandboxesResponse)(nil), // 59: openshell.v1.ListSandboxesResponse + (*ListSandboxProvidersResponse)(nil), // 60: openshell.v1.ListSandboxProvidersResponse + (*AttachSandboxProviderResponse)(nil), // 61: openshell.v1.AttachSandboxProviderResponse + (*DetachSandboxProviderResponse)(nil), // 62: openshell.v1.DetachSandboxProviderResponse + (*DeleteSandboxResponse)(nil), // 63: openshell.v1.DeleteSandboxResponse + (*CreateSshSessionRequest)(nil), // 64: openshell.v1.CreateSshSessionRequest + (*CreateSshSessionResponse)(nil), // 65: openshell.v1.CreateSshSessionResponse + (*ExposeServiceRequest)(nil), // 66: openshell.v1.ExposeServiceRequest + (*GetServiceRequest)(nil), // 67: openshell.v1.GetServiceRequest + (*ListServicesRequest)(nil), // 68: openshell.v1.ListServicesRequest + (*ListServicesResponse)(nil), // 69: openshell.v1.ListServicesResponse + (*DeleteServiceRequest)(nil), // 70: openshell.v1.DeleteServiceRequest + (*DeleteServiceResponse)(nil), // 71: openshell.v1.DeleteServiceResponse + (*ServiceEndpoint)(nil), // 72: openshell.v1.ServiceEndpoint + (*ServiceEndpointResponse)(nil), // 73: openshell.v1.ServiceEndpointResponse + (*RevokeSshSessionRequest)(nil), // 74: openshell.v1.RevokeSshSessionRequest + (*RevokeSshSessionResponse)(nil), // 75: openshell.v1.RevokeSshSessionResponse + (*ExecSandboxRequest)(nil), // 76: openshell.v1.ExecSandboxRequest + (*ExecSandboxStdout)(nil), // 77: openshell.v1.ExecSandboxStdout + (*ExecSandboxStderr)(nil), // 78: openshell.v1.ExecSandboxStderr + (*ExecSandboxExit)(nil), // 79: openshell.v1.ExecSandboxExit + (*ExecSandboxEvent)(nil), // 80: openshell.v1.ExecSandboxEvent + (*TcpForwardInit)(nil), // 81: openshell.v1.TcpForwardInit + (*TcpForwardFrame)(nil), // 82: openshell.v1.TcpForwardFrame + (*ExecSandboxInput)(nil), // 83: openshell.v1.ExecSandboxInput + (*ExecSandboxWindowResize)(nil), // 84: openshell.v1.ExecSandboxWindowResize + (*SshSession)(nil), // 85: openshell.v1.SshSession + (*WatchSandboxRequest)(nil), // 86: openshell.v1.WatchSandboxRequest + (*SandboxStreamEvent)(nil), // 87: openshell.v1.SandboxStreamEvent + (*SandboxLogLine)(nil), // 88: openshell.v1.SandboxLogLine + (*SandboxStreamWarning)(nil), // 89: openshell.v1.SandboxStreamWarning + (*CreateProviderRequest)(nil), // 90: openshell.v1.CreateProviderRequest + (*GetProviderRequest)(nil), // 91: openshell.v1.GetProviderRequest + (*ListProvidersRequest)(nil), // 92: openshell.v1.ListProvidersRequest + (*UpdateProviderRequest)(nil), // 93: openshell.v1.UpdateProviderRequest + (*DeleteProviderRequest)(nil), // 94: openshell.v1.DeleteProviderRequest + (*ProviderResponse)(nil), // 95: openshell.v1.ProviderResponse + (*ListProvidersResponse)(nil), // 96: openshell.v1.ListProvidersResponse + (*ListProviderProfilesRequest)(nil), // 97: openshell.v1.ListProviderProfilesRequest + (*GetProviderProfileRequest)(nil), // 98: openshell.v1.GetProviderProfileRequest + (*ProviderProfileImportItem)(nil), // 99: openshell.v1.ProviderProfileImportItem + (*ProviderProfileDiagnostic)(nil), // 100: openshell.v1.ProviderProfileDiagnostic + (*ProviderCredentialTokenGrantAudienceOverride)(nil), // 101: openshell.v1.ProviderCredentialTokenGrantAudienceOverride + (*ProviderCredentialTokenGrantSubjectToken)(nil), // 102: openshell.v1.ProviderCredentialTokenGrantSubjectToken + (*ProviderCredentialTokenGrant)(nil), // 103: openshell.v1.ProviderCredentialTokenGrant + (*ProviderProfileCredential)(nil), // 104: openshell.v1.ProviderProfileCredential + (*ProviderCredentialRefreshMaterial)(nil), // 105: openshell.v1.ProviderCredentialRefreshMaterial + (*ProviderCredentialRefreshOutput)(nil), // 106: openshell.v1.ProviderCredentialRefreshOutput + (*ProviderCredentialRefresh)(nil), // 107: openshell.v1.ProviderCredentialRefresh + (*ProviderCredentialRefreshStatus)(nil), // 108: openshell.v1.ProviderCredentialRefreshStatus + (*ProviderProfileDiscovery)(nil), // 109: openshell.v1.ProviderProfileDiscovery + (*StoredProviderCredentialRefreshState)(nil), // 110: openshell.v1.StoredProviderCredentialRefreshState + (*StoredRefreshMaterialDeletion)(nil), // 111: openshell.v1.StoredRefreshMaterialDeletion + (*GetProviderRefreshStatusRequest)(nil), // 112: openshell.v1.GetProviderRefreshStatusRequest + (*GetProviderRefreshStatusResponse)(nil), // 113: openshell.v1.GetProviderRefreshStatusResponse + (*ConfigureProviderRefreshRequest)(nil), // 114: openshell.v1.ConfigureProviderRefreshRequest + (*ConfigureProviderRefreshResponse)(nil), // 115: openshell.v1.ConfigureProviderRefreshResponse + (*RotateProviderCredentialRequest)(nil), // 116: openshell.v1.RotateProviderCredentialRequest + (*RotateProviderCredentialResponse)(nil), // 117: openshell.v1.RotateProviderCredentialResponse + (*DeleteProviderRefreshRequest)(nil), // 118: openshell.v1.DeleteProviderRefreshRequest + (*DeleteProviderRefreshResponse)(nil), // 119: openshell.v1.DeleteProviderRefreshResponse + (*ProviderProfile)(nil), // 120: openshell.v1.ProviderProfile + (*StoredProviderProfile)(nil), // 121: openshell.v1.StoredProviderProfile + (*ProviderProfileResponse)(nil), // 122: openshell.v1.ProviderProfileResponse + (*ListProviderProfilesResponse)(nil), // 123: openshell.v1.ListProviderProfilesResponse + (*ImportProviderProfilesRequest)(nil), // 124: openshell.v1.ImportProviderProfilesRequest + (*ImportProviderProfilesResponse)(nil), // 125: openshell.v1.ImportProviderProfilesResponse + (*UpdateProviderProfilesRequest)(nil), // 126: openshell.v1.UpdateProviderProfilesRequest + (*UpdateProviderProfilesResponse)(nil), // 127: openshell.v1.UpdateProviderProfilesResponse + (*LintProviderProfilesRequest)(nil), // 128: openshell.v1.LintProviderProfilesRequest + (*LintProviderProfilesResponse)(nil), // 129: openshell.v1.LintProviderProfilesResponse + (*DeleteProviderResponse)(nil), // 130: openshell.v1.DeleteProviderResponse + (*DeleteProviderProfileRequest)(nil), // 131: openshell.v1.DeleteProviderProfileRequest + (*DeleteProviderProfileResponse)(nil), // 132: openshell.v1.DeleteProviderProfileResponse + (*GetSandboxProviderEnvironmentRequest)(nil), // 133: openshell.v1.GetSandboxProviderEnvironmentRequest + (*StaticCredentialEndpointBinding)(nil), // 134: openshell.v1.StaticCredentialEndpointBinding + (*StaticCredentialBinding)(nil), // 135: openshell.v1.StaticCredentialBinding + (*GetSandboxProviderEnvironmentResponse)(nil), // 136: openshell.v1.GetSandboxProviderEnvironmentResponse + (*ExchangeProviderSubjectTokenRequest)(nil), // 137: openshell.v1.ExchangeProviderSubjectTokenRequest + (*ExchangeProviderSubjectTokenResponse)(nil), // 138: openshell.v1.ExchangeProviderSubjectTokenResponse + (*UpdateConfigRequest)(nil), // 139: openshell.v1.UpdateConfigRequest + (*PolicyMergeOperation)(nil), // 140: openshell.v1.PolicyMergeOperation + (*AddNetworkRule)(nil), // 141: openshell.v1.AddNetworkRule + (*RemoveNetworkEndpoint)(nil), // 142: openshell.v1.RemoveNetworkEndpoint + (*RemoveNetworkRule)(nil), // 143: openshell.v1.RemoveNetworkRule + (*AddDenyRules)(nil), // 144: openshell.v1.AddDenyRules + (*AddAllowRules)(nil), // 145: openshell.v1.AddAllowRules + (*RemoveNetworkBinary)(nil), // 146: openshell.v1.RemoveNetworkBinary + (*UpdateConfigResponse)(nil), // 147: openshell.v1.UpdateConfigResponse + (*GetSandboxPolicyStatusRequest)(nil), // 148: openshell.v1.GetSandboxPolicyStatusRequest + (*GetSandboxPolicyStatusResponse)(nil), // 149: openshell.v1.GetSandboxPolicyStatusResponse + (*ListSandboxPoliciesRequest)(nil), // 150: openshell.v1.ListSandboxPoliciesRequest + (*ListSandboxPoliciesResponse)(nil), // 151: openshell.v1.ListSandboxPoliciesResponse + (*ReportPolicyStatusRequest)(nil), // 152: openshell.v1.ReportPolicyStatusRequest + (*ReportPolicyStatusResponse)(nil), // 153: openshell.v1.ReportPolicyStatusResponse + (*SandboxPolicyRevision)(nil), // 154: openshell.v1.SandboxPolicyRevision + (*GetSandboxLogsRequest)(nil), // 155: openshell.v1.GetSandboxLogsRequest + (*PushSandboxLogsRequest)(nil), // 156: openshell.v1.PushSandboxLogsRequest + (*PushSandboxLogsResponse)(nil), // 157: openshell.v1.PushSandboxLogsResponse + (*GetSandboxLogsResponse)(nil), // 158: openshell.v1.GetSandboxLogsResponse + (*SupervisorMessage)(nil), // 159: openshell.v1.SupervisorMessage + (*GatewayMessage)(nil), // 160: openshell.v1.GatewayMessage + (*SupervisorHello)(nil), // 161: openshell.v1.SupervisorHello + (*SessionAccepted)(nil), // 162: openshell.v1.SessionAccepted + (*SessionRejected)(nil), // 163: openshell.v1.SessionRejected + (*SupervisorHeartbeat)(nil), // 164: openshell.v1.SupervisorHeartbeat + (*GatewayHeartbeat)(nil), // 165: openshell.v1.GatewayHeartbeat + (*ReportMainProcessExitRequest)(nil), // 166: openshell.v1.ReportMainProcessExitRequest + (*ReportMainProcessExitResponse)(nil), // 167: openshell.v1.ReportMainProcessExitResponse + (*FinalizeMainProcessExitRequest)(nil), // 168: openshell.v1.FinalizeMainProcessExitRequest + (*FinalizeMainProcessExitResponse)(nil), // 169: openshell.v1.FinalizeMainProcessExitResponse + (*RelayOpen)(nil), // 170: openshell.v1.RelayOpen + (*SshRelayTarget)(nil), // 171: openshell.v1.SshRelayTarget + (*TcpRelayTarget)(nil), // 172: openshell.v1.TcpRelayTarget + (*RelayInit)(nil), // 173: openshell.v1.RelayInit + (*RelayFrame)(nil), // 174: openshell.v1.RelayFrame + (*RelayOpenResult)(nil), // 175: openshell.v1.RelayOpenResult + (*RelayClose)(nil), // 176: openshell.v1.RelayClose + (*L7RequestSample)(nil), // 177: openshell.v1.L7RequestSample + (*DenialSummary)(nil), // 178: openshell.v1.DenialSummary + (*DenialGroupCount)(nil), // 179: openshell.v1.DenialGroupCount + (*NetworkActivitySummary)(nil), // 180: openshell.v1.NetworkActivitySummary + (*PolicyChunk)(nil), // 181: openshell.v1.PolicyChunk + (*DraftPolicyUpdate)(nil), // 182: openshell.v1.DraftPolicyUpdate + (*SubmitPolicyAnalysisRequest)(nil), // 183: openshell.v1.SubmitPolicyAnalysisRequest + (*SubmitPolicyAnalysisResponse)(nil), // 184: openshell.v1.SubmitPolicyAnalysisResponse + (*GetDraftPolicyRequest)(nil), // 185: openshell.v1.GetDraftPolicyRequest + (*GetDraftPolicyResponse)(nil), // 186: openshell.v1.GetDraftPolicyResponse + (*ApproveDraftChunkRequest)(nil), // 187: openshell.v1.ApproveDraftChunkRequest + (*ApproveDraftChunkResponse)(nil), // 188: openshell.v1.ApproveDraftChunkResponse + (*RejectDraftChunkRequest)(nil), // 189: openshell.v1.RejectDraftChunkRequest + (*RejectDraftChunkResponse)(nil), // 190: openshell.v1.RejectDraftChunkResponse + (*DraftChunkApproval)(nil), // 191: openshell.v1.DraftChunkApproval + (*ApproveAllDraftChunksRequest)(nil), // 192: openshell.v1.ApproveAllDraftChunksRequest + (*ApproveAllDraftChunksResponse)(nil), // 193: openshell.v1.ApproveAllDraftChunksResponse + (*EditDraftChunkRequest)(nil), // 194: openshell.v1.EditDraftChunkRequest + (*EditDraftChunkResponse)(nil), // 195: openshell.v1.EditDraftChunkResponse + (*UndoDraftChunkRequest)(nil), // 196: openshell.v1.UndoDraftChunkRequest + (*UndoDraftChunkResponse)(nil), // 197: openshell.v1.UndoDraftChunkResponse + (*ClearDraftChunksRequest)(nil), // 198: openshell.v1.ClearDraftChunksRequest + (*ClearDraftChunksResponse)(nil), // 199: openshell.v1.ClearDraftChunksResponse + (*GetDraftHistoryRequest)(nil), // 200: openshell.v1.GetDraftHistoryRequest + (*DraftHistoryEntry)(nil), // 201: openshell.v1.DraftHistoryEntry + (*GetDraftHistoryResponse)(nil), // 202: openshell.v1.GetDraftHistoryResponse + (*PolicyRevisionPayload)(nil), // 203: openshell.v1.PolicyRevisionPayload + (*DraftChunkPayload)(nil), // 204: openshell.v1.DraftChunkPayload + (*StoredPolicyRevision)(nil), // 205: openshell.v1.StoredPolicyRevision + (*StoredDraftChunk)(nil), // 206: openshell.v1.StoredDraftChunk + (*CreateWorkspaceRequest)(nil), // 207: openshell.v1.CreateWorkspaceRequest + (*CreateWorkspaceResponse)(nil), // 208: openshell.v1.CreateWorkspaceResponse + (*GetWorkspaceRequest)(nil), // 209: openshell.v1.GetWorkspaceRequest + (*GetWorkspaceResponse)(nil), // 210: openshell.v1.GetWorkspaceResponse + (*ListWorkspacesRequest)(nil), // 211: openshell.v1.ListWorkspacesRequest + (*ListWorkspacesResponse)(nil), // 212: openshell.v1.ListWorkspacesResponse + (*DeleteWorkspaceRequest)(nil), // 213: openshell.v1.DeleteWorkspaceRequest + (*DeleteWorkspaceResponse)(nil), // 214: openshell.v1.DeleteWorkspaceResponse + (*WorkspaceMember)(nil), // 215: openshell.v1.WorkspaceMember + (*AddWorkspaceMemberRequest)(nil), // 216: openshell.v1.AddWorkspaceMemberRequest + (*AddWorkspaceMemberResponse)(nil), // 217: openshell.v1.AddWorkspaceMemberResponse + (*RemoveWorkspaceMemberRequest)(nil), // 218: openshell.v1.RemoveWorkspaceMemberRequest + (*RemoveWorkspaceMemberResponse)(nil), // 219: openshell.v1.RemoveWorkspaceMemberResponse + (*ListWorkspaceMembersRequest)(nil), // 220: openshell.v1.ListWorkspaceMembersRequest + (*ListWorkspaceMembersResponse)(nil), // 221: openshell.v1.ListWorkspaceMembersResponse + (*ExtensionServiceCredential)(nil), // 222: openshell.v1.ExtensionServiceCredential + nil, // 223: openshell.v1.SandboxSpec.EnvironmentEntry + nil, // 224: openshell.v1.SandboxTemplate.LabelsEntry + nil, // 225: openshell.v1.SandboxTemplate.AnnotationsEntry + nil, // 226: openshell.v1.SandboxTemplate.EnvironmentEntry + nil, // 227: openshell.v1.SandboxWorkloadConfig.EnvironmentEntry + nil, // 228: openshell.v1.PlatformEvent.MetadataEntry + nil, // 229: openshell.v1.CreateSandboxRequest.LabelsEntry + nil, // 230: openshell.v1.CreateSandboxRequest.AnnotationsEntry + nil, // 231: openshell.v1.ExecSandboxRequest.EnvironmentEntry + nil, // 232: openshell.v1.SandboxLogLine.FieldsEntry + nil, // 233: openshell.v1.UpdateProviderRequest.CredentialExpiresAtMsEntry + nil, // 234: openshell.v1.StoredProviderCredentialRefreshState.MaterialEntry + nil, // 235: openshell.v1.StoredProviderCredentialRefreshState.AdditionalOutputKeysEntry + nil, // 236: openshell.v1.StoredProviderCredentialRefreshState.SecretMaterialHandlesEntry + nil, // 237: openshell.v1.ConfigureProviderRefreshRequest.MaterialEntry + nil, // 238: openshell.v1.ProviderProfile.AnnotationsEntry + nil, // 239: openshell.v1.GetSandboxProviderEnvironmentResponse.EnvironmentEntry + nil, // 240: openshell.v1.GetSandboxProviderEnvironmentResponse.CredentialExpiresAtMsEntry + nil, // 241: openshell.v1.GetSandboxProviderEnvironmentResponse.DynamicCredentialsEntry + nil, // 242: openshell.v1.GetSandboxProviderEnvironmentResponse.StaticCredentialBindingsEntry + nil, // 243: openshell.v1.UpdateConfigRequest.AnnotationsEntry + nil, // 244: openshell.v1.UpdateConfigResponse.AnnotationsEntry + nil, // 245: openshell.v1.SandboxPolicyRevision.ProvenanceEntry + nil, // 246: openshell.v1.PolicyRevisionPayload.ProvenanceEntry + nil, // 247: openshell.v1.StoredPolicyRevision.ProvenanceEntry + nil, // 248: openshell.v1.CreateWorkspaceRequest.LabelsEntry + (*datamodelv1.ObjectMeta)(nil), // 249: openshell.datamodel.v1.ObjectMeta + (*sandboxv1.SandboxPolicy)(nil), // 250: openshell.sandbox.v1.SandboxPolicy + (*structpb.Struct)(nil), // 251: google.protobuf.Struct + (*durationpb.Duration)(nil), // 252: google.protobuf.Duration + (*datamodelv1.Provider)(nil), // 253: openshell.datamodel.v1.Provider + (*datamodelv1.CredentialHandle)(nil), // 254: openshell.datamodel.v1.CredentialHandle + (*sandboxv1.NetworkEndpoint)(nil), // 255: openshell.sandbox.v1.NetworkEndpoint + (*sandboxv1.NetworkBinary)(nil), // 256: openshell.sandbox.v1.NetworkBinary + (*sandboxv1.SettingValue)(nil), // 257: openshell.sandbox.v1.SettingValue + (*sandboxv1.NetworkPolicyRule)(nil), // 258: openshell.sandbox.v1.NetworkPolicyRule + (*sandboxv1.L7DenyRule)(nil), // 259: openshell.sandbox.v1.L7DenyRule + (*sandboxv1.L7Rule)(nil), // 260: openshell.sandbox.v1.L7Rule + (*datamodelv1.Workspace)(nil), // 261: openshell.datamodel.v1.Workspace + (*sandboxv1.GetSandboxConfigRequest)(nil), // 262: openshell.sandbox.v1.GetSandboxConfigRequest + (*sandboxv1.GetGatewayConfigRequest)(nil), // 263: openshell.sandbox.v1.GetGatewayConfigRequest + (*sandboxv1.GetSandboxConfigResponse)(nil), // 264: openshell.sandbox.v1.GetSandboxConfigResponse + (*sandboxv1.GetGatewayConfigResponse)(nil), // 265: openshell.sandbox.v1.GetGatewayConfigResponse } var file_openshell_proto_depIdxs = []int32{ - 221, // 0: openshell.v1.RefreshSandboxTokenResponse.extension_credentials:type_name -> openshell.v1.ExtensionServiceCredential + 222, // 0: openshell.v1.RefreshSandboxTokenResponse.extension_credentials:type_name -> openshell.v1.ExtensionServiceCredential 5, // 1: openshell.v1.HealthResponse.status:type_name -> openshell.v1.ServiceStatus 5, // 2: openshell.v1.GetGatewayInfoResponse.status:type_name -> openshell.v1.ServiceStatus 18, // 3: openshell.v1.GetGatewayInfoResponse.compute_drivers:type_name -> openshell.v1.ComputeDriverInfo @@ -16887,334 +16936,335 @@ var file_openshell_proto_depIdxs = []int32{ 21, // 6: openshell.v1.ResourceCapabilities.cpu:type_name -> openshell.v1.CpuResourceCapabilities 22, // 7: openshell.v1.ResourceCapabilities.memory:type_name -> openshell.v1.MemoryResourceCapabilities 23, // 8: openshell.v1.ResourceCapabilities.gpu:type_name -> openshell.v1.GpuResourceCapabilities - 248, // 9: openshell.v1.Sandbox.metadata:type_name -> openshell.datamodel.v1.ObjectMeta + 249, // 9: openshell.v1.Sandbox.metadata:type_name -> openshell.datamodel.v1.ObjectMeta 25, // 10: openshell.v1.Sandbox.spec:type_name -> openshell.v1.SandboxSpec - 36, // 11: openshell.v1.Sandbox.status:type_name -> openshell.v1.SandboxStatus - 35, // 12: openshell.v1.Sandbox.created_from_workload_template:type_name -> openshell.v1.SandboxWorkloadTemplateProvenance - 222, // 13: openshell.v1.SandboxSpec.environment:type_name -> openshell.v1.SandboxSpec.EnvironmentEntry - 28, // 14: openshell.v1.SandboxSpec.template:type_name -> openshell.v1.SandboxTemplate - 249, // 15: openshell.v1.SandboxSpec.policy:type_name -> openshell.sandbox.v1.SandboxPolicy + 37, // 11: openshell.v1.Sandbox.status:type_name -> openshell.v1.SandboxStatus + 36, // 12: openshell.v1.Sandbox.created_from_workload_template:type_name -> openshell.v1.SandboxWorkloadTemplateProvenance + 223, // 13: openshell.v1.SandboxSpec.environment:type_name -> openshell.v1.SandboxSpec.EnvironmentEntry + 30, // 14: openshell.v1.SandboxSpec.template:type_name -> openshell.v1.SandboxTemplate + 250, // 15: openshell.v1.SandboxSpec.policy:type_name -> openshell.sandbox.v1.SandboxPolicy 26, // 16: openshell.v1.SandboxSpec.resource_requirements:type_name -> openshell.v1.ResourceRequirements 27, // 17: openshell.v1.ResourceRequirements.gpu:type_name -> openshell.v1.GpuResourceRequirements - 223, // 18: openshell.v1.SandboxTemplate.labels:type_name -> openshell.v1.SandboxTemplate.LabelsEntry - 224, // 19: openshell.v1.SandboxTemplate.annotations:type_name -> openshell.v1.SandboxTemplate.AnnotationsEntry - 225, // 20: openshell.v1.SandboxTemplate.environment:type_name -> openshell.v1.SandboxTemplate.EnvironmentEntry - 250, // 21: openshell.v1.SandboxTemplate.resources:type_name -> google.protobuf.Struct - 250, // 22: openshell.v1.SandboxTemplate.driver_config:type_name -> google.protobuf.Struct - 248, // 23: openshell.v1.SandboxWorkloadTemplate.metadata:type_name -> openshell.datamodel.v1.ObjectMeta - 30, // 24: openshell.v1.SandboxWorkloadTemplate.spec:type_name -> openshell.v1.SandboxWorkloadTemplateSpec - 31, // 25: openshell.v1.SandboxWorkloadTemplateSpec.workload:type_name -> openshell.v1.SandboxWorkloadConfig - 250, // 26: openshell.v1.SandboxWorkloadTemplateSpec.driver_config:type_name -> google.protobuf.Struct - 33, // 27: openshell.v1.SandboxWorkloadTemplateSpec.desired_service_level:type_name -> openshell.v1.SandboxServiceLevel - 226, // 28: openshell.v1.SandboxWorkloadConfig.environment:type_name -> openshell.v1.SandboxWorkloadConfig.EnvironmentEntry - 32, // 29: openshell.v1.SandboxWorkloadConfig.resources:type_name -> openshell.v1.SandboxResources - 27, // 30: openshell.v1.SandboxResources.gpu:type_name -> openshell.v1.GpuResourceRequirements - 34, // 31: openshell.v1.SandboxServiceLevel.startup:type_name -> openshell.v1.SandboxStartup - 251, // 32: openshell.v1.SandboxStartup.ready_within:type_name -> google.protobuf.Duration - 37, // 33: openshell.v1.SandboxStatus.conditions:type_name -> openshell.v1.SandboxCondition - 0, // 34: openshell.v1.SandboxStatus.phase:type_name -> openshell.v1.SandboxPhase - 227, // 35: openshell.v1.PlatformEvent.metadata:type_name -> openshell.v1.PlatformEvent.MetadataEntry - 25, // 36: openshell.v1.CreateSandboxRequest.spec:type_name -> openshell.v1.SandboxSpec - 228, // 37: openshell.v1.CreateSandboxRequest.labels:type_name -> openshell.v1.CreateSandboxRequest.LabelsEntry - 229, // 38: openshell.v1.CreateSandboxRequest.annotations:type_name -> openshell.v1.CreateSandboxRequest.AnnotationsEntry - 29, // 39: openshell.v1.CreateSandboxTemplateRequest.template:type_name -> openshell.v1.SandboxWorkloadTemplate - 29, // 40: openshell.v1.SandboxTemplateResponse.template:type_name -> openshell.v1.SandboxWorkloadTemplate - 29, // 41: openshell.v1.ListSandboxTemplatesResponse.templates:type_name -> openshell.v1.SandboxWorkloadTemplate - 24, // 42: openshell.v1.SandboxResponse.sandbox:type_name -> openshell.v1.Sandbox - 24, // 43: openshell.v1.ListSandboxesResponse.sandboxes:type_name -> openshell.v1.Sandbox - 252, // 44: openshell.v1.ListSandboxProvidersResponse.providers:type_name -> openshell.datamodel.v1.Provider - 24, // 45: openshell.v1.AttachSandboxProviderResponse.sandbox:type_name -> openshell.v1.Sandbox - 24, // 46: openshell.v1.DetachSandboxProviderResponse.sandbox:type_name -> openshell.v1.Sandbox - 72, // 47: openshell.v1.ListServicesResponse.services:type_name -> openshell.v1.ServiceEndpointResponse - 248, // 48: openshell.v1.ServiceEndpoint.metadata:type_name -> openshell.datamodel.v1.ObjectMeta - 71, // 49: openshell.v1.ServiceEndpointResponse.endpoint:type_name -> openshell.v1.ServiceEndpoint - 230, // 50: openshell.v1.ExecSandboxRequest.environment:type_name -> openshell.v1.ExecSandboxRequest.EnvironmentEntry - 76, // 51: openshell.v1.ExecSandboxEvent.stdout:type_name -> openshell.v1.ExecSandboxStdout - 77, // 52: openshell.v1.ExecSandboxEvent.stderr:type_name -> openshell.v1.ExecSandboxStderr - 78, // 53: openshell.v1.ExecSandboxEvent.exit:type_name -> openshell.v1.ExecSandboxExit - 170, // 54: openshell.v1.TcpForwardInit.ssh:type_name -> openshell.v1.SshRelayTarget - 171, // 55: openshell.v1.TcpForwardInit.tcp:type_name -> openshell.v1.TcpRelayTarget - 80, // 56: openshell.v1.TcpForwardFrame.init:type_name -> openshell.v1.TcpForwardInit - 75, // 57: openshell.v1.ExecSandboxInput.start:type_name -> openshell.v1.ExecSandboxRequest - 83, // 58: openshell.v1.ExecSandboxInput.resize:type_name -> openshell.v1.ExecSandboxWindowResize - 248, // 59: openshell.v1.SshSession.metadata:type_name -> openshell.datamodel.v1.ObjectMeta - 24, // 60: openshell.v1.SandboxStreamEvent.sandbox:type_name -> openshell.v1.Sandbox - 87, // 61: openshell.v1.SandboxStreamEvent.log:type_name -> openshell.v1.SandboxLogLine - 38, // 62: openshell.v1.SandboxStreamEvent.event:type_name -> openshell.v1.PlatformEvent - 88, // 63: openshell.v1.SandboxStreamEvent.warning:type_name -> openshell.v1.SandboxStreamWarning - 181, // 64: openshell.v1.SandboxStreamEvent.draft_policy_update:type_name -> openshell.v1.DraftPolicyUpdate - 231, // 65: openshell.v1.SandboxLogLine.fields:type_name -> openshell.v1.SandboxLogLine.FieldsEntry - 252, // 66: openshell.v1.CreateProviderRequest.provider:type_name -> openshell.datamodel.v1.Provider - 252, // 67: openshell.v1.UpdateProviderRequest.provider:type_name -> openshell.datamodel.v1.Provider - 232, // 68: openshell.v1.UpdateProviderRequest.credential_expires_at_ms:type_name -> openshell.v1.UpdateProviderRequest.CredentialExpiresAtMsEntry - 252, // 69: openshell.v1.ProviderResponse.provider:type_name -> openshell.datamodel.v1.Provider - 252, // 70: openshell.v1.ListProvidersResponse.providers:type_name -> openshell.datamodel.v1.Provider - 119, // 71: openshell.v1.ProviderProfileImportItem.profile:type_name -> openshell.v1.ProviderProfile - 100, // 72: openshell.v1.ProviderCredentialTokenGrant.audience_overrides:type_name -> openshell.v1.ProviderCredentialTokenGrantAudienceOverride - 1, // 73: openshell.v1.ProviderCredentialTokenGrant.grant_type:type_name -> openshell.v1.ProviderCredentialTokenGrantType - 101, // 74: openshell.v1.ProviderCredentialTokenGrant.subject_token:type_name -> openshell.v1.ProviderCredentialTokenGrantSubjectToken - 106, // 75: openshell.v1.ProviderProfileCredential.refresh:type_name -> openshell.v1.ProviderCredentialRefresh - 102, // 76: openshell.v1.ProviderProfileCredential.token_grant:type_name -> openshell.v1.ProviderCredentialTokenGrant - 2, // 77: openshell.v1.ProviderCredentialRefresh.strategy:type_name -> openshell.v1.ProviderCredentialRefreshStrategy - 104, // 78: openshell.v1.ProviderCredentialRefresh.material:type_name -> openshell.v1.ProviderCredentialRefreshMaterial - 105, // 79: openshell.v1.ProviderCredentialRefresh.additional_outputs:type_name -> openshell.v1.ProviderCredentialRefreshOutput - 2, // 80: openshell.v1.ProviderCredentialRefreshStatus.strategy:type_name -> openshell.v1.ProviderCredentialRefreshStrategy - 7, // 81: openshell.v1.ProviderCredentialRefreshStatus.recovery_action:type_name -> openshell.v1.ProviderCredentialRefreshRecoveryAction - 248, // 82: openshell.v1.StoredProviderCredentialRefreshState.metadata:type_name -> openshell.datamodel.v1.ObjectMeta - 2, // 83: openshell.v1.StoredProviderCredentialRefreshState.strategy:type_name -> openshell.v1.ProviderCredentialRefreshStrategy - 233, // 84: openshell.v1.StoredProviderCredentialRefreshState.material:type_name -> openshell.v1.StoredProviderCredentialRefreshState.MaterialEntry - 234, // 85: openshell.v1.StoredProviderCredentialRefreshState.additional_output_keys:type_name -> openshell.v1.StoredProviderCredentialRefreshState.AdditionalOutputKeysEntry - 235, // 86: openshell.v1.StoredProviderCredentialRefreshState.secret_material_handles:type_name -> openshell.v1.StoredProviderCredentialRefreshState.SecretMaterialHandlesEntry - 110, // 87: openshell.v1.StoredProviderCredentialRefreshState.pending_secret_deletions:type_name -> openshell.v1.StoredRefreshMaterialDeletion - 7, // 88: openshell.v1.StoredProviderCredentialRefreshState.recovery_action:type_name -> openshell.v1.ProviderCredentialRefreshRecoveryAction - 253, // 89: openshell.v1.StoredRefreshMaterialDeletion.handle:type_name -> openshell.datamodel.v1.CredentialHandle - 107, // 90: openshell.v1.GetProviderRefreshStatusResponse.credentials:type_name -> openshell.v1.ProviderCredentialRefreshStatus - 2, // 91: openshell.v1.ConfigureProviderRefreshRequest.strategy:type_name -> openshell.v1.ProviderCredentialRefreshStrategy - 236, // 92: openshell.v1.ConfigureProviderRefreshRequest.material:type_name -> openshell.v1.ConfigureProviderRefreshRequest.MaterialEntry - 107, // 93: openshell.v1.ConfigureProviderRefreshResponse.status:type_name -> openshell.v1.ProviderCredentialRefreshStatus - 107, // 94: openshell.v1.RotateProviderCredentialResponse.status:type_name -> openshell.v1.ProviderCredentialRefreshStatus - 3, // 95: openshell.v1.ProviderProfile.category:type_name -> openshell.v1.ProviderProfileCategory - 103, // 96: openshell.v1.ProviderProfile.credentials:type_name -> openshell.v1.ProviderProfileCredential - 254, // 97: openshell.v1.ProviderProfile.endpoints:type_name -> openshell.sandbox.v1.NetworkEndpoint - 255, // 98: openshell.v1.ProviderProfile.binaries:type_name -> openshell.sandbox.v1.NetworkBinary - 108, // 99: openshell.v1.ProviderProfile.discovery:type_name -> openshell.v1.ProviderProfileDiscovery - 237, // 100: openshell.v1.ProviderProfile.annotations:type_name -> openshell.v1.ProviderProfile.AnnotationsEntry - 248, // 101: openshell.v1.StoredProviderProfile.metadata:type_name -> openshell.datamodel.v1.ObjectMeta - 119, // 102: openshell.v1.StoredProviderProfile.profile:type_name -> openshell.v1.ProviderProfile - 119, // 103: openshell.v1.ProviderProfileResponse.profile:type_name -> openshell.v1.ProviderProfile - 119, // 104: openshell.v1.ListProviderProfilesResponse.profiles:type_name -> openshell.v1.ProviderProfile - 98, // 105: openshell.v1.ImportProviderProfilesRequest.profiles:type_name -> openshell.v1.ProviderProfileImportItem - 99, // 106: openshell.v1.ImportProviderProfilesResponse.diagnostics:type_name -> openshell.v1.ProviderProfileDiagnostic - 119, // 107: openshell.v1.ImportProviderProfilesResponse.profiles:type_name -> openshell.v1.ProviderProfile - 98, // 108: openshell.v1.UpdateProviderProfilesRequest.profile:type_name -> openshell.v1.ProviderProfileImportItem - 99, // 109: openshell.v1.UpdateProviderProfilesResponse.diagnostics:type_name -> openshell.v1.ProviderProfileDiagnostic - 119, // 110: openshell.v1.UpdateProviderProfilesResponse.profile:type_name -> openshell.v1.ProviderProfile - 98, // 111: openshell.v1.LintProviderProfilesRequest.profiles:type_name -> openshell.v1.ProviderProfileImportItem - 99, // 112: openshell.v1.LintProviderProfilesResponse.diagnostics:type_name -> openshell.v1.ProviderProfileDiagnostic - 133, // 113: openshell.v1.StaticCredentialBinding.endpoints:type_name -> openshell.v1.StaticCredentialEndpointBinding - 238, // 114: openshell.v1.GetSandboxProviderEnvironmentResponse.environment:type_name -> openshell.v1.GetSandboxProviderEnvironmentResponse.EnvironmentEntry - 239, // 115: openshell.v1.GetSandboxProviderEnvironmentResponse.credential_expires_at_ms:type_name -> openshell.v1.GetSandboxProviderEnvironmentResponse.CredentialExpiresAtMsEntry - 240, // 116: openshell.v1.GetSandboxProviderEnvironmentResponse.dynamic_credentials:type_name -> openshell.v1.GetSandboxProviderEnvironmentResponse.DynamicCredentialsEntry - 241, // 117: openshell.v1.GetSandboxProviderEnvironmentResponse.static_credential_bindings:type_name -> openshell.v1.GetSandboxProviderEnvironmentResponse.StaticCredentialBindingsEntry - 249, // 118: openshell.v1.UpdateConfigRequest.policy:type_name -> openshell.sandbox.v1.SandboxPolicy - 256, // 119: openshell.v1.UpdateConfigRequest.setting_value:type_name -> openshell.sandbox.v1.SettingValue - 139, // 120: openshell.v1.UpdateConfigRequest.merge_operations:type_name -> openshell.v1.PolicyMergeOperation - 242, // 121: openshell.v1.UpdateConfigRequest.annotations:type_name -> openshell.v1.UpdateConfigRequest.AnnotationsEntry - 140, // 122: openshell.v1.PolicyMergeOperation.add_rule:type_name -> openshell.v1.AddNetworkRule - 141, // 123: openshell.v1.PolicyMergeOperation.remove_endpoint:type_name -> openshell.v1.RemoveNetworkEndpoint - 142, // 124: openshell.v1.PolicyMergeOperation.remove_rule:type_name -> openshell.v1.RemoveNetworkRule - 143, // 125: openshell.v1.PolicyMergeOperation.add_deny_rules:type_name -> openshell.v1.AddDenyRules - 144, // 126: openshell.v1.PolicyMergeOperation.add_allow_rules:type_name -> openshell.v1.AddAllowRules - 145, // 127: openshell.v1.PolicyMergeOperation.remove_binary:type_name -> openshell.v1.RemoveNetworkBinary - 257, // 128: openshell.v1.AddNetworkRule.rule:type_name -> openshell.sandbox.v1.NetworkPolicyRule - 258, // 129: openshell.v1.AddDenyRules.deny_rules:type_name -> openshell.sandbox.v1.L7DenyRule - 259, // 130: openshell.v1.AddAllowRules.rules:type_name -> openshell.sandbox.v1.L7Rule - 243, // 131: openshell.v1.UpdateConfigResponse.annotations:type_name -> openshell.v1.UpdateConfigResponse.AnnotationsEntry - 153, // 132: openshell.v1.GetSandboxPolicyStatusResponse.revision:type_name -> openshell.v1.SandboxPolicyRevision - 153, // 133: openshell.v1.ListSandboxPoliciesResponse.revisions:type_name -> openshell.v1.SandboxPolicyRevision - 4, // 134: openshell.v1.ReportPolicyStatusRequest.status:type_name -> openshell.v1.PolicyStatus - 4, // 135: openshell.v1.SandboxPolicyRevision.status:type_name -> openshell.v1.PolicyStatus - 249, // 136: openshell.v1.SandboxPolicyRevision.policy:type_name -> openshell.sandbox.v1.SandboxPolicy - 244, // 137: openshell.v1.SandboxPolicyRevision.provenance:type_name -> openshell.v1.SandboxPolicyRevision.ProvenanceEntry - 87, // 138: openshell.v1.PushSandboxLogsRequest.logs:type_name -> openshell.v1.SandboxLogLine - 87, // 139: openshell.v1.GetSandboxLogsResponse.logs:type_name -> openshell.v1.SandboxLogLine - 160, // 140: openshell.v1.SupervisorMessage.hello:type_name -> openshell.v1.SupervisorHello - 163, // 141: openshell.v1.SupervisorMessage.heartbeat:type_name -> openshell.v1.SupervisorHeartbeat - 174, // 142: openshell.v1.SupervisorMessage.relay_open_result:type_name -> openshell.v1.RelayOpenResult - 175, // 143: openshell.v1.SupervisorMessage.relay_close:type_name -> openshell.v1.RelayClose - 161, // 144: openshell.v1.GatewayMessage.session_accepted:type_name -> openshell.v1.SessionAccepted - 162, // 145: openshell.v1.GatewayMessage.session_rejected:type_name -> openshell.v1.SessionRejected - 164, // 146: openshell.v1.GatewayMessage.heartbeat:type_name -> openshell.v1.GatewayHeartbeat - 169, // 147: openshell.v1.GatewayMessage.relay_open:type_name -> openshell.v1.RelayOpen - 175, // 148: openshell.v1.GatewayMessage.relay_close:type_name -> openshell.v1.RelayClose - 170, // 149: openshell.v1.RelayOpen.ssh:type_name -> openshell.v1.SshRelayTarget - 171, // 150: openshell.v1.RelayOpen.tcp:type_name -> openshell.v1.TcpRelayTarget - 172, // 151: openshell.v1.RelayFrame.init:type_name -> openshell.v1.RelayInit - 176, // 152: openshell.v1.DenialSummary.l7_request_samples:type_name -> openshell.v1.L7RequestSample - 178, // 153: openshell.v1.NetworkActivitySummary.denials_by_group:type_name -> openshell.v1.DenialGroupCount - 257, // 154: openshell.v1.PolicyChunk.proposed_rule:type_name -> openshell.sandbox.v1.NetworkPolicyRule - 249, // 155: openshell.v1.PolicyChunk.current_effective_policy:type_name -> openshell.sandbox.v1.SandboxPolicy - 249, // 156: openshell.v1.PolicyChunk.candidate_effective_policy:type_name -> openshell.sandbox.v1.SandboxPolicy - 177, // 157: openshell.v1.SubmitPolicyAnalysisRequest.summaries:type_name -> openshell.v1.DenialSummary - 180, // 158: openshell.v1.SubmitPolicyAnalysisRequest.proposed_chunks:type_name -> openshell.v1.PolicyChunk - 179, // 159: openshell.v1.SubmitPolicyAnalysisRequest.network_activity_summaries:type_name -> openshell.v1.NetworkActivitySummary - 180, // 160: openshell.v1.GetDraftPolicyResponse.chunks:type_name -> openshell.v1.PolicyChunk - 190, // 161: openshell.v1.ApproveAllDraftChunksRequest.approvals:type_name -> openshell.v1.DraftChunkApproval - 257, // 162: openshell.v1.EditDraftChunkRequest.proposed_rule:type_name -> openshell.sandbox.v1.NetworkPolicyRule - 200, // 163: openshell.v1.GetDraftHistoryResponse.entries:type_name -> openshell.v1.DraftHistoryEntry - 249, // 164: openshell.v1.PolicyRevisionPayload.policy:type_name -> openshell.sandbox.v1.SandboxPolicy - 245, // 165: openshell.v1.PolicyRevisionPayload.provenance:type_name -> openshell.v1.PolicyRevisionPayload.ProvenanceEntry - 257, // 166: openshell.v1.DraftChunkPayload.proposed_rule:type_name -> openshell.sandbox.v1.NetworkPolicyRule - 249, // 167: openshell.v1.DraftChunkPayload.current_effective_policy:type_name -> openshell.sandbox.v1.SandboxPolicy - 249, // 168: openshell.v1.DraftChunkPayload.candidate_effective_policy:type_name -> openshell.sandbox.v1.SandboxPolicy - 246, // 169: openshell.v1.StoredPolicyRevision.provenance:type_name -> openshell.v1.StoredPolicyRevision.ProvenanceEntry - 249, // 170: openshell.v1.StoredDraftChunk.current_effective_policy:type_name -> openshell.sandbox.v1.SandboxPolicy - 249, // 171: openshell.v1.StoredDraftChunk.candidate_effective_policy:type_name -> openshell.sandbox.v1.SandboxPolicy - 247, // 172: openshell.v1.CreateWorkspaceRequest.labels:type_name -> openshell.v1.CreateWorkspaceRequest.LabelsEntry - 260, // 173: openshell.v1.CreateWorkspaceResponse.workspace:type_name -> openshell.datamodel.v1.Workspace - 260, // 174: openshell.v1.GetWorkspaceResponse.workspace:type_name -> openshell.datamodel.v1.Workspace - 260, // 175: openshell.v1.ListWorkspacesResponse.workspaces:type_name -> openshell.datamodel.v1.Workspace - 248, // 176: openshell.v1.WorkspaceMember.metadata:type_name -> openshell.datamodel.v1.ObjectMeta - 6, // 177: openshell.v1.WorkspaceMember.role:type_name -> openshell.v1.WorkspaceRole - 6, // 178: openshell.v1.AddWorkspaceMemberRequest.role:type_name -> openshell.v1.WorkspaceRole - 214, // 179: openshell.v1.AddWorkspaceMemberResponse.member:type_name -> openshell.v1.WorkspaceMember - 214, // 180: openshell.v1.ListWorkspaceMembersResponse.members:type_name -> openshell.v1.WorkspaceMember - 253, // 181: openshell.v1.StoredProviderCredentialRefreshState.SecretMaterialHandlesEntry.value:type_name -> openshell.datamodel.v1.CredentialHandle - 103, // 182: openshell.v1.GetSandboxProviderEnvironmentResponse.DynamicCredentialsEntry.value:type_name -> openshell.v1.ProviderProfileCredential - 134, // 183: openshell.v1.GetSandboxProviderEnvironmentResponse.StaticCredentialBindingsEntry.value:type_name -> openshell.v1.StaticCredentialBinding - 12, // 184: openshell.v1.OpenShell.Health:input_type -> openshell.v1.HealthRequest - 14, // 185: openshell.v1.OpenShell.GetCurrentUser:input_type -> openshell.v1.GetCurrentUserRequest - 16, // 186: openshell.v1.OpenShell.GetGatewayInfo:input_type -> openshell.v1.GetGatewayInfoRequest - 39, // 187: openshell.v1.OpenShell.CreateSandbox:input_type -> openshell.v1.CreateSandboxRequest - 47, // 188: openshell.v1.OpenShell.BeginRootfsTarStaging:input_type -> openshell.v1.BeginRootfsTarStagingRequest - 49, // 189: openshell.v1.OpenShell.GetSandbox:input_type -> openshell.v1.GetSandboxRequest - 50, // 190: openshell.v1.OpenShell.ListSandboxes:input_type -> openshell.v1.ListSandboxesRequest - 40, // 191: openshell.v1.OpenShell.CreateSandboxTemplate:input_type -> openshell.v1.CreateSandboxTemplateRequest - 41, // 192: openshell.v1.OpenShell.GetSandboxTemplate:input_type -> openshell.v1.GetSandboxTemplateRequest - 42, // 193: openshell.v1.OpenShell.ListSandboxTemplates:input_type -> openshell.v1.ListSandboxTemplatesRequest - 43, // 194: openshell.v1.OpenShell.DeleteSandboxTemplate:input_type -> openshell.v1.DeleteSandboxTemplateRequest - 51, // 195: openshell.v1.OpenShell.ListSandboxProviders:input_type -> openshell.v1.ListSandboxProvidersRequest - 52, // 196: openshell.v1.OpenShell.AttachSandboxProvider:input_type -> openshell.v1.AttachSandboxProviderRequest - 53, // 197: openshell.v1.OpenShell.DetachSandboxProvider:input_type -> openshell.v1.DetachSandboxProviderRequest - 54, // 198: openshell.v1.OpenShell.DeleteSandbox:input_type -> openshell.v1.DeleteSandboxRequest - 55, // 199: openshell.v1.OpenShell.StopSandbox:input_type -> openshell.v1.StopSandboxRequest - 56, // 200: openshell.v1.OpenShell.StartSandbox:input_type -> openshell.v1.StartSandboxRequest - 63, // 201: openshell.v1.OpenShell.CreateSshSession:input_type -> openshell.v1.CreateSshSessionRequest - 65, // 202: openshell.v1.OpenShell.ExposeService:input_type -> openshell.v1.ExposeServiceRequest - 66, // 203: openshell.v1.OpenShell.GetService:input_type -> openshell.v1.GetServiceRequest - 67, // 204: openshell.v1.OpenShell.ListServices:input_type -> openshell.v1.ListServicesRequest - 69, // 205: openshell.v1.OpenShell.DeleteService:input_type -> openshell.v1.DeleteServiceRequest - 73, // 206: openshell.v1.OpenShell.RevokeSshSession:input_type -> openshell.v1.RevokeSshSessionRequest - 75, // 207: openshell.v1.OpenShell.ExecSandbox:input_type -> openshell.v1.ExecSandboxRequest - 81, // 208: openshell.v1.OpenShell.ForwardTcp:input_type -> openshell.v1.TcpForwardFrame - 82, // 209: openshell.v1.OpenShell.ExecSandboxInteractive:input_type -> openshell.v1.ExecSandboxInput - 89, // 210: openshell.v1.OpenShell.CreateProvider:input_type -> openshell.v1.CreateProviderRequest - 90, // 211: openshell.v1.OpenShell.GetProvider:input_type -> openshell.v1.GetProviderRequest - 91, // 212: openshell.v1.OpenShell.ListProviders:input_type -> openshell.v1.ListProvidersRequest - 96, // 213: openshell.v1.OpenShell.ListProviderProfiles:input_type -> openshell.v1.ListProviderProfilesRequest - 97, // 214: openshell.v1.OpenShell.GetProviderProfile:input_type -> openshell.v1.GetProviderProfileRequest - 123, // 215: openshell.v1.OpenShell.ImportProviderProfiles:input_type -> openshell.v1.ImportProviderProfilesRequest - 125, // 216: openshell.v1.OpenShell.UpdateProviderProfiles:input_type -> openshell.v1.UpdateProviderProfilesRequest - 127, // 217: openshell.v1.OpenShell.LintProviderProfiles:input_type -> openshell.v1.LintProviderProfilesRequest - 92, // 218: openshell.v1.OpenShell.UpdateProvider:input_type -> openshell.v1.UpdateProviderRequest - 111, // 219: openshell.v1.OpenShell.GetProviderRefreshStatus:input_type -> openshell.v1.GetProviderRefreshStatusRequest - 113, // 220: openshell.v1.OpenShell.ConfigureProviderRefresh:input_type -> openshell.v1.ConfigureProviderRefreshRequest - 115, // 221: openshell.v1.OpenShell.RotateProviderCredential:input_type -> openshell.v1.RotateProviderCredentialRequest - 117, // 222: openshell.v1.OpenShell.DeleteProviderRefresh:input_type -> openshell.v1.DeleteProviderRefreshRequest - 93, // 223: openshell.v1.OpenShell.DeleteProvider:input_type -> openshell.v1.DeleteProviderRequest - 130, // 224: openshell.v1.OpenShell.DeleteProviderProfile:input_type -> openshell.v1.DeleteProviderProfileRequest - 261, // 225: openshell.v1.OpenShell.GetSandboxConfig:input_type -> openshell.sandbox.v1.GetSandboxConfigRequest - 262, // 226: openshell.v1.OpenShell.GetGatewayConfig:input_type -> openshell.sandbox.v1.GetGatewayConfigRequest - 138, // 227: openshell.v1.OpenShell.UpdateConfig:input_type -> openshell.v1.UpdateConfigRequest - 147, // 228: openshell.v1.OpenShell.GetSandboxPolicyStatus:input_type -> openshell.v1.GetSandboxPolicyStatusRequest - 149, // 229: openshell.v1.OpenShell.ListSandboxPolicies:input_type -> openshell.v1.ListSandboxPoliciesRequest - 151, // 230: openshell.v1.OpenShell.ReportPolicyStatus:input_type -> openshell.v1.ReportPolicyStatusRequest - 132, // 231: openshell.v1.OpenShell.GetSandboxProviderEnvironment:input_type -> openshell.v1.GetSandboxProviderEnvironmentRequest - 136, // 232: openshell.v1.OpenShell.ExchangeProviderSubjectToken:input_type -> openshell.v1.ExchangeProviderSubjectTokenRequest - 154, // 233: openshell.v1.OpenShell.GetSandboxLogs:input_type -> openshell.v1.GetSandboxLogsRequest - 155, // 234: openshell.v1.OpenShell.PushSandboxLogs:input_type -> openshell.v1.PushSandboxLogsRequest - 158, // 235: openshell.v1.OpenShell.ConnectSupervisor:input_type -> openshell.v1.SupervisorMessage - 165, // 236: openshell.v1.OpenShell.ReportMainProcessExit:input_type -> openshell.v1.ReportMainProcessExitRequest - 167, // 237: openshell.v1.OpenShell.FinalizeMainProcessExit:input_type -> openshell.v1.FinalizeMainProcessExitRequest - 173, // 238: openshell.v1.OpenShell.RelayStream:input_type -> openshell.v1.RelayFrame - 85, // 239: openshell.v1.OpenShell.WatchSandbox:input_type -> openshell.v1.WatchSandboxRequest - 182, // 240: openshell.v1.OpenShell.SubmitPolicyAnalysis:input_type -> openshell.v1.SubmitPolicyAnalysisRequest - 184, // 241: openshell.v1.OpenShell.GetDraftPolicy:input_type -> openshell.v1.GetDraftPolicyRequest - 186, // 242: openshell.v1.OpenShell.ApproveDraftChunk:input_type -> openshell.v1.ApproveDraftChunkRequest - 188, // 243: openshell.v1.OpenShell.RejectDraftChunk:input_type -> openshell.v1.RejectDraftChunkRequest - 191, // 244: openshell.v1.OpenShell.ApproveAllDraftChunks:input_type -> openshell.v1.ApproveAllDraftChunksRequest - 193, // 245: openshell.v1.OpenShell.EditDraftChunk:input_type -> openshell.v1.EditDraftChunkRequest - 195, // 246: openshell.v1.OpenShell.UndoDraftChunk:input_type -> openshell.v1.UndoDraftChunkRequest - 197, // 247: openshell.v1.OpenShell.ClearDraftChunks:input_type -> openshell.v1.ClearDraftChunksRequest - 199, // 248: openshell.v1.OpenShell.GetDraftHistory:input_type -> openshell.v1.GetDraftHistoryRequest - 8, // 249: openshell.v1.OpenShell.IssueSandboxToken:input_type -> openshell.v1.IssueSandboxTokenRequest - 10, // 250: openshell.v1.OpenShell.RefreshSandboxToken:input_type -> openshell.v1.RefreshSandboxTokenRequest - 206, // 251: openshell.v1.OpenShell.CreateWorkspace:input_type -> openshell.v1.CreateWorkspaceRequest - 208, // 252: openshell.v1.OpenShell.GetWorkspace:input_type -> openshell.v1.GetWorkspaceRequest - 210, // 253: openshell.v1.OpenShell.ListWorkspaces:input_type -> openshell.v1.ListWorkspacesRequest - 212, // 254: openshell.v1.OpenShell.DeleteWorkspace:input_type -> openshell.v1.DeleteWorkspaceRequest - 215, // 255: openshell.v1.OpenShell.AddWorkspaceMember:input_type -> openshell.v1.AddWorkspaceMemberRequest - 217, // 256: openshell.v1.OpenShell.RemoveWorkspaceMember:input_type -> openshell.v1.RemoveWorkspaceMemberRequest - 219, // 257: openshell.v1.OpenShell.ListWorkspaceMembers:input_type -> openshell.v1.ListWorkspaceMembersRequest - 13, // 258: openshell.v1.OpenShell.Health:output_type -> openshell.v1.HealthResponse - 15, // 259: openshell.v1.OpenShell.GetCurrentUser:output_type -> openshell.v1.GetCurrentUserResponse - 17, // 260: openshell.v1.OpenShell.GetGatewayInfo:output_type -> openshell.v1.GetGatewayInfoResponse - 57, // 261: openshell.v1.OpenShell.CreateSandbox:output_type -> openshell.v1.SandboxResponse - 48, // 262: openshell.v1.OpenShell.BeginRootfsTarStaging:output_type -> openshell.v1.BeginRootfsTarStagingResponse - 57, // 263: openshell.v1.OpenShell.GetSandbox:output_type -> openshell.v1.SandboxResponse - 58, // 264: openshell.v1.OpenShell.ListSandboxes:output_type -> openshell.v1.ListSandboxesResponse - 44, // 265: openshell.v1.OpenShell.CreateSandboxTemplate:output_type -> openshell.v1.SandboxTemplateResponse - 44, // 266: openshell.v1.OpenShell.GetSandboxTemplate:output_type -> openshell.v1.SandboxTemplateResponse - 45, // 267: openshell.v1.OpenShell.ListSandboxTemplates:output_type -> openshell.v1.ListSandboxTemplatesResponse - 46, // 268: openshell.v1.OpenShell.DeleteSandboxTemplate:output_type -> openshell.v1.DeleteSandboxTemplateResponse - 59, // 269: openshell.v1.OpenShell.ListSandboxProviders:output_type -> openshell.v1.ListSandboxProvidersResponse - 60, // 270: openshell.v1.OpenShell.AttachSandboxProvider:output_type -> openshell.v1.AttachSandboxProviderResponse - 61, // 271: openshell.v1.OpenShell.DetachSandboxProvider:output_type -> openshell.v1.DetachSandboxProviderResponse - 62, // 272: openshell.v1.OpenShell.DeleteSandbox:output_type -> openshell.v1.DeleteSandboxResponse - 57, // 273: openshell.v1.OpenShell.StopSandbox:output_type -> openshell.v1.SandboxResponse - 57, // 274: openshell.v1.OpenShell.StartSandbox:output_type -> openshell.v1.SandboxResponse - 64, // 275: openshell.v1.OpenShell.CreateSshSession:output_type -> openshell.v1.CreateSshSessionResponse - 72, // 276: openshell.v1.OpenShell.ExposeService:output_type -> openshell.v1.ServiceEndpointResponse - 72, // 277: openshell.v1.OpenShell.GetService:output_type -> openshell.v1.ServiceEndpointResponse - 68, // 278: openshell.v1.OpenShell.ListServices:output_type -> openshell.v1.ListServicesResponse - 70, // 279: openshell.v1.OpenShell.DeleteService:output_type -> openshell.v1.DeleteServiceResponse - 74, // 280: openshell.v1.OpenShell.RevokeSshSession:output_type -> openshell.v1.RevokeSshSessionResponse - 79, // 281: openshell.v1.OpenShell.ExecSandbox:output_type -> openshell.v1.ExecSandboxEvent - 81, // 282: openshell.v1.OpenShell.ForwardTcp:output_type -> openshell.v1.TcpForwardFrame - 79, // 283: openshell.v1.OpenShell.ExecSandboxInteractive:output_type -> openshell.v1.ExecSandboxEvent - 94, // 284: openshell.v1.OpenShell.CreateProvider:output_type -> openshell.v1.ProviderResponse - 94, // 285: openshell.v1.OpenShell.GetProvider:output_type -> openshell.v1.ProviderResponse - 95, // 286: openshell.v1.OpenShell.ListProviders:output_type -> openshell.v1.ListProvidersResponse - 122, // 287: openshell.v1.OpenShell.ListProviderProfiles:output_type -> openshell.v1.ListProviderProfilesResponse - 121, // 288: openshell.v1.OpenShell.GetProviderProfile:output_type -> openshell.v1.ProviderProfileResponse - 124, // 289: openshell.v1.OpenShell.ImportProviderProfiles:output_type -> openshell.v1.ImportProviderProfilesResponse - 126, // 290: openshell.v1.OpenShell.UpdateProviderProfiles:output_type -> openshell.v1.UpdateProviderProfilesResponse - 128, // 291: openshell.v1.OpenShell.LintProviderProfiles:output_type -> openshell.v1.LintProviderProfilesResponse - 94, // 292: openshell.v1.OpenShell.UpdateProvider:output_type -> openshell.v1.ProviderResponse - 112, // 293: openshell.v1.OpenShell.GetProviderRefreshStatus:output_type -> openshell.v1.GetProviderRefreshStatusResponse - 114, // 294: openshell.v1.OpenShell.ConfigureProviderRefresh:output_type -> openshell.v1.ConfigureProviderRefreshResponse - 116, // 295: openshell.v1.OpenShell.RotateProviderCredential:output_type -> openshell.v1.RotateProviderCredentialResponse - 118, // 296: openshell.v1.OpenShell.DeleteProviderRefresh:output_type -> openshell.v1.DeleteProviderRefreshResponse - 129, // 297: openshell.v1.OpenShell.DeleteProvider:output_type -> openshell.v1.DeleteProviderResponse - 131, // 298: openshell.v1.OpenShell.DeleteProviderProfile:output_type -> openshell.v1.DeleteProviderProfileResponse - 263, // 299: openshell.v1.OpenShell.GetSandboxConfig:output_type -> openshell.sandbox.v1.GetSandboxConfigResponse - 264, // 300: openshell.v1.OpenShell.GetGatewayConfig:output_type -> openshell.sandbox.v1.GetGatewayConfigResponse - 146, // 301: openshell.v1.OpenShell.UpdateConfig:output_type -> openshell.v1.UpdateConfigResponse - 148, // 302: openshell.v1.OpenShell.GetSandboxPolicyStatus:output_type -> openshell.v1.GetSandboxPolicyStatusResponse - 150, // 303: openshell.v1.OpenShell.ListSandboxPolicies:output_type -> openshell.v1.ListSandboxPoliciesResponse - 152, // 304: openshell.v1.OpenShell.ReportPolicyStatus:output_type -> openshell.v1.ReportPolicyStatusResponse - 135, // 305: openshell.v1.OpenShell.GetSandboxProviderEnvironment:output_type -> openshell.v1.GetSandboxProviderEnvironmentResponse - 137, // 306: openshell.v1.OpenShell.ExchangeProviderSubjectToken:output_type -> openshell.v1.ExchangeProviderSubjectTokenResponse - 157, // 307: openshell.v1.OpenShell.GetSandboxLogs:output_type -> openshell.v1.GetSandboxLogsResponse - 156, // 308: openshell.v1.OpenShell.PushSandboxLogs:output_type -> openshell.v1.PushSandboxLogsResponse - 159, // 309: openshell.v1.OpenShell.ConnectSupervisor:output_type -> openshell.v1.GatewayMessage - 166, // 310: openshell.v1.OpenShell.ReportMainProcessExit:output_type -> openshell.v1.ReportMainProcessExitResponse - 168, // 311: openshell.v1.OpenShell.FinalizeMainProcessExit:output_type -> openshell.v1.FinalizeMainProcessExitResponse - 173, // 312: openshell.v1.OpenShell.RelayStream:output_type -> openshell.v1.RelayFrame - 86, // 313: openshell.v1.OpenShell.WatchSandbox:output_type -> openshell.v1.SandboxStreamEvent - 183, // 314: openshell.v1.OpenShell.SubmitPolicyAnalysis:output_type -> openshell.v1.SubmitPolicyAnalysisResponse - 185, // 315: openshell.v1.OpenShell.GetDraftPolicy:output_type -> openshell.v1.GetDraftPolicyResponse - 187, // 316: openshell.v1.OpenShell.ApproveDraftChunk:output_type -> openshell.v1.ApproveDraftChunkResponse - 189, // 317: openshell.v1.OpenShell.RejectDraftChunk:output_type -> openshell.v1.RejectDraftChunkResponse - 192, // 318: openshell.v1.OpenShell.ApproveAllDraftChunks:output_type -> openshell.v1.ApproveAllDraftChunksResponse - 194, // 319: openshell.v1.OpenShell.EditDraftChunk:output_type -> openshell.v1.EditDraftChunkResponse - 196, // 320: openshell.v1.OpenShell.UndoDraftChunk:output_type -> openshell.v1.UndoDraftChunkResponse - 198, // 321: openshell.v1.OpenShell.ClearDraftChunks:output_type -> openshell.v1.ClearDraftChunksResponse - 201, // 322: openshell.v1.OpenShell.GetDraftHistory:output_type -> openshell.v1.GetDraftHistoryResponse - 9, // 323: openshell.v1.OpenShell.IssueSandboxToken:output_type -> openshell.v1.IssueSandboxTokenResponse - 11, // 324: openshell.v1.OpenShell.RefreshSandboxToken:output_type -> openshell.v1.RefreshSandboxTokenResponse - 207, // 325: openshell.v1.OpenShell.CreateWorkspace:output_type -> openshell.v1.CreateWorkspaceResponse - 209, // 326: openshell.v1.OpenShell.GetWorkspace:output_type -> openshell.v1.GetWorkspaceResponse - 211, // 327: openshell.v1.OpenShell.ListWorkspaces:output_type -> openshell.v1.ListWorkspacesResponse - 213, // 328: openshell.v1.OpenShell.DeleteWorkspace:output_type -> openshell.v1.DeleteWorkspaceResponse - 216, // 329: openshell.v1.OpenShell.AddWorkspaceMember:output_type -> openshell.v1.AddWorkspaceMemberResponse - 218, // 330: openshell.v1.OpenShell.RemoveWorkspaceMember:output_type -> openshell.v1.RemoveWorkspaceMemberResponse - 220, // 331: openshell.v1.OpenShell.ListWorkspaceMembers:output_type -> openshell.v1.ListWorkspaceMembersResponse - 258, // [258:332] is the sub-list for method output_type - 184, // [184:258] is the sub-list for method input_type - 184, // [184:184] is the sub-list for extension type_name - 184, // [184:184] is the sub-list for extension extendee - 0, // [0:184] is the sub-list for field type_name + 28, // 18: openshell.v1.ResourceRequirements.cpu:type_name -> openshell.v1.CpuResourceRequirements + 29, // 19: openshell.v1.ResourceRequirements.memory:type_name -> openshell.v1.MemoryResourceRequirements + 224, // 20: openshell.v1.SandboxTemplate.labels:type_name -> openshell.v1.SandboxTemplate.LabelsEntry + 225, // 21: openshell.v1.SandboxTemplate.annotations:type_name -> openshell.v1.SandboxTemplate.AnnotationsEntry + 226, // 22: openshell.v1.SandboxTemplate.environment:type_name -> openshell.v1.SandboxTemplate.EnvironmentEntry + 251, // 23: openshell.v1.SandboxTemplate.resources:type_name -> google.protobuf.Struct + 251, // 24: openshell.v1.SandboxTemplate.driver_config:type_name -> google.protobuf.Struct + 249, // 25: openshell.v1.SandboxWorkloadTemplate.metadata:type_name -> openshell.datamodel.v1.ObjectMeta + 32, // 26: openshell.v1.SandboxWorkloadTemplate.spec:type_name -> openshell.v1.SandboxWorkloadTemplateSpec + 33, // 27: openshell.v1.SandboxWorkloadTemplateSpec.workload:type_name -> openshell.v1.SandboxWorkloadConfig + 251, // 28: openshell.v1.SandboxWorkloadTemplateSpec.driver_config:type_name -> google.protobuf.Struct + 34, // 29: openshell.v1.SandboxWorkloadTemplateSpec.desired_service_level:type_name -> openshell.v1.SandboxServiceLevel + 227, // 30: openshell.v1.SandboxWorkloadConfig.environment:type_name -> openshell.v1.SandboxWorkloadConfig.EnvironmentEntry + 26, // 31: openshell.v1.SandboxWorkloadConfig.resources:type_name -> openshell.v1.ResourceRequirements + 35, // 32: openshell.v1.SandboxServiceLevel.startup:type_name -> openshell.v1.SandboxStartup + 252, // 33: openshell.v1.SandboxStartup.ready_within:type_name -> google.protobuf.Duration + 38, // 34: openshell.v1.SandboxStatus.conditions:type_name -> openshell.v1.SandboxCondition + 0, // 35: openshell.v1.SandboxStatus.phase:type_name -> openshell.v1.SandboxPhase + 228, // 36: openshell.v1.PlatformEvent.metadata:type_name -> openshell.v1.PlatformEvent.MetadataEntry + 25, // 37: openshell.v1.CreateSandboxRequest.spec:type_name -> openshell.v1.SandboxSpec + 229, // 38: openshell.v1.CreateSandboxRequest.labels:type_name -> openshell.v1.CreateSandboxRequest.LabelsEntry + 230, // 39: openshell.v1.CreateSandboxRequest.annotations:type_name -> openshell.v1.CreateSandboxRequest.AnnotationsEntry + 31, // 40: openshell.v1.CreateSandboxTemplateRequest.template:type_name -> openshell.v1.SandboxWorkloadTemplate + 31, // 41: openshell.v1.SandboxTemplateResponse.template:type_name -> openshell.v1.SandboxWorkloadTemplate + 31, // 42: openshell.v1.ListSandboxTemplatesResponse.templates:type_name -> openshell.v1.SandboxWorkloadTemplate + 24, // 43: openshell.v1.SandboxResponse.sandbox:type_name -> openshell.v1.Sandbox + 24, // 44: openshell.v1.ListSandboxesResponse.sandboxes:type_name -> openshell.v1.Sandbox + 253, // 45: openshell.v1.ListSandboxProvidersResponse.providers:type_name -> openshell.datamodel.v1.Provider + 24, // 46: openshell.v1.AttachSandboxProviderResponse.sandbox:type_name -> openshell.v1.Sandbox + 24, // 47: openshell.v1.DetachSandboxProviderResponse.sandbox:type_name -> openshell.v1.Sandbox + 73, // 48: openshell.v1.ListServicesResponse.services:type_name -> openshell.v1.ServiceEndpointResponse + 249, // 49: openshell.v1.ServiceEndpoint.metadata:type_name -> openshell.datamodel.v1.ObjectMeta + 72, // 50: openshell.v1.ServiceEndpointResponse.endpoint:type_name -> openshell.v1.ServiceEndpoint + 231, // 51: openshell.v1.ExecSandboxRequest.environment:type_name -> openshell.v1.ExecSandboxRequest.EnvironmentEntry + 77, // 52: openshell.v1.ExecSandboxEvent.stdout:type_name -> openshell.v1.ExecSandboxStdout + 78, // 53: openshell.v1.ExecSandboxEvent.stderr:type_name -> openshell.v1.ExecSandboxStderr + 79, // 54: openshell.v1.ExecSandboxEvent.exit:type_name -> openshell.v1.ExecSandboxExit + 171, // 55: openshell.v1.TcpForwardInit.ssh:type_name -> openshell.v1.SshRelayTarget + 172, // 56: openshell.v1.TcpForwardInit.tcp:type_name -> openshell.v1.TcpRelayTarget + 81, // 57: openshell.v1.TcpForwardFrame.init:type_name -> openshell.v1.TcpForwardInit + 76, // 58: openshell.v1.ExecSandboxInput.start:type_name -> openshell.v1.ExecSandboxRequest + 84, // 59: openshell.v1.ExecSandboxInput.resize:type_name -> openshell.v1.ExecSandboxWindowResize + 249, // 60: openshell.v1.SshSession.metadata:type_name -> openshell.datamodel.v1.ObjectMeta + 24, // 61: openshell.v1.SandboxStreamEvent.sandbox:type_name -> openshell.v1.Sandbox + 88, // 62: openshell.v1.SandboxStreamEvent.log:type_name -> openshell.v1.SandboxLogLine + 39, // 63: openshell.v1.SandboxStreamEvent.event:type_name -> openshell.v1.PlatformEvent + 89, // 64: openshell.v1.SandboxStreamEvent.warning:type_name -> openshell.v1.SandboxStreamWarning + 182, // 65: openshell.v1.SandboxStreamEvent.draft_policy_update:type_name -> openshell.v1.DraftPolicyUpdate + 232, // 66: openshell.v1.SandboxLogLine.fields:type_name -> openshell.v1.SandboxLogLine.FieldsEntry + 253, // 67: openshell.v1.CreateProviderRequest.provider:type_name -> openshell.datamodel.v1.Provider + 253, // 68: openshell.v1.UpdateProviderRequest.provider:type_name -> openshell.datamodel.v1.Provider + 233, // 69: openshell.v1.UpdateProviderRequest.credential_expires_at_ms:type_name -> openshell.v1.UpdateProviderRequest.CredentialExpiresAtMsEntry + 253, // 70: openshell.v1.ProviderResponse.provider:type_name -> openshell.datamodel.v1.Provider + 253, // 71: openshell.v1.ListProvidersResponse.providers:type_name -> openshell.datamodel.v1.Provider + 120, // 72: openshell.v1.ProviderProfileImportItem.profile:type_name -> openshell.v1.ProviderProfile + 101, // 73: openshell.v1.ProviderCredentialTokenGrant.audience_overrides:type_name -> openshell.v1.ProviderCredentialTokenGrantAudienceOverride + 1, // 74: openshell.v1.ProviderCredentialTokenGrant.grant_type:type_name -> openshell.v1.ProviderCredentialTokenGrantType + 102, // 75: openshell.v1.ProviderCredentialTokenGrant.subject_token:type_name -> openshell.v1.ProviderCredentialTokenGrantSubjectToken + 107, // 76: openshell.v1.ProviderProfileCredential.refresh:type_name -> openshell.v1.ProviderCredentialRefresh + 103, // 77: openshell.v1.ProviderProfileCredential.token_grant:type_name -> openshell.v1.ProviderCredentialTokenGrant + 2, // 78: openshell.v1.ProviderCredentialRefresh.strategy:type_name -> openshell.v1.ProviderCredentialRefreshStrategy + 105, // 79: openshell.v1.ProviderCredentialRefresh.material:type_name -> openshell.v1.ProviderCredentialRefreshMaterial + 106, // 80: openshell.v1.ProviderCredentialRefresh.additional_outputs:type_name -> openshell.v1.ProviderCredentialRefreshOutput + 2, // 81: openshell.v1.ProviderCredentialRefreshStatus.strategy:type_name -> openshell.v1.ProviderCredentialRefreshStrategy + 7, // 82: openshell.v1.ProviderCredentialRefreshStatus.recovery_action:type_name -> openshell.v1.ProviderCredentialRefreshRecoveryAction + 249, // 83: openshell.v1.StoredProviderCredentialRefreshState.metadata:type_name -> openshell.datamodel.v1.ObjectMeta + 2, // 84: openshell.v1.StoredProviderCredentialRefreshState.strategy:type_name -> openshell.v1.ProviderCredentialRefreshStrategy + 234, // 85: openshell.v1.StoredProviderCredentialRefreshState.material:type_name -> openshell.v1.StoredProviderCredentialRefreshState.MaterialEntry + 235, // 86: openshell.v1.StoredProviderCredentialRefreshState.additional_output_keys:type_name -> openshell.v1.StoredProviderCredentialRefreshState.AdditionalOutputKeysEntry + 236, // 87: openshell.v1.StoredProviderCredentialRefreshState.secret_material_handles:type_name -> openshell.v1.StoredProviderCredentialRefreshState.SecretMaterialHandlesEntry + 111, // 88: openshell.v1.StoredProviderCredentialRefreshState.pending_secret_deletions:type_name -> openshell.v1.StoredRefreshMaterialDeletion + 7, // 89: openshell.v1.StoredProviderCredentialRefreshState.recovery_action:type_name -> openshell.v1.ProviderCredentialRefreshRecoveryAction + 254, // 90: openshell.v1.StoredRefreshMaterialDeletion.handle:type_name -> openshell.datamodel.v1.CredentialHandle + 108, // 91: openshell.v1.GetProviderRefreshStatusResponse.credentials:type_name -> openshell.v1.ProviderCredentialRefreshStatus + 2, // 92: openshell.v1.ConfigureProviderRefreshRequest.strategy:type_name -> openshell.v1.ProviderCredentialRefreshStrategy + 237, // 93: openshell.v1.ConfigureProviderRefreshRequest.material:type_name -> openshell.v1.ConfigureProviderRefreshRequest.MaterialEntry + 108, // 94: openshell.v1.ConfigureProviderRefreshResponse.status:type_name -> openshell.v1.ProviderCredentialRefreshStatus + 108, // 95: openshell.v1.RotateProviderCredentialResponse.status:type_name -> openshell.v1.ProviderCredentialRefreshStatus + 3, // 96: openshell.v1.ProviderProfile.category:type_name -> openshell.v1.ProviderProfileCategory + 104, // 97: openshell.v1.ProviderProfile.credentials:type_name -> openshell.v1.ProviderProfileCredential + 255, // 98: openshell.v1.ProviderProfile.endpoints:type_name -> openshell.sandbox.v1.NetworkEndpoint + 256, // 99: openshell.v1.ProviderProfile.binaries:type_name -> openshell.sandbox.v1.NetworkBinary + 109, // 100: openshell.v1.ProviderProfile.discovery:type_name -> openshell.v1.ProviderProfileDiscovery + 238, // 101: openshell.v1.ProviderProfile.annotations:type_name -> openshell.v1.ProviderProfile.AnnotationsEntry + 249, // 102: openshell.v1.StoredProviderProfile.metadata:type_name -> openshell.datamodel.v1.ObjectMeta + 120, // 103: openshell.v1.StoredProviderProfile.profile:type_name -> openshell.v1.ProviderProfile + 120, // 104: openshell.v1.ProviderProfileResponse.profile:type_name -> openshell.v1.ProviderProfile + 120, // 105: openshell.v1.ListProviderProfilesResponse.profiles:type_name -> openshell.v1.ProviderProfile + 99, // 106: openshell.v1.ImportProviderProfilesRequest.profiles:type_name -> openshell.v1.ProviderProfileImportItem + 100, // 107: openshell.v1.ImportProviderProfilesResponse.diagnostics:type_name -> openshell.v1.ProviderProfileDiagnostic + 120, // 108: openshell.v1.ImportProviderProfilesResponse.profiles:type_name -> openshell.v1.ProviderProfile + 99, // 109: openshell.v1.UpdateProviderProfilesRequest.profile:type_name -> openshell.v1.ProviderProfileImportItem + 100, // 110: openshell.v1.UpdateProviderProfilesResponse.diagnostics:type_name -> openshell.v1.ProviderProfileDiagnostic + 120, // 111: openshell.v1.UpdateProviderProfilesResponse.profile:type_name -> openshell.v1.ProviderProfile + 99, // 112: openshell.v1.LintProviderProfilesRequest.profiles:type_name -> openshell.v1.ProviderProfileImportItem + 100, // 113: openshell.v1.LintProviderProfilesResponse.diagnostics:type_name -> openshell.v1.ProviderProfileDiagnostic + 134, // 114: openshell.v1.StaticCredentialBinding.endpoints:type_name -> openshell.v1.StaticCredentialEndpointBinding + 239, // 115: openshell.v1.GetSandboxProviderEnvironmentResponse.environment:type_name -> openshell.v1.GetSandboxProviderEnvironmentResponse.EnvironmentEntry + 240, // 116: openshell.v1.GetSandboxProviderEnvironmentResponse.credential_expires_at_ms:type_name -> openshell.v1.GetSandboxProviderEnvironmentResponse.CredentialExpiresAtMsEntry + 241, // 117: openshell.v1.GetSandboxProviderEnvironmentResponse.dynamic_credentials:type_name -> openshell.v1.GetSandboxProviderEnvironmentResponse.DynamicCredentialsEntry + 242, // 118: openshell.v1.GetSandboxProviderEnvironmentResponse.static_credential_bindings:type_name -> openshell.v1.GetSandboxProviderEnvironmentResponse.StaticCredentialBindingsEntry + 250, // 119: openshell.v1.UpdateConfigRequest.policy:type_name -> openshell.sandbox.v1.SandboxPolicy + 257, // 120: openshell.v1.UpdateConfigRequest.setting_value:type_name -> openshell.sandbox.v1.SettingValue + 140, // 121: openshell.v1.UpdateConfigRequest.merge_operations:type_name -> openshell.v1.PolicyMergeOperation + 243, // 122: openshell.v1.UpdateConfigRequest.annotations:type_name -> openshell.v1.UpdateConfigRequest.AnnotationsEntry + 141, // 123: openshell.v1.PolicyMergeOperation.add_rule:type_name -> openshell.v1.AddNetworkRule + 142, // 124: openshell.v1.PolicyMergeOperation.remove_endpoint:type_name -> openshell.v1.RemoveNetworkEndpoint + 143, // 125: openshell.v1.PolicyMergeOperation.remove_rule:type_name -> openshell.v1.RemoveNetworkRule + 144, // 126: openshell.v1.PolicyMergeOperation.add_deny_rules:type_name -> openshell.v1.AddDenyRules + 145, // 127: openshell.v1.PolicyMergeOperation.add_allow_rules:type_name -> openshell.v1.AddAllowRules + 146, // 128: openshell.v1.PolicyMergeOperation.remove_binary:type_name -> openshell.v1.RemoveNetworkBinary + 258, // 129: openshell.v1.AddNetworkRule.rule:type_name -> openshell.sandbox.v1.NetworkPolicyRule + 259, // 130: openshell.v1.AddDenyRules.deny_rules:type_name -> openshell.sandbox.v1.L7DenyRule + 260, // 131: openshell.v1.AddAllowRules.rules:type_name -> openshell.sandbox.v1.L7Rule + 244, // 132: openshell.v1.UpdateConfigResponse.annotations:type_name -> openshell.v1.UpdateConfigResponse.AnnotationsEntry + 154, // 133: openshell.v1.GetSandboxPolicyStatusResponse.revision:type_name -> openshell.v1.SandboxPolicyRevision + 154, // 134: openshell.v1.ListSandboxPoliciesResponse.revisions:type_name -> openshell.v1.SandboxPolicyRevision + 4, // 135: openshell.v1.ReportPolicyStatusRequest.status:type_name -> openshell.v1.PolicyStatus + 4, // 136: openshell.v1.SandboxPolicyRevision.status:type_name -> openshell.v1.PolicyStatus + 250, // 137: openshell.v1.SandboxPolicyRevision.policy:type_name -> openshell.sandbox.v1.SandboxPolicy + 245, // 138: openshell.v1.SandboxPolicyRevision.provenance:type_name -> openshell.v1.SandboxPolicyRevision.ProvenanceEntry + 88, // 139: openshell.v1.PushSandboxLogsRequest.logs:type_name -> openshell.v1.SandboxLogLine + 88, // 140: openshell.v1.GetSandboxLogsResponse.logs:type_name -> openshell.v1.SandboxLogLine + 161, // 141: openshell.v1.SupervisorMessage.hello:type_name -> openshell.v1.SupervisorHello + 164, // 142: openshell.v1.SupervisorMessage.heartbeat:type_name -> openshell.v1.SupervisorHeartbeat + 175, // 143: openshell.v1.SupervisorMessage.relay_open_result:type_name -> openshell.v1.RelayOpenResult + 176, // 144: openshell.v1.SupervisorMessage.relay_close:type_name -> openshell.v1.RelayClose + 162, // 145: openshell.v1.GatewayMessage.session_accepted:type_name -> openshell.v1.SessionAccepted + 163, // 146: openshell.v1.GatewayMessage.session_rejected:type_name -> openshell.v1.SessionRejected + 165, // 147: openshell.v1.GatewayMessage.heartbeat:type_name -> openshell.v1.GatewayHeartbeat + 170, // 148: openshell.v1.GatewayMessage.relay_open:type_name -> openshell.v1.RelayOpen + 176, // 149: openshell.v1.GatewayMessage.relay_close:type_name -> openshell.v1.RelayClose + 171, // 150: openshell.v1.RelayOpen.ssh:type_name -> openshell.v1.SshRelayTarget + 172, // 151: openshell.v1.RelayOpen.tcp:type_name -> openshell.v1.TcpRelayTarget + 173, // 152: openshell.v1.RelayFrame.init:type_name -> openshell.v1.RelayInit + 177, // 153: openshell.v1.DenialSummary.l7_request_samples:type_name -> openshell.v1.L7RequestSample + 179, // 154: openshell.v1.NetworkActivitySummary.denials_by_group:type_name -> openshell.v1.DenialGroupCount + 258, // 155: openshell.v1.PolicyChunk.proposed_rule:type_name -> openshell.sandbox.v1.NetworkPolicyRule + 250, // 156: openshell.v1.PolicyChunk.current_effective_policy:type_name -> openshell.sandbox.v1.SandboxPolicy + 250, // 157: openshell.v1.PolicyChunk.candidate_effective_policy:type_name -> openshell.sandbox.v1.SandboxPolicy + 178, // 158: openshell.v1.SubmitPolicyAnalysisRequest.summaries:type_name -> openshell.v1.DenialSummary + 181, // 159: openshell.v1.SubmitPolicyAnalysisRequest.proposed_chunks:type_name -> openshell.v1.PolicyChunk + 180, // 160: openshell.v1.SubmitPolicyAnalysisRequest.network_activity_summaries:type_name -> openshell.v1.NetworkActivitySummary + 181, // 161: openshell.v1.GetDraftPolicyResponse.chunks:type_name -> openshell.v1.PolicyChunk + 191, // 162: openshell.v1.ApproveAllDraftChunksRequest.approvals:type_name -> openshell.v1.DraftChunkApproval + 258, // 163: openshell.v1.EditDraftChunkRequest.proposed_rule:type_name -> openshell.sandbox.v1.NetworkPolicyRule + 201, // 164: openshell.v1.GetDraftHistoryResponse.entries:type_name -> openshell.v1.DraftHistoryEntry + 250, // 165: openshell.v1.PolicyRevisionPayload.policy:type_name -> openshell.sandbox.v1.SandboxPolicy + 246, // 166: openshell.v1.PolicyRevisionPayload.provenance:type_name -> openshell.v1.PolicyRevisionPayload.ProvenanceEntry + 258, // 167: openshell.v1.DraftChunkPayload.proposed_rule:type_name -> openshell.sandbox.v1.NetworkPolicyRule + 250, // 168: openshell.v1.DraftChunkPayload.current_effective_policy:type_name -> openshell.sandbox.v1.SandboxPolicy + 250, // 169: openshell.v1.DraftChunkPayload.candidate_effective_policy:type_name -> openshell.sandbox.v1.SandboxPolicy + 247, // 170: openshell.v1.StoredPolicyRevision.provenance:type_name -> openshell.v1.StoredPolicyRevision.ProvenanceEntry + 250, // 171: openshell.v1.StoredDraftChunk.current_effective_policy:type_name -> openshell.sandbox.v1.SandboxPolicy + 250, // 172: openshell.v1.StoredDraftChunk.candidate_effective_policy:type_name -> openshell.sandbox.v1.SandboxPolicy + 248, // 173: openshell.v1.CreateWorkspaceRequest.labels:type_name -> openshell.v1.CreateWorkspaceRequest.LabelsEntry + 261, // 174: openshell.v1.CreateWorkspaceResponse.workspace:type_name -> openshell.datamodel.v1.Workspace + 261, // 175: openshell.v1.GetWorkspaceResponse.workspace:type_name -> openshell.datamodel.v1.Workspace + 261, // 176: openshell.v1.ListWorkspacesResponse.workspaces:type_name -> openshell.datamodel.v1.Workspace + 249, // 177: openshell.v1.WorkspaceMember.metadata:type_name -> openshell.datamodel.v1.ObjectMeta + 6, // 178: openshell.v1.WorkspaceMember.role:type_name -> openshell.v1.WorkspaceRole + 6, // 179: openshell.v1.AddWorkspaceMemberRequest.role:type_name -> openshell.v1.WorkspaceRole + 215, // 180: openshell.v1.AddWorkspaceMemberResponse.member:type_name -> openshell.v1.WorkspaceMember + 215, // 181: openshell.v1.ListWorkspaceMembersResponse.members:type_name -> openshell.v1.WorkspaceMember + 254, // 182: openshell.v1.StoredProviderCredentialRefreshState.SecretMaterialHandlesEntry.value:type_name -> openshell.datamodel.v1.CredentialHandle + 104, // 183: openshell.v1.GetSandboxProviderEnvironmentResponse.DynamicCredentialsEntry.value:type_name -> openshell.v1.ProviderProfileCredential + 135, // 184: openshell.v1.GetSandboxProviderEnvironmentResponse.StaticCredentialBindingsEntry.value:type_name -> openshell.v1.StaticCredentialBinding + 12, // 185: openshell.v1.OpenShell.Health:input_type -> openshell.v1.HealthRequest + 14, // 186: openshell.v1.OpenShell.GetCurrentUser:input_type -> openshell.v1.GetCurrentUserRequest + 16, // 187: openshell.v1.OpenShell.GetGatewayInfo:input_type -> openshell.v1.GetGatewayInfoRequest + 40, // 188: openshell.v1.OpenShell.CreateSandbox:input_type -> openshell.v1.CreateSandboxRequest + 48, // 189: openshell.v1.OpenShell.BeginRootfsTarStaging:input_type -> openshell.v1.BeginRootfsTarStagingRequest + 50, // 190: openshell.v1.OpenShell.GetSandbox:input_type -> openshell.v1.GetSandboxRequest + 51, // 191: openshell.v1.OpenShell.ListSandboxes:input_type -> openshell.v1.ListSandboxesRequest + 41, // 192: openshell.v1.OpenShell.CreateSandboxTemplate:input_type -> openshell.v1.CreateSandboxTemplateRequest + 42, // 193: openshell.v1.OpenShell.GetSandboxTemplate:input_type -> openshell.v1.GetSandboxTemplateRequest + 43, // 194: openshell.v1.OpenShell.ListSandboxTemplates:input_type -> openshell.v1.ListSandboxTemplatesRequest + 44, // 195: openshell.v1.OpenShell.DeleteSandboxTemplate:input_type -> openshell.v1.DeleteSandboxTemplateRequest + 52, // 196: openshell.v1.OpenShell.ListSandboxProviders:input_type -> openshell.v1.ListSandboxProvidersRequest + 53, // 197: openshell.v1.OpenShell.AttachSandboxProvider:input_type -> openshell.v1.AttachSandboxProviderRequest + 54, // 198: openshell.v1.OpenShell.DetachSandboxProvider:input_type -> openshell.v1.DetachSandboxProviderRequest + 55, // 199: openshell.v1.OpenShell.DeleteSandbox:input_type -> openshell.v1.DeleteSandboxRequest + 56, // 200: openshell.v1.OpenShell.StopSandbox:input_type -> openshell.v1.StopSandboxRequest + 57, // 201: openshell.v1.OpenShell.StartSandbox:input_type -> openshell.v1.StartSandboxRequest + 64, // 202: openshell.v1.OpenShell.CreateSshSession:input_type -> openshell.v1.CreateSshSessionRequest + 66, // 203: openshell.v1.OpenShell.ExposeService:input_type -> openshell.v1.ExposeServiceRequest + 67, // 204: openshell.v1.OpenShell.GetService:input_type -> openshell.v1.GetServiceRequest + 68, // 205: openshell.v1.OpenShell.ListServices:input_type -> openshell.v1.ListServicesRequest + 70, // 206: openshell.v1.OpenShell.DeleteService:input_type -> openshell.v1.DeleteServiceRequest + 74, // 207: openshell.v1.OpenShell.RevokeSshSession:input_type -> openshell.v1.RevokeSshSessionRequest + 76, // 208: openshell.v1.OpenShell.ExecSandbox:input_type -> openshell.v1.ExecSandboxRequest + 82, // 209: openshell.v1.OpenShell.ForwardTcp:input_type -> openshell.v1.TcpForwardFrame + 83, // 210: openshell.v1.OpenShell.ExecSandboxInteractive:input_type -> openshell.v1.ExecSandboxInput + 90, // 211: openshell.v1.OpenShell.CreateProvider:input_type -> openshell.v1.CreateProviderRequest + 91, // 212: openshell.v1.OpenShell.GetProvider:input_type -> openshell.v1.GetProviderRequest + 92, // 213: openshell.v1.OpenShell.ListProviders:input_type -> openshell.v1.ListProvidersRequest + 97, // 214: openshell.v1.OpenShell.ListProviderProfiles:input_type -> openshell.v1.ListProviderProfilesRequest + 98, // 215: openshell.v1.OpenShell.GetProviderProfile:input_type -> openshell.v1.GetProviderProfileRequest + 124, // 216: openshell.v1.OpenShell.ImportProviderProfiles:input_type -> openshell.v1.ImportProviderProfilesRequest + 126, // 217: openshell.v1.OpenShell.UpdateProviderProfiles:input_type -> openshell.v1.UpdateProviderProfilesRequest + 128, // 218: openshell.v1.OpenShell.LintProviderProfiles:input_type -> openshell.v1.LintProviderProfilesRequest + 93, // 219: openshell.v1.OpenShell.UpdateProvider:input_type -> openshell.v1.UpdateProviderRequest + 112, // 220: openshell.v1.OpenShell.GetProviderRefreshStatus:input_type -> openshell.v1.GetProviderRefreshStatusRequest + 114, // 221: openshell.v1.OpenShell.ConfigureProviderRefresh:input_type -> openshell.v1.ConfigureProviderRefreshRequest + 116, // 222: openshell.v1.OpenShell.RotateProviderCredential:input_type -> openshell.v1.RotateProviderCredentialRequest + 118, // 223: openshell.v1.OpenShell.DeleteProviderRefresh:input_type -> openshell.v1.DeleteProviderRefreshRequest + 94, // 224: openshell.v1.OpenShell.DeleteProvider:input_type -> openshell.v1.DeleteProviderRequest + 131, // 225: openshell.v1.OpenShell.DeleteProviderProfile:input_type -> openshell.v1.DeleteProviderProfileRequest + 262, // 226: openshell.v1.OpenShell.GetSandboxConfig:input_type -> openshell.sandbox.v1.GetSandboxConfigRequest + 263, // 227: openshell.v1.OpenShell.GetGatewayConfig:input_type -> openshell.sandbox.v1.GetGatewayConfigRequest + 139, // 228: openshell.v1.OpenShell.UpdateConfig:input_type -> openshell.v1.UpdateConfigRequest + 148, // 229: openshell.v1.OpenShell.GetSandboxPolicyStatus:input_type -> openshell.v1.GetSandboxPolicyStatusRequest + 150, // 230: openshell.v1.OpenShell.ListSandboxPolicies:input_type -> openshell.v1.ListSandboxPoliciesRequest + 152, // 231: openshell.v1.OpenShell.ReportPolicyStatus:input_type -> openshell.v1.ReportPolicyStatusRequest + 133, // 232: openshell.v1.OpenShell.GetSandboxProviderEnvironment:input_type -> openshell.v1.GetSandboxProviderEnvironmentRequest + 137, // 233: openshell.v1.OpenShell.ExchangeProviderSubjectToken:input_type -> openshell.v1.ExchangeProviderSubjectTokenRequest + 155, // 234: openshell.v1.OpenShell.GetSandboxLogs:input_type -> openshell.v1.GetSandboxLogsRequest + 156, // 235: openshell.v1.OpenShell.PushSandboxLogs:input_type -> openshell.v1.PushSandboxLogsRequest + 159, // 236: openshell.v1.OpenShell.ConnectSupervisor:input_type -> openshell.v1.SupervisorMessage + 166, // 237: openshell.v1.OpenShell.ReportMainProcessExit:input_type -> openshell.v1.ReportMainProcessExitRequest + 168, // 238: openshell.v1.OpenShell.FinalizeMainProcessExit:input_type -> openshell.v1.FinalizeMainProcessExitRequest + 174, // 239: openshell.v1.OpenShell.RelayStream:input_type -> openshell.v1.RelayFrame + 86, // 240: openshell.v1.OpenShell.WatchSandbox:input_type -> openshell.v1.WatchSandboxRequest + 183, // 241: openshell.v1.OpenShell.SubmitPolicyAnalysis:input_type -> openshell.v1.SubmitPolicyAnalysisRequest + 185, // 242: openshell.v1.OpenShell.GetDraftPolicy:input_type -> openshell.v1.GetDraftPolicyRequest + 187, // 243: openshell.v1.OpenShell.ApproveDraftChunk:input_type -> openshell.v1.ApproveDraftChunkRequest + 189, // 244: openshell.v1.OpenShell.RejectDraftChunk:input_type -> openshell.v1.RejectDraftChunkRequest + 192, // 245: openshell.v1.OpenShell.ApproveAllDraftChunks:input_type -> openshell.v1.ApproveAllDraftChunksRequest + 194, // 246: openshell.v1.OpenShell.EditDraftChunk:input_type -> openshell.v1.EditDraftChunkRequest + 196, // 247: openshell.v1.OpenShell.UndoDraftChunk:input_type -> openshell.v1.UndoDraftChunkRequest + 198, // 248: openshell.v1.OpenShell.ClearDraftChunks:input_type -> openshell.v1.ClearDraftChunksRequest + 200, // 249: openshell.v1.OpenShell.GetDraftHistory:input_type -> openshell.v1.GetDraftHistoryRequest + 8, // 250: openshell.v1.OpenShell.IssueSandboxToken:input_type -> openshell.v1.IssueSandboxTokenRequest + 10, // 251: openshell.v1.OpenShell.RefreshSandboxToken:input_type -> openshell.v1.RefreshSandboxTokenRequest + 207, // 252: openshell.v1.OpenShell.CreateWorkspace:input_type -> openshell.v1.CreateWorkspaceRequest + 209, // 253: openshell.v1.OpenShell.GetWorkspace:input_type -> openshell.v1.GetWorkspaceRequest + 211, // 254: openshell.v1.OpenShell.ListWorkspaces:input_type -> openshell.v1.ListWorkspacesRequest + 213, // 255: openshell.v1.OpenShell.DeleteWorkspace:input_type -> openshell.v1.DeleteWorkspaceRequest + 216, // 256: openshell.v1.OpenShell.AddWorkspaceMember:input_type -> openshell.v1.AddWorkspaceMemberRequest + 218, // 257: openshell.v1.OpenShell.RemoveWorkspaceMember:input_type -> openshell.v1.RemoveWorkspaceMemberRequest + 220, // 258: openshell.v1.OpenShell.ListWorkspaceMembers:input_type -> openshell.v1.ListWorkspaceMembersRequest + 13, // 259: openshell.v1.OpenShell.Health:output_type -> openshell.v1.HealthResponse + 15, // 260: openshell.v1.OpenShell.GetCurrentUser:output_type -> openshell.v1.GetCurrentUserResponse + 17, // 261: openshell.v1.OpenShell.GetGatewayInfo:output_type -> openshell.v1.GetGatewayInfoResponse + 58, // 262: openshell.v1.OpenShell.CreateSandbox:output_type -> openshell.v1.SandboxResponse + 49, // 263: openshell.v1.OpenShell.BeginRootfsTarStaging:output_type -> openshell.v1.BeginRootfsTarStagingResponse + 58, // 264: openshell.v1.OpenShell.GetSandbox:output_type -> openshell.v1.SandboxResponse + 59, // 265: openshell.v1.OpenShell.ListSandboxes:output_type -> openshell.v1.ListSandboxesResponse + 45, // 266: openshell.v1.OpenShell.CreateSandboxTemplate:output_type -> openshell.v1.SandboxTemplateResponse + 45, // 267: openshell.v1.OpenShell.GetSandboxTemplate:output_type -> openshell.v1.SandboxTemplateResponse + 46, // 268: openshell.v1.OpenShell.ListSandboxTemplates:output_type -> openshell.v1.ListSandboxTemplatesResponse + 47, // 269: openshell.v1.OpenShell.DeleteSandboxTemplate:output_type -> openshell.v1.DeleteSandboxTemplateResponse + 60, // 270: openshell.v1.OpenShell.ListSandboxProviders:output_type -> openshell.v1.ListSandboxProvidersResponse + 61, // 271: openshell.v1.OpenShell.AttachSandboxProvider:output_type -> openshell.v1.AttachSandboxProviderResponse + 62, // 272: openshell.v1.OpenShell.DetachSandboxProvider:output_type -> openshell.v1.DetachSandboxProviderResponse + 63, // 273: openshell.v1.OpenShell.DeleteSandbox:output_type -> openshell.v1.DeleteSandboxResponse + 58, // 274: openshell.v1.OpenShell.StopSandbox:output_type -> openshell.v1.SandboxResponse + 58, // 275: openshell.v1.OpenShell.StartSandbox:output_type -> openshell.v1.SandboxResponse + 65, // 276: openshell.v1.OpenShell.CreateSshSession:output_type -> openshell.v1.CreateSshSessionResponse + 73, // 277: openshell.v1.OpenShell.ExposeService:output_type -> openshell.v1.ServiceEndpointResponse + 73, // 278: openshell.v1.OpenShell.GetService:output_type -> openshell.v1.ServiceEndpointResponse + 69, // 279: openshell.v1.OpenShell.ListServices:output_type -> openshell.v1.ListServicesResponse + 71, // 280: openshell.v1.OpenShell.DeleteService:output_type -> openshell.v1.DeleteServiceResponse + 75, // 281: openshell.v1.OpenShell.RevokeSshSession:output_type -> openshell.v1.RevokeSshSessionResponse + 80, // 282: openshell.v1.OpenShell.ExecSandbox:output_type -> openshell.v1.ExecSandboxEvent + 82, // 283: openshell.v1.OpenShell.ForwardTcp:output_type -> openshell.v1.TcpForwardFrame + 80, // 284: openshell.v1.OpenShell.ExecSandboxInteractive:output_type -> openshell.v1.ExecSandboxEvent + 95, // 285: openshell.v1.OpenShell.CreateProvider:output_type -> openshell.v1.ProviderResponse + 95, // 286: openshell.v1.OpenShell.GetProvider:output_type -> openshell.v1.ProviderResponse + 96, // 287: openshell.v1.OpenShell.ListProviders:output_type -> openshell.v1.ListProvidersResponse + 123, // 288: openshell.v1.OpenShell.ListProviderProfiles:output_type -> openshell.v1.ListProviderProfilesResponse + 122, // 289: openshell.v1.OpenShell.GetProviderProfile:output_type -> openshell.v1.ProviderProfileResponse + 125, // 290: openshell.v1.OpenShell.ImportProviderProfiles:output_type -> openshell.v1.ImportProviderProfilesResponse + 127, // 291: openshell.v1.OpenShell.UpdateProviderProfiles:output_type -> openshell.v1.UpdateProviderProfilesResponse + 129, // 292: openshell.v1.OpenShell.LintProviderProfiles:output_type -> openshell.v1.LintProviderProfilesResponse + 95, // 293: openshell.v1.OpenShell.UpdateProvider:output_type -> openshell.v1.ProviderResponse + 113, // 294: openshell.v1.OpenShell.GetProviderRefreshStatus:output_type -> openshell.v1.GetProviderRefreshStatusResponse + 115, // 295: openshell.v1.OpenShell.ConfigureProviderRefresh:output_type -> openshell.v1.ConfigureProviderRefreshResponse + 117, // 296: openshell.v1.OpenShell.RotateProviderCredential:output_type -> openshell.v1.RotateProviderCredentialResponse + 119, // 297: openshell.v1.OpenShell.DeleteProviderRefresh:output_type -> openshell.v1.DeleteProviderRefreshResponse + 130, // 298: openshell.v1.OpenShell.DeleteProvider:output_type -> openshell.v1.DeleteProviderResponse + 132, // 299: openshell.v1.OpenShell.DeleteProviderProfile:output_type -> openshell.v1.DeleteProviderProfileResponse + 264, // 300: openshell.v1.OpenShell.GetSandboxConfig:output_type -> openshell.sandbox.v1.GetSandboxConfigResponse + 265, // 301: openshell.v1.OpenShell.GetGatewayConfig:output_type -> openshell.sandbox.v1.GetGatewayConfigResponse + 147, // 302: openshell.v1.OpenShell.UpdateConfig:output_type -> openshell.v1.UpdateConfigResponse + 149, // 303: openshell.v1.OpenShell.GetSandboxPolicyStatus:output_type -> openshell.v1.GetSandboxPolicyStatusResponse + 151, // 304: openshell.v1.OpenShell.ListSandboxPolicies:output_type -> openshell.v1.ListSandboxPoliciesResponse + 153, // 305: openshell.v1.OpenShell.ReportPolicyStatus:output_type -> openshell.v1.ReportPolicyStatusResponse + 136, // 306: openshell.v1.OpenShell.GetSandboxProviderEnvironment:output_type -> openshell.v1.GetSandboxProviderEnvironmentResponse + 138, // 307: openshell.v1.OpenShell.ExchangeProviderSubjectToken:output_type -> openshell.v1.ExchangeProviderSubjectTokenResponse + 158, // 308: openshell.v1.OpenShell.GetSandboxLogs:output_type -> openshell.v1.GetSandboxLogsResponse + 157, // 309: openshell.v1.OpenShell.PushSandboxLogs:output_type -> openshell.v1.PushSandboxLogsResponse + 160, // 310: openshell.v1.OpenShell.ConnectSupervisor:output_type -> openshell.v1.GatewayMessage + 167, // 311: openshell.v1.OpenShell.ReportMainProcessExit:output_type -> openshell.v1.ReportMainProcessExitResponse + 169, // 312: openshell.v1.OpenShell.FinalizeMainProcessExit:output_type -> openshell.v1.FinalizeMainProcessExitResponse + 174, // 313: openshell.v1.OpenShell.RelayStream:output_type -> openshell.v1.RelayFrame + 87, // 314: openshell.v1.OpenShell.WatchSandbox:output_type -> openshell.v1.SandboxStreamEvent + 184, // 315: openshell.v1.OpenShell.SubmitPolicyAnalysis:output_type -> openshell.v1.SubmitPolicyAnalysisResponse + 186, // 316: openshell.v1.OpenShell.GetDraftPolicy:output_type -> openshell.v1.GetDraftPolicyResponse + 188, // 317: openshell.v1.OpenShell.ApproveDraftChunk:output_type -> openshell.v1.ApproveDraftChunkResponse + 190, // 318: openshell.v1.OpenShell.RejectDraftChunk:output_type -> openshell.v1.RejectDraftChunkResponse + 193, // 319: openshell.v1.OpenShell.ApproveAllDraftChunks:output_type -> openshell.v1.ApproveAllDraftChunksResponse + 195, // 320: openshell.v1.OpenShell.EditDraftChunk:output_type -> openshell.v1.EditDraftChunkResponse + 197, // 321: openshell.v1.OpenShell.UndoDraftChunk:output_type -> openshell.v1.UndoDraftChunkResponse + 199, // 322: openshell.v1.OpenShell.ClearDraftChunks:output_type -> openshell.v1.ClearDraftChunksResponse + 202, // 323: openshell.v1.OpenShell.GetDraftHistory:output_type -> openshell.v1.GetDraftHistoryResponse + 9, // 324: openshell.v1.OpenShell.IssueSandboxToken:output_type -> openshell.v1.IssueSandboxTokenResponse + 11, // 325: openshell.v1.OpenShell.RefreshSandboxToken:output_type -> openshell.v1.RefreshSandboxTokenResponse + 208, // 326: openshell.v1.OpenShell.CreateWorkspace:output_type -> openshell.v1.CreateWorkspaceResponse + 210, // 327: openshell.v1.OpenShell.GetWorkspace:output_type -> openshell.v1.GetWorkspaceResponse + 212, // 328: openshell.v1.OpenShell.ListWorkspaces:output_type -> openshell.v1.ListWorkspacesResponse + 214, // 329: openshell.v1.OpenShell.DeleteWorkspace:output_type -> openshell.v1.DeleteWorkspaceResponse + 217, // 330: openshell.v1.OpenShell.AddWorkspaceMember:output_type -> openshell.v1.AddWorkspaceMemberResponse + 219, // 331: openshell.v1.OpenShell.RemoveWorkspaceMember:output_type -> openshell.v1.RemoveWorkspaceMemberResponse + 221, // 332: openshell.v1.OpenShell.ListWorkspaceMembers:output_type -> openshell.v1.ListWorkspaceMembersResponse + 259, // [259:333] is the sub-list for method output_type + 185, // [185:259] is the sub-list for method input_type + 185, // [185:185] is the sub-list for extension type_name + 185, // [185:185] is the sub-list for extension extendee + 0, // [0:185] is the sub-list for field type_name } func init() { file_openshell_proto_init() } @@ -17223,35 +17273,35 @@ func file_openshell_proto_init() { return } file_openshell_proto_msgTypes[19].OneofWrappers = []any{} - file_openshell_proto_msgTypes[20].OneofWrappers = []any{} - file_openshell_proto_msgTypes[28].OneofWrappers = []any{} - file_openshell_proto_msgTypes[71].OneofWrappers = []any{ + file_openshell_proto_msgTypes[22].OneofWrappers = []any{} + file_openshell_proto_msgTypes[29].OneofWrappers = []any{} + file_openshell_proto_msgTypes[72].OneofWrappers = []any{ (*ExecSandboxEvent_Stdout)(nil), (*ExecSandboxEvent_Stderr)(nil), (*ExecSandboxEvent_Exit)(nil), } - file_openshell_proto_msgTypes[72].OneofWrappers = []any{ + file_openshell_proto_msgTypes[73].OneofWrappers = []any{ (*TcpForwardInit_Ssh)(nil), (*TcpForwardInit_Tcp)(nil), } - file_openshell_proto_msgTypes[73].OneofWrappers = []any{ + file_openshell_proto_msgTypes[74].OneofWrappers = []any{ (*TcpForwardFrame_Init)(nil), (*TcpForwardFrame_Data)(nil), } - file_openshell_proto_msgTypes[74].OneofWrappers = []any{ + file_openshell_proto_msgTypes[75].OneofWrappers = []any{ (*ExecSandboxInput_Start)(nil), (*ExecSandboxInput_Stdin)(nil), (*ExecSandboxInput_Resize)(nil), } - file_openshell_proto_msgTypes[78].OneofWrappers = []any{ + file_openshell_proto_msgTypes[79].OneofWrappers = []any{ (*SandboxStreamEvent_Sandbox)(nil), (*SandboxStreamEvent_Log)(nil), (*SandboxStreamEvent_Event)(nil), (*SandboxStreamEvent_Warning)(nil), (*SandboxStreamEvent_DraftPolicyUpdate)(nil), } - file_openshell_proto_msgTypes[105].OneofWrappers = []any{} - file_openshell_proto_msgTypes[131].OneofWrappers = []any{ + file_openshell_proto_msgTypes[106].OneofWrappers = []any{} + file_openshell_proto_msgTypes[132].OneofWrappers = []any{ (*PolicyMergeOperation_AddRule)(nil), (*PolicyMergeOperation_RemoveEndpoint)(nil), (*PolicyMergeOperation_RemoveRule)(nil), @@ -17259,36 +17309,36 @@ func file_openshell_proto_init() { (*PolicyMergeOperation_AddAllowRules)(nil), (*PolicyMergeOperation_RemoveBinary)(nil), } - file_openshell_proto_msgTypes[150].OneofWrappers = []any{ + file_openshell_proto_msgTypes[151].OneofWrappers = []any{ (*SupervisorMessage_Hello)(nil), (*SupervisorMessage_Heartbeat)(nil), (*SupervisorMessage_RelayOpenResult)(nil), (*SupervisorMessage_RelayClose)(nil), } - file_openshell_proto_msgTypes[151].OneofWrappers = []any{ + file_openshell_proto_msgTypes[152].OneofWrappers = []any{ (*GatewayMessage_SessionAccepted)(nil), (*GatewayMessage_SessionRejected)(nil), (*GatewayMessage_Heartbeat)(nil), (*GatewayMessage_RelayOpen)(nil), (*GatewayMessage_RelayClose)(nil), } - file_openshell_proto_msgTypes[161].OneofWrappers = []any{ + file_openshell_proto_msgTypes[162].OneofWrappers = []any{ (*RelayOpen_Ssh)(nil), (*RelayOpen_Tcp)(nil), } - file_openshell_proto_msgTypes[165].OneofWrappers = []any{ + file_openshell_proto_msgTypes[166].OneofWrappers = []any{ (*RelayFrame_Init)(nil), (*RelayFrame_Data)(nil), } - file_openshell_proto_msgTypes[196].OneofWrappers = []any{} file_openshell_proto_msgTypes[197].OneofWrappers = []any{} + file_openshell_proto_msgTypes[198].OneofWrappers = []any{} type x struct{} out := protoimpl.TypeBuilder{ File: protoimpl.DescBuilder{ GoPackagePath: reflect.TypeOf(x{}).PkgPath(), RawDescriptor: unsafe.Slice(unsafe.StringData(file_openshell_proto_rawDesc), len(file_openshell_proto_rawDesc)), NumEnums: 8, - NumMessages: 240, + NumMessages: 241, NumExtensions: 0, NumServices: 1, }, From f2c6d9cfc7bc81cb3838ee5bbd17119a4a9fdf03 Mon Sep 17 00:00:00 2001 From: Evan Lezar Date: Wed, 9 Sep 2026 11:36:46 +0200 Subject: [PATCH 4/7] feat(sdk/python)!: align portable resource requirements Update reusable workload template construction and tests for the shared ResourceRequirements protobuf shape while preserving the high-level builder arguments. BREAKING CHANGE: Raw reusable-template protobuf callers must use resources.cpu.limit and resources.memory.limit instead of string fields. Part of #2838 Signed-off-by: Evan Lezar --- python/openshell/sandbox.py | 4 ++-- python/openshell/sandbox_test.py | 8 ++++---- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/python/openshell/sandbox.py b/python/openshell/sandbox.py index 07eeb6480e..016a966faa 100644 --- a/python/openshell/sandbox.py +++ b/python/openshell/sandbox.py @@ -1627,9 +1627,9 @@ def _sandbox_workload_template( if environment: template.spec.workload.environment.update(dict(environment)) if cpu is not None: - template.spec.workload.resources.cpu = cpu + template.spec.workload.resources.cpu.limit = cpu if memory is not None: - template.spec.workload.resources.memory = memory + template.spec.workload.resources.memory.limit = memory if gpu or gpu_count is not None: template.spec.workload.resources.gpu.SetInParent() if gpu_count is not None: diff --git a/python/openshell/sandbox_test.py b/python/openshell/sandbox_test.py index 5e12d0c8a3..140052a1f6 100644 --- a/python/openshell/sandbox_test.py +++ b/python/openshell/sandbox_test.py @@ -2008,8 +2008,8 @@ def _make_workload_template_proto( template.metadata.name = name template.metadata.workspace = workspace template.spec.workload.image = f"ghcr.io/test/{name}:latest" - template.spec.workload.resources.cpu = "1" - template.spec.workload.resources.memory = "512Mi" + template.spec.workload.resources.cpu.limit = "1" + template.spec.workload.resources.memory.limit = "512Mi" return template @@ -2286,8 +2286,8 @@ def test_sandbox_template_create_builds_template_from_public_fields() -> None: assert dict(template.metadata.annotations) == {"owner": "platform"} assert template.spec.workload.image == "ghcr.io/test/gpu-kata:latest" assert dict(template.spec.workload.environment) == {"FEATURE_FLAG": "on"} - assert template.spec.workload.resources.cpu == "1" - assert template.spec.workload.resources.memory == "512Mi" + assert template.spec.workload.resources.cpu.limit == "1" + assert template.spec.workload.resources.memory.limit == "512Mi" assert template.spec.workload.resources.gpu.count == 2 assert template.spec.driver_config["kubernetes"]["runtime_class_name"] == "kata" From 2821aaff534e738b0d22032f29992dcb36a13a8b Mon Sep 17 00:00:00 2001 From: Evan Lezar Date: Wed, 9 Sep 2026 11:36:46 +0200 Subject: [PATCH 5/7] feat(sdk/typescript)!: align portable resource requirements Use the shared generated ResourceRequirements shape for reusable workload templates and update the curated exports and tests. BREAKING CHANGE: SandboxResources is no longer exported, and reusable-template CPU and memory values use typed limit objects. Part of #2838 Signed-off-by: Evan Lezar --- sdk/typescript/src/client.test.ts | 66 +++++++++++++++++++++++++++++-- sdk/typescript/src/client.ts | 38 +++++++++++++++--- sdk/typescript/src/index.ts | 5 ++- 3 files changed, 100 insertions(+), 9 deletions(-) diff --git a/sdk/typescript/src/client.test.ts b/sdk/typescript/src/client.test.ts index 5b12a48e23..50a9ed4379 100644 --- a/sdk/typescript/src/client.test.ts +++ b/sdk/typescript/src/client.test.ts @@ -245,12 +245,61 @@ describe('create', () => { expect(created.spec?.tty).toBe(true); }); + it('sends portable CPU, memory, and explicit GPU requirements', async () => { + let created: { + spec?: { + resourceRequirements?: { + cpu?: { limit?: string }; + memory?: { limit?: string }; + gpu?: { count?: number }; + }; + }; + } = {}; + const sandbox = client({ + createSandbox: (req) => { + created = req; + return readySandbox('sb', 'sb-id'); + }, + }); + + await sandbox.create({ + image: 'img', + resourceRequirements: { + cpu: { limit: '2' }, + memory: { limit: '4Gi' }, + gpu: { count: 2 }, + }, + }); + + expect(created.spec?.resourceRequirements).toMatchObject({ + cpu: { limit: '2' }, + memory: { limit: '4Gi' }, + gpu: { count: 2 }, + }); + }); + + it('sends an empty GPU requirement for the driver default assignment', async () => { + let created: { spec?: { resourceRequirements?: { gpu?: { count?: number } } } } = {}; + const sandbox = client({ + createSandbox: (req) => { + created = req; + return readySandbox('sb', 'sb-id'); + }, + }); + + await sandbox.create({ image: 'img', resourceRequirements: { gpu: {} } }); + + expect(created.spec?.resourceRequirements?.gpu).toBeDefined(); + expect(created.spec?.resourceRequirements?.gpu?.count).toBeUndefined(); + }); + it('rawSpec reaches an ungated field and overrides a curated one', async () => { let created: { spec?: { logLevel?: string; template?: { image?: string }; providers?: string[]; + resourceRequirements?: { cpu?: { limit?: string } }; }; } = {}; const sandbox = client({ @@ -262,7 +311,12 @@ describe('create', () => { await sandbox.create({ image: 'curated-image', providers: ['claude'], - rawSpec: { logLevel: 'debug', template: { image: 'raw-image' } }, + resourceRequirements: { cpu: { limit: '1' } }, + rawSpec: { + logLevel: 'debug', + template: { image: 'raw-image' }, + resourceRequirements: { cpu: { limit: '4' } }, + }, }); // Ungated field only reachable via rawSpec. expect(created.spec?.logLevel).toBe('debug'); @@ -270,6 +324,8 @@ describe('create', () => { expect(created.spec?.template?.image).toBe('raw-image'); // Curated fields rawSpec does not touch survive. expect(created.spec?.providers).toEqual(['claude']); + // rawSpec also wins over the curated resource requirements object. + expect(created.spec?.resourceRequirements?.cpu?.limit).toBe('4'); }); it('createFromTemplate sends the workload template name with governance fields only', async () => { @@ -529,7 +585,11 @@ describe('sandbox templates', () => { workload?: { image?: string; environment?: Record; - resources?: { cpu?: string; memory?: string; gpu?: { count?: number } }; + resources?: { + cpu?: { limit?: string }; + memory?: { limit?: string }; + gpu?: { count?: number }; + }; }; driverConfig?: Record; }; @@ -560,7 +620,7 @@ describe('sandbox templates', () => { workload: { image: 'ghcr.io/nvidia/openshell-community/sandboxes/python:latest', environment: { FEATURE_FLAG: 'on' }, - resources: { cpu: '1', memory: '512Mi', gpu: { count: 1 } }, + resources: { cpu: { limit: '1' }, memory: { limit: '512Mi' }, gpu: { count: 1 } }, }, driverConfig: { kubernetes: { runtime_class_name: 'kata-containers' } }, }, diff --git a/sdk/typescript/src/client.ts b/sdk/typescript/src/client.ts index 4d1ff362ac..afbcbcfb96 100644 --- a/sdk/typescript/src/client.ts +++ b/sdk/typescript/src/client.ts @@ -35,7 +35,6 @@ import { buildTransport, type ConnectOptions } from './transport.js'; // Generated protobuf message shapes that callers need to populate or round-trip // directly. Re-export these rather than re-curating parallel surfaces. export type { - SandboxResources, SandboxServiceLevel, SandboxStartup, SandboxWorkloadConfig, @@ -84,6 +83,34 @@ export interface Health { version: string; } +/** Portable compute resource requirements for a sandbox workload. */ +export interface ResourceRequirements { + /** Presence requests GPU resources. An empty object uses the driver's default assignment. */ + gpu?: GPUResourceRequirements; + /** CPU requirements for the sandbox workload. */ + cpu?: CPUResourceRequirements; + /** Memory requirements for the sandbox workload. */ + memory?: MemoryResourceRequirements; +} + +/** GPU resource requirements for a sandbox. */ +export interface GPUResourceRequirements { + /** Number of GPUs requested. Omit to use the driver's default assignment. */ + count?: number; +} + +/** CPU resource requirements for a sandbox. */ +export interface CPUResourceRequirements { + /** Kubernetes-style CPU quantity such as `500m`, `1`, or `2.5`. */ + limit: string; +} + +/** Memory resource requirements for a sandbox. */ +export interface MemoryResourceRequirements { + /** Byte quantity such as `512Mi`, `4Gi`, or `8G`. */ + limit: string; +} + export interface SandboxSpec { name?: string; /** Workspace scope. Omit or use an empty string for the gateway default workspace. */ @@ -92,7 +119,8 @@ export interface SandboxSpec { labels?: Record; environment?: Record; providers?: string[]; - gpu?: boolean; + /** Portable GPU, CPU, and memory requirements for the sandbox workload. */ + resourceRequirements?: ResourceRequirements; /** Exact canonical command. Empty selects the gateway scratch shell. */ command?: string[]; /** Allocate a retained pseudo-terminal for the canonical command. */ @@ -107,8 +135,8 @@ export interface SandboxSpec { * Advanced escape hatch: the full generated proto spec. Curated fields build * the base spec, then `rawSpec` shallow-overrides at the top spec level, so * any field it sets wins. Use it to reach proto spec fields the curated shape - * does not surface (template runtime class, resource limits, log level, and - * future additions) without an SDK change. + * does not surface (template runtime class, log level, and future additions) + * without an SDK change. */ rawSpec?: MessageInitShape; } @@ -748,7 +776,7 @@ export class SandboxClient { environment: spec.environment ?? {}, providers: spec.providers ?? [], template: spec.image ? { image: spec.image } : undefined, - resourceRequirements: spec.gpu ? { gpu: {} } : undefined, + resourceRequirements: spec.resourceRequirements, policy: spec.policy, command: spec.command ?? [], tty: spec.tty ?? false, diff --git a/sdk/typescript/src/index.ts b/sdk/typescript/src/index.ts index 31571865be..4041b00cff 100644 --- a/sdk/typescript/src/index.ts +++ b/sdk/typescript/src/index.ts @@ -5,6 +5,7 @@ // export type { ConnectOptions, + CPUResourceRequirements, EffectiveSettingView, ExecExitEvent, ExecInteractiveOptions, @@ -15,19 +16,21 @@ export type { ExecStreamEvent, ForwardHandle, ForwardOptions, + GPUResourceRequirements, Health, HealthStatus, ListOptions, + MemoryResourceRequirements, PolicySourceName, ProviderChange, ProviderChangeOptions, ProviderRef, + ResourceRequirements, SandboxConfig, SandboxFromTemplateSpec, SandboxPhaseName, SandboxPolicy, SandboxRef, - SandboxResources, SandboxServiceLevel, SandboxSpec, SandboxStartup, From 7240cd82bf684a86e89cf614f29c54ac3f5418cd Mon Sep 17 00:00:00 2001 From: Evan Lezar Date: Wed, 9 Sep 2026 11:37:03 +0200 Subject: [PATCH 6/7] fix(server): validate portable resource requirements Validate typed CPU and memory quantities and reject legacy CPU or memory entries in the historical inline template resource passthrough with migration guidance. Part of #2838 Signed-off-by: Evan Lezar --- .../openshell-server/src/grpc/validation.rs | 179 +++++++++++++++++- 1 file changed, 176 insertions(+), 3 deletions(-) diff --git a/crates/openshell-server/src/grpc/validation.rs b/crates/openshell-server/src/grpc/validation.rs index dac34524c1..6bff364d29 100644 --- a/crates/openshell-server/src/grpc/validation.rs +++ b/crates/openshell-server/src/grpc/validation.rs @@ -181,8 +181,8 @@ pub(super) fn validate_sandbox_spec(name: &str, spec: &SandboxSpec) -> Result<() validate_env_entries(&tmpl.environment, "spec.template.environment")?; } - // --- spec.resource_requirements.gpu --- - validate_gpu_request_fields(spec)?; + // --- spec.resource_requirements --- + validate_resource_requirement_fields(spec)?; if !spec.command.is_empty() { validate_main_process_command(&spec.command)?; @@ -269,14 +269,40 @@ fn validate_main_process_command(command: &[String]) -> Result<(), Status> { Ok(()) } -fn validate_gpu_request_fields(spec: &SandboxSpec) -> Result<(), Status> { +fn validate_resource_requirement_fields(spec: &SandboxSpec) -> Result<(), Status> { if openshell_core::gpu::sandbox_gpu_count(spec.resource_requirements.as_ref()) == Some(0) { return Err(Status::invalid_argument("gpu count must be greater than 0")); } + if let Some(cpu) = spec + .resource_requirements + .as_ref() + .and_then(|requirements| requirements.cpu.as_ref()) + { + validate_cpu_quantity(&cpu.limit, "spec.resource_requirements.cpu.limit")?; + } + + if let Some(memory) = spec + .resource_requirements + .as_ref() + .and_then(|requirements| requirements.memory.as_ref()) + { + validate_memory_quantity(&memory.limit, "spec.resource_requirements.memory.limit")?; + } + Ok(()) } +fn validate_cpu_quantity(value: &str, field_name: &str) -> Result<(), Status> { + openshell_core::quantity::validate_cpu_quantity(value, field_name) + .map_err(Status::invalid_argument) +} + +fn validate_memory_quantity(value: &str, field_name: &str) -> Result<(), Status> { + openshell_core::quantity::validate_memory_quantity(value, field_name) + .map_err(Status::invalid_argument) +} + /// Validate template-level field sizes. fn validate_sandbox_template(tmpl: &SandboxTemplate) -> Result<(), Status> { // String fields. @@ -324,6 +350,7 @@ fn validate_sandbox_template(tmpl: &SandboxTemplate) -> Result<(), Status> { "template.resources serialized size exceeds maximum ({size} > {MAX_TEMPLATE_STRUCT_SIZE})" ))); } + reject_legacy_template_cpu_memory_resources(s)?; } if let Some(ref s) = tmpl.driver_config { let size = s.encoded_len(); @@ -359,6 +386,31 @@ fn reject_gateway_owned_driver_config_keys(config: &prost_types::Struct) -> Resu } } } + + Ok(()) +} + +fn reject_legacy_template_cpu_memory_resources( + resources: &prost_types::Struct, +) -> Result<(), Status> { + for section_name in ["limits", "requests"] { + let Some(value) = resources.fields.get(section_name) else { + continue; + }; + let Some(prost_types::value::Kind::StructValue(section)) = value.kind.as_ref() else { + return Err(Status::invalid_argument(format!( + "template.resources.{section_name} must be an object" + ))); + }; + + for resource_name in ["cpu", "memory"] { + if section.fields.contains_key(resource_name) { + return Err(Status::invalid_argument(format!( + "template.resources.{section_name}.{resource_name} is no longer supported; use spec.resource_requirements.{resource_name}.limit" + ))); + } + } + } Ok(()) } @@ -1067,6 +1119,8 @@ mod tests { let spec = SandboxSpec { resource_requirements: Some(openshell_core::proto::ResourceRequirements { gpu: Some(openshell_core::proto::GpuResourceRequirements { count: None }), + cpu: None, + memory: None, }), ..Default::default() }; @@ -1078,6 +1132,8 @@ mod tests { let spec = SandboxSpec { resource_requirements: Some(openshell_core::proto::ResourceRequirements { gpu: Some(openshell_core::proto::GpuResourceRequirements { count: Some(2) }), + cpu: None, + memory: None, }), ..Default::default() }; @@ -1089,6 +1145,8 @@ mod tests { let spec = SandboxSpec { resource_requirements: Some(openshell_core::proto::ResourceRequirements { gpu: Some(openshell_core::proto::GpuResourceRequirements { count: Some(0) }), + cpu: None, + memory: None, }), ..Default::default() }; @@ -1097,6 +1155,121 @@ mod tests { assert!(err.message().contains("gpu count must be greater than 0")); } + #[test] + fn validate_sandbox_spec_accepts_cpu_and_memory_requirements() { + let spec = SandboxSpec { + resource_requirements: Some(openshell_core::proto::ResourceRequirements { + gpu: None, + cpu: Some(openshell_core::proto::CpuResourceRequirements { + limit: "500m".to_string(), + }), + memory: Some(openshell_core::proto::MemoryResourceRequirements { + limit: "2Gi".to_string(), + }), + }), + ..Default::default() + }; + + assert!(validate_sandbox_spec("compute-sandbox", &spec).is_ok()); + } + + #[test] + fn validate_sandbox_spec_rejects_invalid_cpu_requirements() { + let spec = SandboxSpec { + resource_requirements: Some(openshell_core::proto::ResourceRequirements { + gpu: None, + cpu: Some(openshell_core::proto::CpuResourceRequirements { + limit: "0".to_string(), + }), + memory: Some(openshell_core::proto::MemoryResourceRequirements { + limit: "2Gi".to_string(), + }), + }), + ..Default::default() + }; + + let err = validate_sandbox_spec("compute-sandbox", &spec).unwrap_err(); + assert_eq!(err.code(), Code::InvalidArgument); + assert!( + err.message() + .contains("spec.resource_requirements.cpu.limit") + ); + } + + #[test] + fn validate_sandbox_spec_rejects_legacy_template_cpu_memory_resources() { + use prost_types::{Struct, Value, value::Kind}; + + let mut limits = std::collections::BTreeMap::new(); + limits.insert( + "cpu".to_string(), + Value { + kind: Some(Kind::StringValue("500m".to_string())), + }, + ); + let mut fields = std::collections::BTreeMap::new(); + fields.insert( + "limits".to_string(), + Value { + kind: Some(Kind::StructValue(Struct { fields: limits })), + }, + ); + let spec = SandboxSpec { + template: Some(SandboxTemplate { + resources: Some(Struct { fields }), + ..Default::default() + }), + ..Default::default() + }; + + let err = validate_sandbox_spec("legacy-resources", &spec).unwrap_err(); + assert_eq!(err.code(), Code::InvalidArgument); + assert!(err.message().contains("template.resources.limits.cpu")); + assert!( + err.message() + .contains("spec.resource_requirements.cpu.limit") + ); + } + + #[test] + fn validate_sandbox_spec_rejects_non_object_legacy_resource_sections() { + use prost_types::{ListValue, Struct, Value, value::Kind}; + + let invalid_sections = [ + ( + "limits", + "string", + Some(Kind::StringValue("500m".to_string())), + ), + ( + "requests", + "list", + Some(Kind::ListValue(ListValue { values: Vec::new() })), + ), + ("limits", "null", None), + ]; + + for (section_name, name, kind) in invalid_sections { + let mut fields = std::collections::BTreeMap::new(); + fields.insert(section_name.to_string(), Value { kind }); + let spec = SandboxSpec { + template: Some(SandboxTemplate { + resources: Some(Struct { fields }), + ..Default::default() + }), + ..Default::default() + }; + + let message = format!("{name} {section_name} section should be rejected"); + let err = validate_sandbox_spec("legacy-resources", &spec).expect_err(&message); + assert_eq!(err.code(), Code::InvalidArgument, "{name}"); + assert_eq!( + err.message(), + format!("template.resources.{section_name} must be an object") + ); + } + } + #[test] fn validate_sandbox_spec_accepts_empty_defaults() { assert!(validate_sandbox_spec("", &default_spec()).is_ok()); From 90eb97b5c30f275cc9917142ccf7c8131ed19a15 Mon Sep 17 00:00:00 2001 From: Evan Lezar Date: Wed, 9 Sep 2026 11:37:03 +0200 Subject: [PATCH 7/7] docs: explain unified portable resource requirements Document the shared inline and reusable-template resource model, driver behavior, migration from legacy template resource sections, and updated SDK examples. Part of #2838 Signed-off-by: Evan Lezar --- architecture/compute-runtimes.md | 33 ++++++++++++++-------- crates/openshell-sdk/README.md | 8 +++++- docs/reference/sandbox-compute-drivers.mdx | 32 +++++++++++++++++---- docs/sandboxes/manage-sandboxes.mdx | 26 +++++++++++++---- sdk/go/docs/src/api/sandbox-templates.md | 10 +++---- sdk/go/docs/src/api/sandboxes.md | 7 +++-- sdk/typescript/README.md | 22 ++++++++++++++- 7 files changed, 106 insertions(+), 32 deletions(-) diff --git a/architecture/compute-runtimes.md b/architecture/compute-runtimes.md index e1e731a0ce..c55e3629da 100644 --- a/architecture/compute-runtimes.md +++ b/architecture/compute-runtimes.md @@ -253,20 +253,21 @@ delete, reconciliation removes the row; otherwise it can remain `Deleting`. | VM | Experimental microVM isolation. | Per-sandbox libkrun VM. | Managed endpoint-backed driver. The gateway spawns `openshell-driver-vm`, waits for its Unix socket, and then consumes it through the same remote `compute_driver.proto` path used by unmanaged endpoint drivers. The VM driver boots a cached bootstrap `rootfs.ext4`, prepares requested OCI images inside a bootstrap VM with `umoci`, attaches the prepared image disk read-only, and gives each sandbox a writable `overlay.ext4` for merged-root changes and runtime material. The driver persists each accepted launch request beside the overlay and restarts those VMs on driver startup without recreating the overlay. | | Extension | Out-of-tree drivers operated alongside the gateway. | Whatever boundary the driver implements. | Selected by a custom `compute_drivers = [""]` entry with `[openshell.drivers.].socket_path`, or at launch time by pairing `--drivers ` with `--compute-driver-socket=`. A launch-time endpoint may use a canonical built-in name to preserve its driver-config key while replacing in-process construction. The gateway connects to an operator-provisioned UDS, snapshots `GetCapabilities`, and dispatches all sandbox lifecycle calls through `compute_driver.proto`. The driver process and socket lifecycle are operator-owned; the gateway does not spawn, supervise, or remove unmanaged extension drivers. The trust boundary is the socket's filesystem permissions: the operator must ensure only the gateway uid can read/write it. | -Per-sandbox CPU and memory values currently enter the driver layer through -template resource limits. Docker and Podman apply them as runtime limits. -Kubernetes mirrors each limit into the matching request. VM accepts the fields -but currently ignores them. +Per-sandbox CPU, memory, and GPU requirements enter the driver layer through +the typed `ResourceRequirements` message. Docker and Podman apply CPU and +memory as runtime limits. Kubernetes mirrors each limit into the matching +request. VM and MXC reject unsupported CPU and memory requirements instead of +silently ignoring them. Reusable sandbox workload templates are resolved before the compute-driver boundary. Drivers do not receive a separate template resource; the gateway lowers the selected `SandboxWorkloadTemplate` into the existing sandbox spec and validates that spec before calling `ValidateSandboxCreate` or -`CreateSandbox`. Template CPU and memory become the same typed resource limits -described above. Template GPU settings become `ResourceRequirements`, preserving -the driver's default GPU assignment when the count is omitted. Template -`driver_config` remains a driver-keyed envelope until the compute layer selects -the active driver block and forwards only that block to the driver. +`CreateSandbox`. `SandboxWorkloadConfig.resources` reuses the public +`ResourceRequirements` message, so the gateway clones the typed requirements +directly into the resolved sandbox spec. Template `driver_config` remains a +driver-keyed envelope until the compute layer selects the active driver block +and forwards only that block to the driver. Docker and Podman also accept per-sandbox driver-config mounts for existing runtime-managed named volumes and tmpfs mounts. Podman additionally accepts @@ -304,9 +305,17 @@ disjoint lifecycle ownership. A shared-mode gateway can target one external namespace, while operator mode maps workspace names to multiple platform-provisioned namespaces. -Resource requirements enter the driver layer through `SandboxSpec.resource_requirements`. This includes a set of GPU requirements, where a user -can request a specific number of GPUs or the driver-specific default behaviour. -For all in-tree drivers, this is equivalent to selecting a single GPU. +Resource requirements enter the driver layer through `SandboxSpec.resource_requirements`, +which carries typed GPU, CPU, and memory requirements as portable sandbox-sizing intent. +GPU requests let a user ask for a specific number of GPUs or the driver-specific default +behaviour; for all in-tree drivers, an unspecified count is equivalent to selecting a +single GPU. CPU and memory requests use Kubernetes-style quantity strings (e.g. `"500m"`, +`"4Gi"`). Docker, Podman, and Kubernetes apply typed CPU/memory requirements as native +resource limits; the VM and MXC drivers reject typed CPU/memory requirements with a clear +error until sizing support lands there, rather than silently ignoring them. +`SandboxTemplate.resources` remains a platform-native escape hatch for non-portable fields +only — CPU/memory keys under it are rejected in favor of +`resource_requirements.cpu`/`resource_requirements.memory`. VM runtime state paths are derived only from driver-validated sandbox IDs matching `[A-Za-z0-9._-]{1,128}`. The gateway-owned VM driver socket uses a diff --git a/crates/openshell-sdk/README.md b/crates/openshell-sdk/README.md index cb42e12dc1..3267dc3f16 100644 --- a/crates/openshell-sdk/README.md +++ b/crates/openshell-sdk/README.md @@ -57,7 +57,8 @@ with a discriminable kind. ```rust use openshell_sdk::{ - ClientConfig, OpenShellClient, SandboxTemplateCreateSpec, + ClientConfig, CpuResourceRequirements, MemoryResourceRequirements, OpenShellClient, + ResourceRequirements, SandboxTemplateCreateSpec, SandboxWorkloadConfig, SandboxWorkloadTemplate, SandboxWorkloadTemplateSpec, }; @@ -72,6 +73,11 @@ client spec: Some(SandboxWorkloadTemplateSpec { workload: Some(SandboxWorkloadConfig { image: "ghcr.io/nvidia/openshell-community/sandboxes/python:latest".to_string(), + resources: Some(ResourceRequirements { + cpu: Some(CpuResourceRequirements { limit: "1".to_string() }), + memory: Some(MemoryResourceRequirements { limit: "512Mi".to_string() }), + ..Default::default() + }), ..Default::default() }), ..Default::default() diff --git a/docs/reference/sandbox-compute-drivers.mdx b/docs/reference/sandbox-compute-drivers.mdx index 5e9789f4fe..d54238d8fc 100644 --- a/docs/reference/sandbox-compute-drivers.mdx +++ b/docs/reference/sandbox-compute-drivers.mdx @@ -89,11 +89,6 @@ The gateway connects to the operator-provided endpoint; it does not provision or supervise the remote driver. The operator must protect the socket so only the gateway uid can access it. -Sandbox create supports `--cpu` and `--memory` for per-sandbox compute sizing. -Docker and Podman apply them as runtime limits. Kubernetes applies them as both -container requests and limits. The VM driver accepts the fields but currently -ignores them. - Sandbox create also accepts experimental driver-owned config through `--driver-config-json`. The value is a JSON object keyed by driver name. The gateway forwards only the block for the active driver, so a Kubernetes gateway @@ -133,6 +128,33 @@ request. The VM driver accepts `gpu_device_ids`, for example accepts at most one entry and allows either `--gpu` or `--gpu 1` when `gpu_device_ids` is set. +## Portable Resource Requirements + +CPU, memory, and GPU requests use the typed +`SandboxSpec.resource_requirements` API: + +- `cpu.limit` contains a portable CPU quantity such as `500m` or `2`. +- `memory.limit` contains a portable memory quantity such as `512Mi` or `4Gi`. +- `gpu` indicates a GPU request and can include an optional count. + +Reusable workload templates use this same message at +`SandboxWorkloadConfig.resources`. The gateway copies those typed requirements +into the resolved sandbox spec when a sandbox is created from a template. + +| Driver | CPU and memory behavior | +|---|---| +| Docker | Converts typed limits to native container CPU and memory limits. | +| Podman | Converts typed limits to native container CPU and memory limits. | +| Kubernetes | Applies each typed value as both the container request and limit. | +| VM | Rejects typed CPU and memory requirements. Configure gateway-wide `vcpus` and `mem_mib` instead. | +| MXC | Rejects typed CPU and memory requirements. | + +The historical inline `SandboxTemplate.resources` remains available for platform-native resource +fields that do not have a portable representation. Do not place CPU or memory +under its `limits` or `requests` sections. The gateway rejects `limits.cpu`, +`limits.memory`, `requests.cpu`, and `requests.memory` and directs the caller to +the corresponding typed field. + ## Resource Capability Reporting API clients can read each configured driver's static resource request support diff --git a/docs/sandboxes/manage-sandboxes.mdx b/docs/sandboxes/manage-sandboxes.mdx index 40b35e4237..2925fe1c4e 100644 --- a/docs/sandboxes/manage-sandboxes.mdx +++ b/docs/sandboxes/manage-sandboxes.mdx @@ -66,7 +66,7 @@ openshell gateway select local ### CPU and Memory -Set per-sandbox CPU and memory amounts with `--cpu` and `--memory`: +Set portable CPU and memory limits with `--cpu` and `--memory`: ```shell openshell sandbox create --cpu 2 --memory 4Gi -- claude @@ -75,10 +75,20 @@ openshell sandbox create --cpu 2 --memory 4Gi -- claude CPU values use Kubernetes-style quantities such as `500m`, `1`, or `2.5`. Memory values use byte quantities such as `512Mi`, `4Gi`, or `8G`. -Docker and Podman apply these values as runtime limits. Kubernetes applies each -value as both the request and the limit so the scheduler reserves the same -amount the sandbox can use. The VM driver currently accepts these flags but -does not change VM allocation. +OpenShell stores these values as typed portable resource requirements. Docker +and Podman apply them as runtime limits. Kubernetes applies each value as both +the request and limit so the scheduler reserves the same amount the sandbox can +use. The VM and MXC drivers reject CPU or memory requirements because they do +not currently support per-sandbox sizing. For VM gateways, configure `vcpus` +and `mem_mib` on the driver instead. + + +CPU and memory values under `SandboxTemplate.resources.limits` or +`SandboxTemplate.resources.requests` are no longer supported. API clients must +use `SandboxSpec.resource_requirements.cpu.limit` and +`SandboxSpec.resource_requirements.memory.limit`. The gateway rejects legacy +requests with a migration error. + ### Driver-Specific Configuration @@ -227,6 +237,12 @@ Create a sandbox from a template: openshell sandbox create --template gpu-kata --provider github -- claude ``` +When the gateway creates a sandbox from a template, it resolves the template's +CPU, memory, and GPU settings into the sandbox's typed `resource_requirements`. +The reusable template field `SandboxWorkloadConfig.resources` uses the same +`ResourceRequirements` message as `SandboxSpec.resource_requirements`, so API +and SDK callers use `cpu.limit`, `memory.limit`, and `gpu` in both places. + The `--template` flag cannot be combined with inline workload flags such as `--from`, `--cpu`, `--memory`, `--gpu`, `--env`, or `--driver-config-json`. Put those values on the template instead. Create-time policy and provider attachments remain part of the sandbox request, so each sandbox can keep its own access boundary. Inspect and manage templates: diff --git a/sdk/go/docs/src/api/sandbox-templates.md b/sdk/go/docs/src/api/sandbox-templates.md index d1dcc86e47..9268f831ab 100644 --- a/sdk/go/docs/src/api/sandbox-templates.md +++ b/sdk/go/docs/src/api/sandbox-templates.md @@ -29,10 +29,10 @@ template, err := client.SandboxTemplates().Create(ctx, "default", &v1.SandboxWor Environment: map[string]string{ "NVIDIA_VISIBLE_DEVICES": "all", }, - Resources: &v1.SandboxResources{ - CPU: "2", - Memory: "8Gi", - GPU: &v1.SandboxGPURequirements{Count: &gpuCount}, + Resources: &v1.ResourceRequirements{ + CPU: &v1.CPUResourceRequirements{Limit: "2"}, + Memory: &v1.MemoryResourceRequirements{Limit: "8Gi"}, + GPU: &v1.GPUResourceRequirements{Count: &gpuCount}, }, }, DriverConfig: map[string]any{ @@ -52,7 +52,7 @@ template, err := client.SandboxTemplates().Create(ctx, "default", &v1.SandboxWor }) ``` -Set `GPU: &v1.SandboxGPURequirements{}` to request the active driver's default +Set `GPU: &v1.GPUResourceRequirements{}` to request the active driver's default GPU assignment without specifying a count. ## Create a Sandbox From a Template diff --git a/sdk/go/docs/src/api/sandboxes.md b/sdk/go/docs/src/api/sandboxes.md index 698982fe13..2639408fa9 100644 --- a/sdk/go/docs/src/api/sandboxes.md +++ b/sdk/go/docs/src/api/sandboxes.md @@ -20,9 +20,10 @@ sb, err := client.Sandboxes().Create(ctx, "default", "my-sandbox", &v1.SandboxSp }) ``` -Set `GPU: true` to request the active driver's default GPU assignment. Set -`GPUCount` when the sandbox needs a specific GPU count; a non-nil `GPUCount` -also implies `GPU`. +Set `ResourceRequirements.GPU` to request a GPU. Leave its `Count` nil to use +the active driver's default GPU assignment, or set `Count` to request a +specific number. `ResourceRequirements.CPU` and `.Memory` accept portable +quantity limits such as `500m` and `2Gi`. ## Create From Template diff --git a/sdk/typescript/README.md b/sdk/typescript/README.md index 322b1a092c..4351b310c9 100644 --- a/sdk/typescript/README.md +++ b/sdk/typescript/README.md @@ -35,6 +35,10 @@ const client = await OpenShellClient.connect({ const sandbox = await client.sandbox.create({ image: 'ghcr.io/nvidia/openshell-community/sandboxes/python:latest', + resourceRequirements: { + cpu: { limit: '2' }, + memory: { limit: '4Gi' }, + }, }) await client.sandbox.waitReady(sandbox.name, 120) @@ -69,6 +73,22 @@ in memory, and renews before expiry. The root client has no explicit close method because Connect does not retain a dedicated session. Close operation-scoped streams and forward handles instead. +Set portable compute requirements with `resourceRequirements`. CPU and memory +limits use Kubernetes-style quantities. Set `gpu: {}` to request the active +driver's default GPU assignment, or set `gpu.count` to request a specific +number: + +```ts +await client.sandbox.create({ + image, + resourceRequirements: { + cpu: { limit: '500m' }, + memory: { limit: '2Gi' }, + gpu: { count: 1 }, + }, +}) +``` + Express the create-time safety boundary with `policy`. Sandbox-scoped `setPolicy` cannot introduce static policy fields later, so set filesystem, landlock, process, and initial network policy at creation. For proto spec fields the @@ -170,7 +190,7 @@ const template: SandboxWorkloadTemplate = await client.sandboxTemplates.create( workload: { image: 'ghcr.io/nvidia/openshell-community/sandboxes/python:latest', environment: { FEATURE_FLAG: 'on' }, - resources: { cpu: '1', memory: '512Mi' }, + resources: { cpu: { limit: '1' }, memory: { limit: '512Mi' } }, }, driverConfig: { kubernetes: { pod: { runtime_class_name: 'kata-containers' } } }, },