From ddbb259ce6c5b7c4c80113027582ce0b53fba11a 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 | 318 +++++++----------- .../sandbox_create_lifecycle_integration.rs | 108 +++--- 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 | 58 ++-- crates/openshell-driver-docker/src/tests.rs | 62 ++-- .../openshell-driver-kubernetes/src/driver.rs | 299 +++++++++++++--- crates/openshell-driver-mxc/src/driver.rs | 11 + .../openshell-driver-podman/src/container.rs | 92 +++-- crates/openshell-driver-podman/src/driver.rs | 12 +- crates/openshell-driver-vm/src/driver.rs | 58 +++- crates/openshell-server/src/compute/mod.rs | 115 ++++--- crates/openshell-server/src/grpc/mod.rs | 13 +- crates/openshell-server/src/grpc/sandbox.rs | 318 +++++++++++++----- crates/openshell-server/src/storage_proto.rs | 12 +- proto/compute_driver.proto | 44 +-- proto/openshell.proto | 42 ++- 19 files changed, 1119 insertions(+), 590 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 9f55658efc..ab68346f2d 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 { @@ -3200,6 +3200,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; @@ -3214,9 +3229,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 3256cbe111..05ac28b10b 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, DeleteSandboxRequest, DeleteSandboxTemplateRequest, - DeleteServiceRequest, DeletionOutcome, EndpointResult, EndpointStatus, ExecSandboxRequest, - ExposeServiceRequest, GetCurrentUserRequest, GetDraftHistoryRequest, GetDraftPolicyRequest, - GetGatewayConfigRequest, GetSandboxConfigRequest, GetSandboxConfigResponse, - GetSandboxLogsRequest, GetSandboxPolicyStatusRequest, GetSandboxRequest, - GetSandboxTemplateRequest, GetServiceRequest, GpuResourceRequirements, - ListSandboxPoliciesRequest, ListSandboxTemplatesRequest, ListSandboxesRequest, - ListServicesRequest, PolicySource, PolicyStatus, RejectDraftChunkRequest, ResourceRequirements, - RevokeSshSessionRequest, Sandbox, SandboxCondition, SandboxPhase, SandboxPolicy, - SandboxResources, SandboxServiceLevel, SandboxSpec, SandboxStartup, SandboxTemplate, - SandboxWorkloadConfig, SandboxWorkloadTemplate, SandboxWorkloadTemplateSpec, - ServiceEndpointResponse, SettingScope, StartSandboxRequest, StopSandboxRequest, - TcpForwardFrame, TcpForwardInit, TcpRelayTarget, UpdateConfigRequest, WatchSandboxRequest, - exec_sandbox_event, tcp_forward_init, + ClearDraftChunksRequest, CpuResourceRequirements, CreateSandboxRequest, + CreateSandboxTemplateRequest, CreateSshSessionRequest, DeleteSandboxRequest, + DeleteSandboxTemplateRequest, DeleteServiceRequest, DeletionOutcome, EndpointResult, + EndpointStatus, ExecSandboxRequest, ExposeServiceRequest, GetCurrentUserRequest, + GetDraftHistoryRequest, GetDraftPolicyRequest, GetGatewayConfigRequest, + GetSandboxConfigRequest, GetSandboxConfigResponse, GetSandboxLogsRequest, + GetSandboxPolicyStatusRequest, GetSandboxRequest, GetSandboxTemplateRequest, GetServiceRequest, + GpuResourceRequirements, ListSandboxPoliciesRequest, ListSandboxTemplatesRequest, + ListSandboxesRequest, ListServicesRequest, MemoryResourceRequirements, PolicySource, + PolicyStatus, RejectDraftChunkRequest, ResourceRequirements, RevokeSshSessionRequest, Sandbox, + SandboxCondition, SandboxPhase, SandboxPolicy, SandboxServiceLevel, SandboxSpec, + SandboxStartup, SandboxTemplate, SandboxWorkloadConfig, SandboxWorkloadTemplate, + SandboxWorkloadTemplateSpec, ServiceEndpointResponse, SettingScope, StartSandboxRequest, + StopSandboxRequest, TcpForwardFrame, TcpForwardInit, TcpRelayTarget, UpdateConfigRequest, + WatchSandboxRequest, exec_sandbox_event, tcp_forward_init, }; use openshell_core::settings; use openshell_core::{ObjectId, ObjectName, ObjectWorkspace}; @@ -283,41 +283,28 @@ fn is_provisional_container_exit(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 { + quantity: Some(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 { + quantity: Some(validate_memory_quantity(memory)?), + })) } fn parse_driver_config_json(value: &str) -> Result { @@ -337,61 +324,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( @@ -432,9 +372,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], @@ -459,9 +397,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: &[], @@ -494,9 +430,7 @@ pub async fn sandbox_create( from, uploads, keep, - gpu_requirements, - cpu, - memory, + resource_requirements, driver_config_json, editor, providers, @@ -556,9 +490,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()) { @@ -593,11 +525,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) @@ -610,22 +537,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()); @@ -651,7 +572,7 @@ pub async fn sandbox_create( let request = CreateSandboxRequest { request_id: String::new(), spec: Some(SandboxSpec { - resource_requirements, + resource_requirements: resource_requirements.clone(), environment: if template.is_none() { environment } else { @@ -2759,15 +2680,18 @@ pub async fn sandbox_template_create( suppress_credential_warnings: bool, ) -> Result<()> { let resources = if cpu.is_some() || memory.is_some() || gpu_requirements.is_some() { - Some(SandboxResources { - cpu: cpu - .map(validate_cpu_quantity) - .transpose()? - .unwrap_or_default(), + Some(ResourceRequirements { + cpu: cpu.map(validate_cpu_quantity).transpose()?.map(|quantity| { + CpuResourceRequirements { + quantity: Some(quantity), + } + }), memory: memory .map(validate_memory_quantity) .transpose()? - .unwrap_or_default(), + .map(|quantity| MemoryResourceRequirements { + quantity: Some(quantity), + }), gpu: gpu_requirements, }) } else { @@ -2802,6 +2726,7 @@ pub async fn sandbox_template_create( image: image.unwrap_or_default().to_string(), environment, resources, + ..Default::default() }), driver_config, desired_service_level, @@ -3038,12 +2963,17 @@ 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!({ "quantity": cpu.quantity }), + ); } - 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!({ "quantity": memory.quantity }), + ); } if let Some(gpu) = &resources.gpu { let value = gpu @@ -3140,12 +3070,20 @@ fn print_sandbox_template_detail(template: &SandboxWorkloadTemplate) { println!( " {} {}", "CPU:".dimmed(), - non_empty_or(&resources.cpu, "") + resources + .cpu + .as_ref() + .and_then(|cpu| cpu.quantity.as_deref()) + .map_or("", |value| non_empty_or(value, "")) ); println!( " {} {}", "Memory:".dimmed(), - non_empty_or(&resources.memory, "") + resources + .memory + .as_ref() + .and_then(|memory| memory.quantity.as_deref()) + .map_or("", |value| non_empty_or(value, "")) ); println!( " {} {}", @@ -3229,11 +3167,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()) + .and_then(|cpu| cpu.quantity.as_deref()) .filter(|cpu| !cpu.is_empty()) .unwrap_or("-"); let memory = resources - .map(|resources| resources.memory.as_str()) + .and_then(|resources| resources.memory.as_ref()) + .and_then(|memory| memory.quantity.as_deref()) .filter(|memory| !memory.is_empty()) .unwrap_or("-"); let gpu = resources @@ -3293,7 +3233,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() @@ -3301,7 +3241,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 @@ -6220,7 +6160,8 @@ fn format_endpoint(endpoint: &openshell_core::proto::NetworkEndpoint) -> String #[cfg(test)] mod tests { use super::{ - PolicyGetView, ProvisioningStep, build_sandbox_resource_limits, format_endpoint, + PolicyGetView, ProvisioningStep, build_cpu_resource_requirements, + build_memory_resource_requirements, build_sandbox_resource_limits, 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, @@ -6259,10 +6200,10 @@ mod tests { use openshell_core::proto::{ EndpointResult, EndpointStatus, GetSandboxConfigResponse, GpuResourceRequirements, PolicySource, PolicyStatus, ResourceRequirements, Sandbox, SandboxCondition, SandboxPhase, - SandboxPolicy, SandboxPolicyRevision, SandboxResources, SandboxStatus, - SandboxWorkloadConfig, SandboxWorkloadTemplate, SandboxWorkloadTemplateProvenance, - SandboxWorkloadTemplateSpec, ServiceEndpoint, ServiceEndpointResponse, WorkspaceMember, - WorkspaceRole, datamodel::v1::ObjectMeta, + SandboxPolicy, SandboxPolicyRevision, SandboxStatus, SandboxWorkloadConfig, + SandboxWorkloadTemplate, SandboxWorkloadTemplateProvenance, SandboxWorkloadTemplateSpec, + ServiceEndpoint, ServiceEndpointResponse, WorkspaceMember, WorkspaceRole, + datamodel::v1::ObjectMeta, }; #[test] @@ -6597,52 +6538,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.quantity.as_deref(), Some("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.quantity.as_deref(), Some("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] @@ -7158,6 +7076,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, @@ -7179,7 +7099,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"); @@ -7418,7 +7342,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() }), @@ -7439,7 +7363,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 033bd2479e..911c4a8008 100644 --- a/crates/openshell-cli/tests/sandbox_create_lifecycle_integration.rs +++ b/crates/openshell-cli/tests/sandbox_create_lifecycle_integration.rs @@ -24,11 +24,11 @@ use openshell_core::proto::{ ListProvidersResponse, ListSandboxProvidersRequest, ListSandboxProvidersResponse, ListSandboxTemplatesRequest, ListSandboxTemplatesResponse, ListSandboxesRequest, ListSandboxesResponse, PlatformEvent, Provider, ProviderResponse, ReportEndpointStatusRequest, - ReportEndpointStatusResponse, RevokeSshSessionRequest, RevokeSshSessionResponse, Sandbox, - SandboxCondition, SandboxLogLine, SandboxPhase, SandboxResponse, SandboxStatus, - SandboxStreamEvent, SandboxTemplateResponse, SandboxWorkloadTemplate, ServiceStatus, - SettingValue, SupervisorMessage, UpdateProviderRequest, WatchSandboxRequest, - sandbox_stream_event, + ReportEndpointStatusResponse, ResourceRequirements, RevokeSshSessionRequest, + RevokeSshSessionResponse, Sandbox, SandboxCondition, SandboxLogLine, SandboxPhase, + SandboxResponse, SandboxStatus, SandboxStreamEvent, SandboxTemplateResponse, + SandboxWorkloadTemplate, ServiceStatus, SettingValue, SupervisorMessage, UpdateProviderRequest, + WatchSandboxRequest, sandbox_stream_event, }; use std::collections::HashMap; use std::fs; @@ -1494,6 +1494,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 @@ -1653,7 +1661,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(); @@ -1666,8 +1674,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 { + quantity: Some("500m".to_string()), + }), + Some(openshell_core::proto::MemoryResourceRequirements { + quantity: Some("2Gi".to_string()), + }), + )), command: &["echo".into(), "OK".into()], ..test_config() }, @@ -1678,45 +1693,34 @@ 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() + .and_then(|cpu| cpu.quantity.as_deref()), 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() + .and_then(|memory| memory.quantity.as_deref()), 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] @@ -1984,8 +1988,20 @@ async fn sandbox_template_create_sends_non_default_workspace_in_scope_and_metada .resources .as_ref() .expect("resources should be sent"); - assert_eq!(resources.cpu, "2"); - assert_eq!(resources.memory, "4Gi"); + assert_eq!( + resources + .cpu + .as_ref() + .and_then(|cpu| cpu.quantity.as_deref()), + Some("2") + ); + assert_eq!( + resources + .memory + .as_ref() + .and_then(|memory| memory.quantity.as_deref()), + Some("4Gi") + ); assert_eq!(resources.gpu.as_ref().and_then(|gpu| gpu.count), Some(1)); assert!(spec.driver_config.is_some()); let startup = spec @@ -2107,7 +2123,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() }, @@ -2142,7 +2162,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 a0a317d412..30497efd57 100644 --- a/crates/openshell-core/src/lib.rs +++ b/crates/openshell-core/src/lib.rs @@ -44,6 +44,7 @@ pub mod proposals; pub mod proto; pub mod proto_struct; pub mod provider_credentials; +pub mod quantity; pub mod rpc_error; pub mod sandbox_env; pub mod sandbox_generation; diff --git a/crates/openshell-core/src/quantity.rs b/crates/openshell-core/src/quantity.rs new file mode 100644 index 0000000000..a102ea007d --- /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.quantity` 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 7fa57ed07f..cc75ddba5a 100644 --- a/crates/openshell-driver-docker/src/lib.rs +++ b/crates/openshell-driver-docker/src/lib.rs @@ -48,8 +48,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, @@ -1020,10 +1020,10 @@ impl DockerComputeDriver { driver_reports_runtime_readiness: false, resource_capabilities: Some(ResourceCapabilities { cpu: Some(CpuResourceCapabilities { - limit_supported: true, + quantity_supported: true, }), memory: Some(MemoryResourceCapabilities { - limit_supported: true, + quantity_supported: true, }), gpu: Some(GpuResourceCapabilities { default_selection_supported: self.config.gpu.cdi_supported, @@ -1058,7 +1058,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)?; @@ -5500,7 +5500,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, BOUNDARY_MOUNT_PATH) @@ -5912,26 +5912,26 @@ 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() + .and_then(|cpu| cpu.quantity.as_deref()) + .unwrap_or(""), + )?, + memory_bytes: parse_memory_limit( + resources + .memory + .as_ref() + .and_then(|memory| memory.quantity.as_deref()) + .unwrap_or(""), + )?, }) } @@ -6032,12 +6032,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.quantity '{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.quantity must be greater than zero", )); } return Ok(Some(millicores.saturating_mul(1_000_000))); @@ -6045,12 +6045,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.quantity '{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.quantity must be greater than zero", )); } @@ -6070,12 +6070,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.quantity '{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.quantity must be greater than zero", )); } @@ -6095,7 +6095,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.quantity suffix '{suffix}'", ))); } }; diff --git a/crates/openshell-driver-docker/src/tests.rs b/crates/openshell-driver-docker/src/tests.rs index a0f45f31b7..432441291d 100644 --- a/crates/openshell-driver-docker/src/tests.rs +++ b/crates/openshell-driver-docker/src/tests.rs @@ -17,9 +17,9 @@ use openshell_core::progress::{ PROGRESS_STEP_STARTING_SANDBOX, }; use openshell_core::proto::compute::v1::{ - DriverResourceRequirements, DriverSandboxSpec, DriverSandboxTemplate, - GetGatewayListenerRequirementsRequest, GpuResourceRequirements, ResourceRequirements, - WorkloadIdentityRequest, gateway_listener_requirement::Selector, + CpuResourceRequirements, DriverSandboxSpec, DriverSandboxTemplate, + GetGatewayListenerRequirementsRequest, GpuResourceRequirements, MemoryResourceRequirements, + ResourceRequirements, WorkloadIdentityRequest, gateway_listener_requirement::Selector, }; use std::fs; use std::net::{IpAddr, Ipv4Addr, SocketAddr}; @@ -116,6 +116,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(|quantity| CpuResourceRequirements { + quantity: Some(quantity.to_string()), + }), + memory: memory.map(|quantity| MemoryResourceRequirements { + quantity: Some(quantity.to_string()), + }), } } @@ -219,8 +233,10 @@ fn capabilities_report_static_resource_support() { let mut config = runtime_config(); let capabilities = test_driver_with_config(config.clone()).capabilities(); let resources = capabilities.resource_capabilities.unwrap(); - assert!(resources.cpu.unwrap().limit_supported); - assert!(resources.memory.unwrap().limit_supported); + let cpu = resources.cpu.unwrap(); + assert!(cpu.quantity_supported); + let memory = resources.memory.unwrap(); + assert!(memory.quantity_supported); let gpu = resources.gpu.unwrap(); assert!(!gpu.default_selection_supported); assert!(!gpu.count_selection_supported); @@ -1308,43 +1324,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 2cb44af1a9..82635c5f62 100644 --- a/crates/openshell-driver-kubernetes/src/driver.rs +++ b/crates/openshell-driver-kubernetes/src/driver.rs @@ -58,8 +58,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 openshell_isolation_interface::contract::ResolvedWorkloadIdentity; @@ -755,10 +755,10 @@ impl KubernetesComputeDriver { driver_reports_runtime_readiness: false, resource_capabilities: Some(ResourceCapabilities { cpu: Some(CpuResourceCapabilities { - limit_supported: true, + quantity_supported: true, }), memory: Some(MemoryResourceCapabilities { - limit_supported: true, + quantity_supported: true, }), gpu: Some(GpuResourceCapabilities { default_selection_supported: true, @@ -5787,7 +5787,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, &driver_config, inject_workspace, @@ -5820,7 +5820,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, &driver_config, inject_workspace, @@ -5842,12 +5842,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, &driver_config, inject_workspace, @@ -5862,12 +5866,37 @@ fn sandbox_template_to_k8s_with_gpu_requirements( spec_environment: &std::collections::HashMap, 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, + resource_requirements.as_ref(), + spec_environment, + &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, - gpu_requirements, + resource_requirements, spec_environment, &driver_config, inject_workspace, @@ -5877,12 +5906,13 @@ 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, 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 pod_labels = template .labels @@ -6016,7 +6046,11 @@ 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, + &driver_config.containers.agent.resources, + ) { container.insert("resources".to_string(), resources); } apply_agent_driver_resources(&mut container, &driver_config.containers.agent.resources); @@ -6146,16 +6180,19 @@ fn image_pull_secret_refs(secrets: &[String]) -> Vec { fn container_resources( template: &SandboxTemplate, - gpu_requirements: Option<&GpuResourceRequirements>, + resource_requirements: Option<&ResourceRequirements>, + driver_resources: &KubernetesContainerResourceConfig, ) -> 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() { @@ -6163,21 +6200,22 @@ 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() { + if let Some(quantity) = cpu.quantity.as_deref() { + apply("limits", "cpu", quantity); + if !driver_resources.requests.contains_key("cpu") { + apply("requests", "cpu", quantity); + } + } + } + if let Some(memory) = requirements.memory.as_ref() { + if let Some(quantity) = memory.quantity.as_deref() { + apply("limits", "memory", quantity); + if !driver_resources.requests.contains_key("memory") { + apply("requests", "memory", quantity); + } + } + } } if let Some(gpu) = gpu_requirements { @@ -6940,7 +6978,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, VecDeque}; @@ -8583,6 +8624,8 @@ mod tests { spec: Some(SandboxSpec { resource_requirements: Some(ResourceRequirements { gpu: Some(GpuResourceRequirements { count: Some(0) }), + cpu: None, + memory: None, }), ..SandboxSpec::default() }), @@ -9067,22 +9110,25 @@ 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_quantity() { + let template = SandboxTemplate::default(); + let resource_requirements = ResourceRequirements { + gpu: Some(GpuResourceRequirements { count: None }), + cpu: Some(CpuResourceRequirements { + quantity: Some("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(), + &driver_config, true, ¶ms, ) @@ -9094,22 +9140,23 @@ 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() + fn cpu_and_memory_quantities_are_mirrored_to_requests() { + let template = SandboxTemplate::default(); + let resource_requirements = ResourceRequirements { + gpu: None, + cpu: Some(CpuResourceRequirements { + quantity: Some("500m".to_string()), + }), + memory: Some(MemoryResourceRequirements { + quantity: Some("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, @@ -9123,6 +9170,152 @@ mod tests { assert_eq!(resources["requests"]["memory"], serde_json::json!("2Gi")); } + #[test] + fn driver_config_requests_are_independent_of_portable_quantities() { + let template = SandboxTemplate { + driver_config: Some(json_struct(serde_json::json!({ + "containers": { + "agent": { + "resources": { + "requests": { "cpu": "250m", "memory": "512Mi" } + } + } + } + }))), + ..SandboxTemplate::default() + }; + let resource_requirements = ResourceRequirements { + gpu: None, + cpu: Some(CpuResourceRequirements { + quantity: Some("1".to_string()), + }), + memory: Some(MemoryResourceRequirements { + quantity: Some("2Gi".to_string()), + }), + }; + + let pod_template = sandbox_template_to_k8s_with_resource_requirements( + &template, + Some(&resource_requirements), + &std::collections::HashMap::new(), + true, + &SandboxPodParams::default(), + ); + + let resources = &pod_template["spec"]["containers"][0]["resources"]; + assert_eq!(resources["limits"]["cpu"], serde_json::json!("1")); + assert_eq!(resources["limits"]["memory"], serde_json::json!("2Gi")); + assert_eq!(resources["requests"]["cpu"], serde_json::json!("250m")); + assert_eq!(resources["requests"]["memory"], serde_json::json!("512Mi")); + } + + #[test] + fn driver_config_requests_can_be_set_without_portable_quantities() { + let template = SandboxTemplate { + driver_config: Some(json_struct(serde_json::json!({ + "containers": { + "agent": { + "resources": { + "requests": { "cpu": "250m", "memory": "512Mi" } + } + } + } + }))), + ..SandboxTemplate::default() + }; + + let pod_template = sandbox_template_to_k8s_with_resource_requirements( + &template, + None, + &std::collections::HashMap::new(), + true, + &SandboxPodParams::default(), + ); + + let resources = &pod_template["spec"]["containers"][0]["resources"]; + assert!(resources.get("limits").is_none()); + assert_eq!(resources["requests"]["cpu"], serde_json::json!("250m")); + assert_eq!(resources["requests"]["memory"], serde_json::json!("512Mi")); + } + + #[test] + fn driver_config_requests_take_precedence_over_limit_fallback() { + let template = SandboxTemplate { + driver_config: Some(json_struct(serde_json::json!({ + "containers": { + "agent": { + "resources": { + "requests": { "cpu": "250m", "memory": "512Mi" } + } + } + } + }))), + ..SandboxTemplate::default() + }; + let resource_requirements = ResourceRequirements { + gpu: None, + cpu: Some(CpuResourceRequirements { + quantity: Some("1".to_string()), + }), + memory: Some(MemoryResourceRequirements { + quantity: Some("2Gi".to_string()), + }), + }; + + let pod_template = sandbox_template_to_k8s_with_resource_requirements( + &template, + Some(&resource_requirements), + &std::collections::HashMap::new(), + true, + &SandboxPodParams::default(), + ); + + let resources = &pod_template["spec"]["containers"][0]["resources"]; + assert_eq!(resources["limits"]["cpu"], serde_json::json!("1")); + assert_eq!(resources["limits"]["memory"], serde_json::json!("2Gi")); + assert_eq!(resources["requests"]["cpu"], serde_json::json!("250m")); + assert_eq!(resources["requests"]["memory"], serde_json::json!("512Mi")); + } + + #[test] + fn driver_config_requests_take_precedence_over_quantity_fallback() { + let template = SandboxTemplate { + driver_config: Some(json_struct(serde_json::json!({ + "containers": { + "agent": { + "resources": { + "requests": { "cpu": "250m", "memory": "512Mi" } + } + } + } + }))), + ..SandboxTemplate::default() + }; + let resource_requirements = ResourceRequirements { + gpu: None, + cpu: Some(CpuResourceRequirements { + quantity: Some("1".to_string()), + }), + memory: Some(MemoryResourceRequirements { + quantity: Some("2Gi".to_string()), + }), + }; + + let pod_template = sandbox_template_to_k8s_with_resource_requirements( + &template, + Some(&resource_requirements), + &std::collections::HashMap::new(), + true, + &SandboxPodParams::default(), + ); + + let resources = &pod_template["spec"]["containers"][0]["resources"]; + assert_eq!(resources["limits"]["cpu"], serde_json::json!("1")); + assert_eq!(resources["limits"]["memory"], serde_json::json!("2Gi")); + assert_eq!(resources["requests"]["cpu"], serde_json::json!("250m")); + assert_eq!(resources["requests"]["memory"], serde_json::json!("512Mi")); + } + // ----------------------------------------------------------------------- // Workspace persistence tests // ----------------------------------------------------------------------- @@ -10300,8 +10493,10 @@ mod tests { .unwrap() .resource_capabilities .unwrap(); - assert!(resources.cpu.unwrap().limit_supported); - assert!(resources.memory.unwrap().limit_supported); + let cpu = resources.cpu.unwrap(); + assert!(cpu.quantity_supported); + let memory = resources.memory.unwrap(); + assert!(memory.quantity_supported); let gpu = resources.gpu.unwrap(); assert!(gpu.default_selection_supported); assert!(gpu.count_selection_supported); diff --git a/crates/openshell-driver-mxc/src/driver.rs b/crates/openshell-driver-mxc/src/driver.rs index 708aa3ae90..498e4d15b2 100644 --- a/crates/openshell-driver-mxc/src/driver.rs +++ b/crates/openshell-driver-mxc/src/driver.rs @@ -477,6 +477,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 4f502da8bc..2595a9fa8b 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; @@ -643,32 +645,63 @@ 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()); - - 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); + .and_then(|s| s.resource_requirements.as_ref()); - 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); + 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); - ResourceLimits { + Ok(ResourceLimits { cpu: CpuLimits { quota: cpu_micros, period: DEFAULT_CPU_PERIOD, }, memory: MemoryLimits { limit: mem_bytes }, pids: podman_pids_limit(config.sandbox_pids_limit).map(|limit| PidsLimits { 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); + }; + let Some(quantity) = cpu.quantity.as_deref() else { + return Ok(None); + }; + parse_cpu_to_microseconds(quantity) + .map(Some) + .ok_or_else(|| { + ComputeDriverError::Precondition(format!( + "invalid podman cpu limit '{}'; expected positive cores or millicores", + quantity + )) + }) +} + +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); + }; + let Some(quantity) = memory.quantity.as_deref() else { + return Ok(None); + }; + parse_memory_to_bytes(quantity).map(Some).ok_or_else(|| { + ComputeDriverError::Precondition(format!( + "invalid podman memory limit '{}'; expected positive bytes or a Kubernetes-style quantity", + quantity + )) + }) } fn podman_pids_limit(value: Option) -> Option { @@ -1065,7 +1098,7 @@ fn build_base_spec( 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 @@ -1682,7 +1715,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(())); @@ -1829,6 +1865,8 @@ mod tests { fn gpu_resources(count: Option) -> ResourceRequirements { ResourceRequirements { gpu: Some(GpuResourceRequirements { count }), + cpu: None, + memory: None, } } @@ -1867,19 +1905,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 { + quantity: Some("500m".to_string()), + }), + memory: Some(MemoryResourceRequirements { + quantity: Some("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 32419fdf3e..8ed7372d9e 100644 --- a/crates/openshell-driver-podman/src/driver.rs +++ b/crates/openshell-driver-podman/src/driver.rs @@ -535,10 +535,10 @@ impl PodmanComputeDriver { driver_reports_runtime_readiness: false, resource_capabilities: Some(ResourceCapabilities { cpu: Some(CpuResourceCapabilities { - limit_supported: true, + quantity_supported: true, }), memory: Some(MemoryResourceCapabilities { - limit_supported: true, + quantity_supported: true, }), gpu: Some(GpuResourceCapabilities { default_selection_supported: true, @@ -1996,6 +1996,8 @@ mod tests { fn gpu_resources(count: Option) -> ResourceRequirements { ResourceRequirements { gpu: Some(GpuResourceRequirements { count }), + cpu: None, + memory: None, } } @@ -3835,8 +3837,10 @@ mod tests { .unwrap() .resource_capabilities .unwrap(); - assert!(resources.cpu.unwrap().limit_supported); - assert!(resources.memory.unwrap().limit_supported); + let cpu = resources.cpu.unwrap(); + assert!(cpu.quantity_supported); + let memory = resources.memory.unwrap(); + assert!(memory.quantity_supported); let gpu = resources.gpu.unwrap(); assert!(gpu.default_selection_supported); assert!(gpu.count_selection_supported); diff --git a/crates/openshell-driver-vm/src/driver.rs b/crates/openshell-driver-vm/src/driver.rs index 1ad10f654b..70b1165231 100644 --- a/crates/openshell-driver-vm/src/driver.rs +++ b/crates/openshell-driver-vm/src/driver.rs @@ -986,10 +986,10 @@ impl VmDriver { driver_reports_runtime_readiness: false, resource_capabilities: Some(ResourceCapabilities { cpu: Some(CpuResourceCapabilities { - limit_supported: false, + quantity_supported: false, }), memory: Some(MemoryResourceCapabilities { - limit_supported: false, + quantity_supported: false, }), gpu: Some(GpuResourceCapabilities { default_selection_supported: self.config.gpu_enabled, @@ -4445,6 +4445,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(()) @@ -4465,6 +4466,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 @@ -6900,8 +6917,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; @@ -7624,6 +7642,8 @@ mod tests { fn gpu_resources(count: Option) -> ResourceRequirements { ResourceRequirements { gpu: Some(GpuResourceRequirements { count }), + cpu: None, + memory: None, } } @@ -7995,26 +8015,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 { + quantity: Some("2".to_string()), + }), + memory: Some(MemoryResourceRequirements { + quantity: Some("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] @@ -10656,8 +10678,10 @@ mod tests { fn capabilities_report_static_resource_support() { let mut driver = test_driver_with_extensions(LifecycleExtensionRegistry::new()); let resources = driver.capabilities().resource_capabilities.unwrap(); - assert!(!resources.cpu.unwrap().limit_supported); - assert!(!resources.memory.unwrap().limit_supported); + let cpu = resources.cpu.unwrap(); + assert!(!cpu.quantity_supported); + let memory = resources.memory.unwrap(); + assert!(!memory.quantity_supported); let gpu = resources.gpu.unwrap(); assert!(!gpu.default_selection_supported); assert!(!gpu.count_selection_supported); diff --git a/crates/openshell-server/src/compute/mod.rs b/crates/openshell-server/src/compute/mod.rs index 9732999c31..7c4251ce10 100644 --- a/crates/openshell-server/src/compute/mod.rs +++ b/crates/openshell-server/src/compute/mod.rs @@ -22,14 +22,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, WorkloadIdentityRequest, compute_driver_client::ComputeDriverClient, @@ -4327,6 +4328,17 @@ fn driver_sandbox_spec_from_public( .gpu .as_ref() .map(|gpu| DriverGpuResourceRequirements { count: gpu.count }), + cpu: requirements + .cpu + .as_ref() + .map(|cpu| DriverCpuResourceRequirements { + quantity: cpu.quantity.clone(), + }), + memory: requirements.memory.as_ref().map(|memory| { + DriverMemoryResourceRequirements { + quantity: memory.quantity.clone(), + } + }), } }), sandbox_token: String::new(), @@ -4358,7 +4370,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, @@ -4453,50 +4464,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. @@ -4537,9 +4504,8 @@ fn build_platform_config(template: &SandboxTemplate) -> Option ResourceCapabilities { ResourceCapabilities { cpu: resources.cpu.as_ref().map(|cpu| CpuResourceCapabilities { - limit_supported: cpu.limit_supported, + quantity_supported: cpu.quantity_supported, }), memory: resources .memory .as_ref() .map(|memory| MemoryResourceCapabilities { - limit_supported: memory.limit_supported, + quantity_supported: memory.quantity_supported, }), gpu: resources.gpu.as_ref().map(|gpu| GpuResourceCapabilities { default_selection_supported: gpu.default_selection_supported, @@ -1033,10 +1033,10 @@ mod tests { fn public_resource_capabilities_preserves_reported_fields() { let driver_capabilities = DriverResourceCapabilities { cpu: Some(DriverCpuResourceCapabilities { - limit_supported: true, + quantity_supported: true, }), memory: Some(DriverMemoryResourceCapabilities { - limit_supported: false, + quantity_supported: false, }), gpu: Some(DriverGpuResourceCapabilities { default_selection_supported: true, @@ -1046,12 +1046,13 @@ mod tests { let capabilities = public_resource_capabilities(driver_capabilities); - assert!(capabilities.cpu.expect("CPU capabilities").limit_supported); + let cpu = capabilities.cpu.expect("CPU capabilities"); + assert!(cpu.quantity_supported); assert!( !capabilities .memory .expect("memory capabilities") - .limit_supported + .quantity_supported ); let gpu = capabilities.gpu.expect("GPU capabilities"); assert!(gpu.default_selection_supported); diff --git a/crates/openshell-server/src/grpc/sandbox.rs b/crates/openshell-server/src/grpc/sandbox.rs index a1342f4575..5bc7637a84 100644 --- a/crates/openshell-server/src/grpc/sandbox.rs +++ b/crates/openshell-server/src/grpc/sandbox.rs @@ -22,15 +22,16 @@ use futures::future; use openshell_core::net::set_tcp_nodelay_best_effort; use openshell_core::proto::datamodel::v1::ObjectMeta; use openshell_core::proto::{ - AttachSandboxProviderRequest, AttachSandboxProviderResponse, CreateSandboxRequest, - CreateSandboxTemplateRequest, CreateSshSessionRequest, CreateSshSessionResponse, - DeleteSandboxRequest, DeleteSandboxResponse, DeleteSandboxTemplateRequest, - DeleteSandboxTemplateResponse, DetachSandboxProviderRequest, DetachSandboxProviderResponse, - ExecSandboxEvent, ExecSandboxExit, ExecSandboxInput, ExecSandboxRequest, ExecSandboxStderr, - ExecSandboxStdout, GetSandboxRequest, GetSandboxTemplateRequest, ListSandboxProvidersRequest, + AttachSandboxProviderRequest, AttachSandboxProviderResponse, CpuResourceRequirements, + CreateSandboxRequest, CreateSandboxTemplateRequest, CreateSshSessionRequest, + CreateSshSessionResponse, DeleteSandboxRequest, DeleteSandboxResponse, + DeleteSandboxTemplateRequest, DeleteSandboxTemplateResponse, DetachSandboxProviderRequest, + DetachSandboxProviderResponse, ExecSandboxEvent, ExecSandboxExit, ExecSandboxInput, + ExecSandboxRequest, ExecSandboxStderr, ExecSandboxStdout, GetSandboxRequest, + GetSandboxTemplateRequest, LegacySandboxResources, ListSandboxProvidersRequest, ListSandboxProvidersResponse, ListSandboxTemplatesRequest, ListSandboxTemplatesResponse, - ListSandboxesRequest, ListSandboxesResponse, Provider, ProviderMutationKind, - ResourceRequirements, RevokeSshSessionRequest, RevokeSshSessionResponse, SandboxResources, + ListSandboxesRequest, ListSandboxesResponse, MemoryResourceRequirements, Provider, + ProviderMutationKind, ResourceRequirements, RevokeSshSessionRequest, RevokeSshSessionResponse, SandboxResponse, SandboxSpec, SandboxStreamEvent, SandboxTemplateResponse, SandboxWorkloadTemplate, SandboxWorkloadTemplateProvenance, SshRelayTarget, StartSandboxRequest, StopSandboxRequest, TcpForwardFrame, TcpForwardInit, TcpRelayTarget, @@ -45,7 +46,7 @@ use openshell_core::telemetry::{ }; use openshell_core::{GetResourceVersion, ObjectId, ObjectName, ObjectWorkspace}; use prost::Message; -use prost_types::{Struct, Value, value::Kind}; +use prost_types::value::Kind; use std::collections::HashMap; use std::net::IpAddr; use std::pin::Pin; @@ -645,7 +646,9 @@ fn validate_template_create_governance_spec(spec: &SandboxSpec) -> Result<(), St fn sandbox_spec_from_stored_workload_template( template: &SandboxWorkloadTemplate, ) -> Result { - sandbox_spec_from_workload_template(template, tonic::Code::Internal) + let mut template = template.clone(); + migrate_legacy_workload_template_resources(&mut template)?; + sandbox_spec_from_workload_template(&template, tonic::Code::Internal) } fn sandbox_spec_from_user_workload_template( @@ -666,56 +669,47 @@ fn sandbox_spec_from_workload_template( .workload .as_ref() .ok_or_else(|| Status::new(missing_field_code, "sandbox template workload is required"))?; - let resources = workload.resources.as_ref(); Ok(SandboxSpec { environment: workload.environment.clone(), template: Some(SandboxTemplate { image: workload.image.clone(), - resources: resources.and_then(template_resource_struct), driver_config: spec.driver_config.clone(), ..SandboxTemplate::default() }), - resource_requirements: resources.and_then(template_gpu_requirements), + resource_requirements: workload.resources.clone(), ..SandboxSpec::default() }) } -fn template_gpu_requirements(resources: &SandboxResources) -> 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 }) +#[allow(deprecated)] +fn migrate_legacy_workload_template_resources( + template: &mut SandboxWorkloadTemplate, +) -> Result<(), Status> { + let Some(workload) = template + .spec + .as_mut() + .and_then(|spec| spec.workload.as_mut()) + else { + return Ok(()); + }; + let Some(LegacySandboxResources { cpu, memory, gpu }) = workload.legacy_resources.take() else { + return Ok(()); + }; + if workload.resources.is_some() { + return Err(Status::internal( + "stored sandbox template contains both legacy and current resources", + )); } + workload.resources = Some(ResourceRequirements { + cpu: (!cpu.is_empty()).then_some(CpuResourceRequirements { + quantity: Some(cpu), + }), + memory: (!memory.is_empty()).then_some(MemoryResourceRequirements { + quantity: Some(memory), + }), + gpu, + }); + Ok(()) } pub(super) async fn handle_get_sandbox( @@ -919,12 +913,13 @@ pub(super) async fn handle_get_sandbox_template( let workspace = super::workspace::resolve_workspace(state.store.as_ref(), &authz.workspace) .await? .name; - let template = state + let mut template = state .store .get_message_by_name::(&workspace, &req.name) .await .map_err(|e| Status::internal(format!("fetch sandbox template failed: {e}")))? .ok_or_else(|| Status::not_found("sandbox template not found"))?; + migrate_legacy_workload_template_resources(&mut template)?; Ok(Response::new(SandboxTemplateResponse { template: Some(template), })) @@ -975,11 +970,14 @@ pub(super) async fn handle_list_sandbox_templates( label_selector: selector, }, }; - let page = state + let mut page = state .store .list_message_page::(query, after.as_ref(), pagination.page_size()) .await .map_err(|e| Status::internal(format!("list sandbox templates failed: {e}")))?; + for template in &mut page.messages { + migrate_legacy_workload_template_resources(template)?; + } let next_page_token = pagination.next_object_token(page.next_cursor.as_ref()); Ok(Response::new(ListSandboxTemplatesResponse { templates: page.messages, @@ -1021,11 +1019,22 @@ pub(super) async fn handle_delete_sandbox_template( })) } +#[allow(deprecated)] fn validate_sandbox_workload_template(template: &SandboxWorkloadTemplate) -> Result<(), Status> { super::validation::validate_object_metadata(template.metadata.as_ref(), "sandbox_template")?; let name = template.object_name().to_string(); validate_dns1123_label(&name, "template.metadata.name")?; validate_sandbox_workload_template_service_level(template)?; + if template + .spec + .as_ref() + .and_then(|spec| spec.workload.as_ref()) + .is_some_and(|workload| workload.legacy_resources.is_some()) + { + return Err(Status::invalid_argument( + "template.spec.workload.legacy_resources is read-only migration data", + )); + } let spec = sandbox_spec_from_user_workload_template(template)?; validate_sandbox_spec(&name, &spec)?; Ok(()) @@ -3320,8 +3329,74 @@ mod tests { use crate::grpc::test_support::{ authed_request, test_server_state, test_server_state_with_driver, }; - use openshell_core::proto::GpuResourceRequirements; use openshell_core::proto::datamodel::v1::ObjectMeta; + use openshell_core::proto::{GpuResourceRequirements, ResourceRequirements}; + + // Encoded with the pre-migration schema where SandboxWorkloadConfig field 3 + // was SandboxResources { cpu: "500m", memory: "512Mi", gpu: { count: 2 } }. + const LEGACY_WORKLOAD_TEMPLATE_FIXTURE: &[u8] = &[ + 0x12, 0x1a, 0x0a, 0x18, 0x0a, 0x03, 0x69, 0x6d, 0x67, 0x1a, 0x11, 0x0a, 0x04, 0x35, 0x30, + 0x30, 0x6d, 0x12, 0x05, 0x35, 0x31, 0x32, 0x4d, 0x69, 0x1a, 0x02, 0x08, 0x02, + ]; + + fn legacy_workload_template_fixture() -> SandboxWorkloadTemplate { + SandboxWorkloadTemplate::decode(LEGACY_WORKLOAD_TEMPLATE_FIXTURE) + .expect("legacy workload template fixture should decode") + } + + #[test] + #[allow(deprecated)] + fn legacy_workload_template_fixture_migrates_portable_resources() { + let mut template = legacy_workload_template_fixture(); + migrate_legacy_workload_template_resources(&mut template) + .expect("legacy resources should migrate"); + + let workload = template.spec.unwrap().workload.unwrap(); + assert!(workload.legacy_resources.is_none()); + let resources = workload.resources.expect("migrated resources"); + assert_eq!( + resources.cpu.and_then(|cpu| cpu.quantity), + Some("500m".to_string()) + ); + assert_eq!( + resources.memory.and_then(|memory| memory.quantity), + Some("512Mi".to_string()) + ); + assert_eq!(resources.gpu.and_then(|gpu| gpu.count), Some(2)); + } + + #[test] + #[allow(deprecated)] + fn new_template_write_rejects_legacy_resources() { + let template = SandboxWorkloadTemplate { + metadata: Some(ObjectMeta { + id: "legacy-write-id".to_string(), + name: "legacy-write".to_string(), + created_time: openshell_core::time::timestamp_from_millis(1_000).ok(), + resource_version: 1, + workspace: "default".to_string(), + ..Default::default() + }), + spec: Some(openshell_core::proto::SandboxWorkloadTemplateSpec { + workload: Some(openshell_core::proto::SandboxWorkloadConfig { + legacy_resources: Some(LegacySandboxResources { + cpu: "500m".to_string(), + ..Default::default() + }), + ..Default::default() + }), + ..Default::default() + }), + }; + + let error = validate_sandbox_workload_template(&template) + .expect_err("new legacy resource writes must be rejected"); + assert_eq!(error.code(), tonic::Code::InvalidArgument); + assert!( + error.message().contains("read-only migration data"), + "{error:?}" + ); + } // ---- shell_escape ---- @@ -3375,6 +3450,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() }), @@ -3778,11 +3855,16 @@ 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(CpuResourceRequirements { + quantity: Some("2".to_string()), + }), + memory: Some(MemoryResourceRequirements { + quantity: Some("4Gi".to_string()), + }), gpu: Some(GpuResourceRequirements { count: Some(1) }), }), + ..Default::default() }), driver_config: None, desired_service_level: None, @@ -3790,13 +3872,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() { @@ -5199,6 +5274,95 @@ mod tests { assert_eq!(missing.code(), tonic::Code::NotFound); } + #[tokio::test] + async fn stored_legacy_template_migrates_for_get_list_and_sandbox_create() { + let state = test_server_state().await; + let mut stored = legacy_workload_template_fixture(); + stored.metadata = Some(ObjectMeta { + id: "legacy-template-id".to_string(), + name: "legacy-template".to_string(), + workspace: "default".to_string(), + ..Default::default() + }); + state.store.put_message(&stored).await.unwrap(); + + let fetched = handle_get_sandbox_template( + &state, + authed_request(GetSandboxTemplateRequest { + name: "legacy-template".to_string(), + workspace_scope: Some(openshell_core::proto::workspace_selector("default")), + }), + ) + .await + .expect("legacy template get should succeed") + .into_inner() + .template + .expect("fetched template"); + let fetched_resources = fetched.spec.unwrap().workload.unwrap().resources.unwrap(); + assert_eq!( + fetched_resources + .cpu + .and_then(|cpu| cpu.quantity) + .as_deref(), + Some("500m") + ); + + let listed = handle_list_sandbox_templates( + &state, + authed_request(ListSandboxTemplatesRequest { + page_size: 100, + workspace_scope: Some(openshell_core::proto::workspace_selector("default")), + ..Default::default() + }), + ) + .await + .expect("legacy template list should succeed") + .into_inner() + .templates; + let listed_resources = listed[0] + .spec + .as_ref() + .unwrap() + .workload + .as_ref() + .unwrap() + .resources + .as_ref() + .unwrap(); + assert_eq!( + listed_resources + .memory + .as_ref() + .and_then(|memory| memory.quantity.as_deref()), + Some("512Mi") + ); + + let created = handle_create_sandbox( + &state, + authed_request(CreateSandboxRequest { + name: "legacy-sandbox".to_string(), + spec: Some(SandboxSpec::default()), + workspace_scope: Some(openshell_core::proto::workspace_selector("default")), + workload_template_name: "legacy-template".to_string(), + ..Default::default() + }), + ) + .await + .expect("sandbox create from legacy template should succeed") + .into_inner() + .sandbox + .expect("created sandbox"); + let created_resources = created.spec.unwrap().resource_requirements.unwrap(); + assert_eq!( + created_resources + .cpu + .and_then(|cpu| cpu.quantity) + .as_deref(), + Some("500m") + ); + assert_eq!(created_resources.gpu.and_then(|gpu| gpu.count), Some(2)); + } + #[tokio::test] async fn sandbox_template_list_filters_by_label_selector() { let state = test_server_state().await; @@ -5763,27 +5927,25 @@ 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() + .and_then(|cpu| cpu.quantity.as_deref()), + Some("2") ); assert_eq!( - spec.resource_requirements - .and_then(|requirements| requirements.gpu) - .and_then(|gpu| gpu.count), - Some(1) + requirements + .memory + .as_ref() + .and_then(|memory| memory.quantity.as_deref()), + Some("4Gi") ); + assert_eq!(requirements.gpu.and_then(|gpu| gpu.count), Some(1)); } #[tokio::test] diff --git a/crates/openshell-server/src/storage_proto.rs b/crates/openshell-server/src/storage_proto.rs index d7982e517c..20a5103cff 100644 --- a/crates/openshell-server/src/storage_proto.rs +++ b/crates/openshell-server/src/storage_proto.rs @@ -118,11 +118,11 @@ mod tests { const STORAGE_V1_SCHEMA_SHA256: &str = "d68401809d8cea445c35233ef32412bbd041cb2ac5acaf368a0d0bf74d2ddf17"; const PUBLIC_RPC_SCHEMA_SHA256: &str = - "f30e23cffedb97d9db96ab1efff5e0ec9dcf174cf113533c0378e7ac63ec6883"; + "ee8fe0b408ad9fac8b5c41052cf450aee63c820ec8538662f583807c9cdab104"; const DURABLE_SCHEMA_SHA256: &str = - "55e4d8f70de4ffe004e45f230b7fe9425c4e635848164a1b94232201745f8d51"; + "068016428c90b13cb6ebfce386c377f5c09273e9bbab90a68bbd07b81bc01166"; const PUBLIC_DURABLE_OVERLAP_SHA256: &str = - "a6e97fdde30c439ffaa03c2952a43033f8ea338fed6b1456ebe2d7d8af14e834"; + "8215dbe0a6173a9a128e0c97200ce496da25990454dac8bfc1eecb6ce7b92000"; // A persisted Sandbox without endpoint status retains its lifecycle fields; // the absent repeated field decodes empty and needs no database rewrite. const SANDBOX_WITHOUT_ENDPOINT_STATUS: &str = "0a1e0a0a73616e64626f782d6964120773616e64626f783a0764656661756c741a2b0a0773616e64626f782a0d0a05526561647912045472756530023807420d73757065727669736f722d6964"; @@ -570,9 +570,9 @@ mod tests { overlap_hash.as_str(), ), ( - (299, 24), - (92, 19), - (80, 19), + (301, 24), + (94, 19), + (82, 19), PUBLIC_RPC_SCHEMA_SHA256, DURABLE_SCHEMA_SHA256, PUBLIC_DURABLE_OVERLAP_SHA256 diff --git a/proto/compute_driver.proto b/proto/compute_driver.proto index 7147c7a6f6..29745c3571 100644 --- a/proto/compute_driver.proto +++ b/proto/compute_driver.proto @@ -122,13 +122,13 @@ message ResourceCapabilities { } message CpuResourceCapabilities { - // The driver accepts and enforces a portable CPU limit. - bool limit_supported = 1; + // The driver accepts a portable CPU quantity. + bool quantity_supported = 1; } message MemoryResourceCapabilities { - // The driver accepts and enforces a portable memory limit. - bool limit_supported = 1; + // The driver accepts a portable memory quantity. + bool quantity_supported = 1; } message GpuResourceCapabilities { @@ -260,6 +260,10 @@ message DriverFenceEvidence { 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. @@ -269,6 +273,18 @@ message GpuResourceRequirements { optional uint32 count = 1; } +// Driver CPU resource requirements. +message CpuResourceRequirements { + // Portable CPU quantity for the sandbox workload (e.g. "500m", "2"). + optional string quantity = 1; +} + +// Driver memory resource requirements. +message MemoryResourceRequirements { + // Portable memory quantity for the sandbox workload (e.g. "512Mi", "4Gi"). + optional string quantity = 1; +} + // Driver-owned runtime template consumed by the compute platform. // // This message describes the sandbox workload in backend-neutral terms. @@ -285,8 +301,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, @@ -300,22 +314,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 586b7d435f..485bb25d60 100644 --- a/proto/openshell.proto +++ b/proto/openshell.proto @@ -911,13 +911,13 @@ message ResourceCapabilities { } message CpuResourceCapabilities { - // The driver accepts and enforces a portable CPU limit. - bool limit_supported = 1; + // The driver accepts a portable CPU quantity. + bool quantity_supported = 1; } message MemoryResourceCapabilities { - // The driver accepts and enforces a portable memory limit. - bool limit_supported = 1; + // The driver accepts a portable memory quantity. + bool quantity_supported = 1; } message GpuResourceCapabilities { @@ -986,6 +986,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. @@ -995,6 +999,18 @@ message GpuResourceRequirements { optional uint32 count = 1; } +// Public CPU resource requirements. +message CpuResourceRequirements { + // Portable CPU quantity for the sandbox workload (e.g. "500m", "2"). + optional string quantity = 1; +} + +// Public memory resource requirements. +message MemoryResourceRequirements { + // Portable memory quantity for the sandbox workload (e.g. "512Mi", "4Gi"). + optional string quantity = 1; +} + // Historical inline compute template mapped onto compute-driver template inputs. // // Despite its name, this is not a reusable named sandbox template resource. It @@ -1014,7 +1030,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"; @@ -1058,18 +1075,19 @@ message SandboxWorkloadConfig { string image = 1; // Environment variables injected into the sandbox runtime. map environment = 2; + // Legacy resource requirements retained only to decode templates persisted + // before ResourceRequirements became the shared portable resource model. + LegacySandboxResources legacy_resources = 3 [deprecated = true]; // Portable resource requirements for sandboxes created from this workload. - SandboxResources resources = 3; + ResourceRequirements resources = 4; } -message SandboxResources { - // Portable CPU quantity, for example "500m" or "2". +// Legacy persisted resource shape. New API writes must not populate this +// message; the gateway converts it to ResourceRequirements when loading stored +// workload templates. +message LegacySandboxResources { 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; } From b85007b1199a029dc6ba087df4e9a04a374a0e1f 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 | 7 ++++--- crates/openshell-sdk/src/raw.rs | 2 +- crates/openshell-sdk/src/types.rs | 13 +++++++++++-- crates/openshell-sdk/tests/client_mock.rs | 13 +++++++++---- 5 files changed, 27 insertions(+), 10 deletions(-) diff --git a/crates/openshell-sdk/src/client.rs b/crates/openshell-sdk/src/client.rs index 473f34d625..619be0fda8 100644 --- a/crates/openshell-sdk/src/client.rs +++ b/crates/openshell-sdk/src/client.rs @@ -1185,6 +1185,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 { request_id: String::new(), diff --git a/crates/openshell-sdk/src/lib.rs b/crates/openshell-sdk/src/lib.rs index 78f7375f8b..9625cd58b8 100644 --- a/crates/openshell-sdk/src/lib.rs +++ b/crates/openshell-sdk/src/lib.rs @@ -50,9 +50,10 @@ pub use error::SdkError; pub use pagination::{Page, Pager}; pub use refresh::{Refresh, RefreshError, RefreshedToken, TokenSource}; pub use types::{ - DeleteOptions, DeletionOutcome, DeletionResult, ExecOptions, ExecResult, Health, ListOptions, - SandboxPhase, SandboxRef, SandboxResources, SandboxServiceLevel, SandboxSpec, SandboxStartup, - SandboxTemplateCreateSpec, SandboxTemplateListOptions, SandboxWorkloadConfig, + CpuResourceRequirements, DeleteOptions, DeletionOutcome, DeletionResult, 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 dd3b7b165b..f2e804103e 100644 --- a/crates/openshell-sdk/src/raw.rs +++ b/crates/openshell-sdk/src/raw.rs @@ -28,7 +28,7 @@ pub use openshell_core::proto::{ ListSandboxTemplatesRequest, ListSandboxesRequest, ListWorkspacesRequest, ProviderDesiredIdentity, ProviderMutationKind, ProviderMutationReceipt, ProviderReadinessObservation, ProviderReadinessReason, ProviderReadinessState, - ProviderReadinessStatus, Sandbox, SandboxPhase as ProtoSandboxPhase, SandboxResources, + ProviderReadinessStatus, ResourceRequirements, Sandbox, SandboxPhase as ProtoSandboxPhase, SandboxServiceLevel, SandboxSpec as ProtoSandboxSpec, SandboxStartup, SandboxTemplate, SandboxTemplateResponse, SandboxWorkloadConfig, SandboxWorkloadTemplate, SandboxWorkloadTemplateProvenance, SandboxWorkloadTemplateSpec, diff --git a/crates/openshell-sdk/src/types.rs b/crates/openshell-sdk/src/types.rs index 3937462d00..0cae8c1464 100644 --- a/crates/openshell-sdk/src/types.rs +++ b/crates/openshell-sdk/src/types.rs @@ -195,8 +195,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 34678e23e1..d8d556e269 100644 --- a/crates/openshell-sdk/tests/client_mock.rs +++ b/crates/openshell-sdk/tests/client_mock.rs @@ -147,11 +147,16 @@ 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 { + quantity: Some("1".to_string()), + }), + memory: Some(proto::MemoryResourceRequirements { + quantity: Some("512Mi".to_string()), + }), + ..Default::default() }), + ..Default::default() }), driver_config: None, desired_service_level: None, From 803fa815ddec9e4bdc63213a57c6cca971b4f3fa 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 +- sdk/go/openshell/v1/fake/sandbox_template.go | 13 +- .../v1/fake/sandbox_template_test.go | 57 +- .../openshell/v1/internal/converter/copy.go | 9 + .../v1/internal/converter/coverage_test.go | 15 +- .../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 | 2894 +++++++++-------- 14 files changed, 1762 insertions(+), 1564 deletions(-) diff --git a/sdk/go/openshell/v1/fake/sandbox.go b/sdk/go/openshell/v1/fake/sandbox.go index 0fa43a59d5..00311f1e17 100644 --- a/sdk/go/openshell/v1/fake/sandbox.go +++ b/sdk/go/openshell/v1/fake/sandbox.go @@ -50,14 +50,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 { @@ -397,7 +420,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 @@ -413,36 +436,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.go b/sdk/go/openshell/v1/fake/sandbox_template.go index 5e560246ac..02788e73ac 100644 --- a/sdk/go/openshell/v1/fake/sandbox_template.go +++ b/sdk/go/openshell/v1/fake/sandbox_template.go @@ -36,18 +36,7 @@ func copySandboxWorkloadTemplateSpec(spec types.SandboxWorkloadTemplateSpec) typ if spec.Workload != nil { workload := *spec.Workload workload.Environment = copyStringMap(spec.Workload.Environment) - if spec.Workload.Resources != nil { - resources := *spec.Workload.Resources - if spec.Workload.Resources.GPU != nil { - gpu := *spec.Workload.Resources.GPU - if spec.Workload.Resources.GPU.Count != nil { - count := *spec.Workload.Resources.GPU.Count - gpu.Count = &count - } - resources.GPU = &gpu - } - workload.Resources = &resources - } + workload.Resources = copyResourceRequirements(spec.Workload.Resources) spec.Workload = &workload } spec.DriverConfig = copyAnyMap(spec.DriverConfig) diff --git a/sdk/go/openshell/v1/fake/sandbox_template_test.go b/sdk/go/openshell/v1/fake/sandbox_template_test.go index 3034895055..adb8680426 100644 --- a/sdk/go/openshell/v1/fake/sandbox_template_test.go +++ b/sdk/go/openshell/v1/fake/sandbox_template_test.go @@ -212,10 +212,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{Quantity: "2"}, + Memory: &types.MemoryResourceRequirements{Quantity: "4Gi"}, + GPU: &types.GPUResourceRequirements{Count: &gpuCount}, }, }, DriverConfig: map[string]any{ @@ -242,11 +242,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.Quantity) + require.NotNil(t, created.Spec.ResourceRequirements.Memory) + assert.Equal(t, "4Gi", created.Spec.ResourceRequirements.Memory.Quantity) + 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) @@ -276,11 +281,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}, + }, }, } @@ -306,8 +310,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{}, }, }, }, @@ -333,8 +337,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{}, }, }, }, @@ -350,8 +354,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) { @@ -364,6 +369,10 @@ func TestSandboxTemplate_DeepCopy(t *testing.T) { Workload: &types.SandboxWorkloadConfig{ Image: "python:3.12", Environment: map[string]string{"KEY": "value"}, + Resources: &types.ResourceRequirements{ + CPU: &types.CPUResourceRequirements{Quantity: "500m"}, + Memory: &types.MemoryResourceRequirements{Quantity: "512Mi"}, + }, }, DriverConfig: map[string]any{"kubernetes": map[string]any{"runtime_class_name": "kata"}}, }, @@ -374,13 +383,19 @@ func TestSandboxTemplate_DeepCopy(t *testing.T) { template.Spec.Workload.Image = "mutated" template.Spec.Workload.Environment["KEY"] = "mutated" + template.Spec.Workload.Resources.CPU.Quantity = "8" + template.Spec.Workload.Resources.Memory.Quantity = "16Gi" template.Spec.DriverConfig["kubernetes"].(map[string]any)["runtime_class_name"] = "mutated" created.Spec.Workload.Image = "mutated-return" + created.Spec.Workload.Resources.CPU.Quantity = "4" + created.Spec.Workload.Resources.Memory.Quantity = "8Gi" got, err := tc.Get(ctx, "default", "gpu-kata") require.NoError(t, err) assert.Equal(t, "python:3.12", got.Spec.Workload.Image) assert.Equal(t, "value", got.Spec.Workload.Environment["KEY"]) + assert.Equal(t, "500m", got.Spec.Workload.Resources.CPU.Quantity) + assert.Equal(t, "512Mi", got.Spec.Workload.Resources.Memory.Quantity) assert.Equal(t, "kata", got.Spec.DriverConfig["kubernetes"].(map[string]any)["runtime_class_name"]) } @@ -436,8 +451,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/copy.go b/sdk/go/openshell/v1/internal/converter/copy.go index dc98588fdd..2a5b4662d7 100644 --- a/sdk/go/openshell/v1/internal/converter/copy.go +++ b/sdk/go/openshell/v1/internal/converter/copy.go @@ -26,6 +26,15 @@ func CopyBoolPtr(p *bool) *bool { return &v } +// StringPtr returns a pointer to value unless it is empty. Empty resource +// quantities are invalid, so use nil to preserve optional-field presence. +func StringPtr(value string) *string { + if value == "" { + return nil + } + return &value +} + // CopyInt32Ptr returns a copy of an *int32 pointer. func CopyInt32Ptr(p *int32) *int32 { if p == nil { diff --git a/sdk/go/openshell/v1/internal/converter/coverage_test.go b/sdk/go/openshell/v1/internal/converter/coverage_test.go index 37ceeb92c0..317ebabdc9 100644 --- a/sdk/go/openshell/v1/internal/converter/coverage_test.go +++ b/sdk/go/openshell/v1/internal/converter/coverage_test.go @@ -82,18 +82,11 @@ func TestConverterCoversAllProtoFields_SandboxWorkloadConfig(t *testing.T) { "environment": true, "resources": true, } + // The gateway alone decodes this deprecated persistence migration field; + // curated SDK callers cannot read or write it. + skipped := fieldSet{"legacy_resources": true} - 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) + assertAllFieldsCovered(t, (&pb.SandboxWorkloadConfig{}).ProtoReflect().Descriptor(), handled, skipped) } func TestConverterCoversAllProtoFields_SandboxServiceLevel(t *testing.T) { diff --git a/sdk/go/openshell/v1/internal/converter/sandbox.go b/sdk/go/openshell/v1/internal/converter/sandbox.go index 2db7002b73..3e35ed0382 100644 --- a/sdk/go/openshell/v1/internal/converter/sandbox.go +++ b/sdk/go/openshell/v1/internal/converter/sandbox.go @@ -82,12 +82,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() @@ -95,6 +90,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{Quantity: cpu.GetQuantity()} + } + if mem := rr.GetMemory(); mem != nil { + result.Memory = &types.MemoryResourceRequirements{Quantity: mem.GetQuantity()} + } + return result +} + func sandboxStatusFromProto(status *pb.SandboxStatus) types.SandboxStatus { result := types.SandboxStatus{ SandboxName: status.GetSandboxName(), @@ -283,12 +297,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) @@ -297,6 +307,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{Quantity: StringPtr(rr.CPU.Quantity)} + } + if rr.Memory != nil { + result.Memory = &pb.MemoryResourceRequirements{Quantity: StringPtr(rr.Memory.Quantity)} + } + 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) { @@ -374,19 +403,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()), } } @@ -456,34 +473,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 81dc260cf8..eef18c6890 100644 --- a/sdk/go/openshell/v1/internal/converter/sandbox_test.go +++ b/sdk/go/openshell/v1/internal/converter/sandbox_test.go @@ -86,6 +86,8 @@ func TestSandboxFromProto(t *testing.T) { Gpu: &pb.GpuResourceRequirements{ Count: &gpuCount, }, + Cpu: &pb.CpuResourceRequirements{Quantity: proto.String("500m")}, + Memory: &pb.MemoryResourceRequirements{Quantity: proto.String("2Gi")}, }, Command: []string{"/opt/agent", "--serve"}, Tty: false, @@ -135,9 +137,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.Quantity) + require.NotNil(t, s.Spec.ResourceRequirements.Memory) + assert.Equal(t, "2Gi", s.Spec.ResourceRequirements.Memory.Quantity) assert.Equal(t, []string{"/opt/agent", "--serve"}, s.Spec.Command) assert.False(t, s.Spec.TTY) @@ -279,8 +286,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) } @@ -296,8 +302,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) { @@ -376,9 +383,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{Quantity: "1"}, + Memory: &v1.MemoryResourceRequirements{Quantity: "4Gi"}, + }, + Command: []string{"/opt/agent", "--serve"}, + TTY: false, }, } @@ -405,6 +416,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.GetQuantity()) + require.NotNil(t, p.Spec.ResourceRequirements.Memory) + assert.Equal(t, "4Gi", p.Spec.ResourceRequirements.Memory.GetQuantity()) require.NotNil(t, p.Spec.Template) assert.Equal(t, "img:v1", p.Spec.Template.Image) @@ -440,7 +455,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{}, + }, }, } @@ -469,10 +486,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{Quantity: "2"}, + Memory: &v1.MemoryResourceRequirements{Quantity: "8Gi"}, + GPU: &v1.GPUResourceRequirements{Count: &gpuCount}, }, }, DriverConfig: map[string]any{ @@ -497,8 +514,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.GetQuantity()) + require.NotNil(t, protoTemplate.Spec.Workload.Resources.Memory) + assert.Equal(t, "8Gi", protoTemplate.Spec.Workload.Resources.Memory.GetQuantity()) 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) @@ -540,8 +559,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{}, }, }, }, @@ -589,7 +608,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{Quantity: "2"}, + Memory: &v1.MemoryResourceRequirements{Quantity: "8Gi"}, + }, Policy: &v1.SandboxPolicy{ Version: 3, Filesystem: &v1.FilesystemPolicy{ @@ -638,9 +661,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.Quantity, back.Spec.ResourceRequirements.CPU.Quantity) + require.NotNil(t, back.Spec.ResourceRequirements.Memory) + assert.Equal(t, original.Spec.ResourceRequirements.Memory.Quantity, back.Spec.ResourceRequirements.Memory.Quantity) require.NotNil(t, back.Spec.Template) assert.Equal(t, original.Spec.Template.Image, back.Spec.Template.Image) require.NotNil(t, back.Spec.Template.UserNamespaces) @@ -711,7 +739,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{Quantity: "500m"}, + Memory: &v1.MemoryResourceRequirements{Quantity: "1Gi"}, + }, Policy: &v1.SandboxPolicy{ Version: 2, Filesystem: &v1.FilesystemPolicy{ @@ -728,6 +760,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.GetQuantity()) + assert.Equal(t, "1Gi", p.ResourceRequirements.Memory.GetQuantity()) 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 89ba2859d7..a38113c448 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 quantity for a sandbox. +type CPUResourceRequirements = types.CPUResourceRequirements + +// MemoryResourceRequirements holds a portable memory quantity 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 bf6e482472..b5409bbf38 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 285cdc0ef0..dcf5688189 100644 --- a/sdk/go/openshell/v1/sandbox_client_test.go +++ b/sdk/go/openshell/v1/sandbox_client_test.go @@ -297,13 +297,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() @@ -335,7 +338,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 52cb4f2784..4a3e94c882 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 8d745344e2..1958708de4 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{Quantity: "2"}, + Memory: &MemoryResourceRequirements{Quantity: "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.GetWorkspaceScope().GetWorkspace()) 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.GetQuantity()) + require.NotNil(t, mock.createRequest.Template.Spec.Workload.Resources.Memory) + assert.Equal(t, "8Gi", mock.createRequest.Template.Spec.Workload.Resources.Memory.GetQuantity()) 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 8d9436979d..1604c05a73 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 { + // Quantity is the portable CPU quantity for the sandbox workload, using a + // Kubernetes-style CPU quantity string such as "500m", "1", or "2.5". + Quantity string +} + +// MemoryResourceRequirements holds memory resource requirements for a sandbox. +type MemoryResourceRequirements struct { + // Quantity is the portable memory quantity for the sandbox workload, using a + // Kubernetes-style memory quantity string such as "512Mi", "4Gi", or "8G". + Quantity 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 319344a845..3d28e60cac 100644 --- a/sdk/go/proto/openshellv1/openshell.pb.go +++ b/sdk/go/proto/openshellv1/openshell.pb.go @@ -1832,10 +1832,10 @@ func (x *ResourceCapabilities) GetGpu() *GpuResourceCapabilities { type CpuResourceCapabilities struct { state protoimpl.MessageState `protogen:"open.v1"` - // The driver accepts and enforces a portable CPU limit. - LimitSupported bool `protobuf:"varint,1,opt,name=limit_supported,json=limitSupported,proto3" json:"limit_supported,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache + // The driver accepts a portable CPU quantity. + QuantitySupported bool `protobuf:"varint,1,opt,name=quantity_supported,json=quantitySupported,proto3" json:"quantity_supported,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *CpuResourceCapabilities) Reset() { @@ -1868,19 +1868,19 @@ func (*CpuResourceCapabilities) Descriptor() ([]byte, []int) { return file_openshell_proto_rawDescGZIP(), []int{13} } -func (x *CpuResourceCapabilities) GetLimitSupported() bool { +func (x *CpuResourceCapabilities) GetQuantitySupported() bool { if x != nil { - return x.LimitSupported + return x.QuantitySupported } return false } type MemoryResourceCapabilities struct { state protoimpl.MessageState `protogen:"open.v1"` - // The driver accepts and enforces a portable memory limit. - LimitSupported bool `protobuf:"varint,1,opt,name=limit_supported,json=limitSupported,proto3" json:"limit_supported,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache + // The driver accepts a portable memory quantity. + QuantitySupported bool `protobuf:"varint,1,opt,name=quantity_supported,json=quantitySupported,proto3" json:"quantity_supported,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *MemoryResourceCapabilities) Reset() { @@ -1913,9 +1913,9 @@ func (*MemoryResourceCapabilities) Descriptor() ([]byte, []int) { return file_openshell_proto_rawDescGZIP(), []int{14} } -func (x *MemoryResourceCapabilities) GetLimitSupported() bool { +func (x *MemoryResourceCapabilities) GetQuantitySupported() bool { if x != nil { - return x.LimitSupported + return x.QuantitySupported } return false } @@ -2179,7 +2179,11 @@ func (x *SandboxSpec) GetProviderAttachmentEpoch() string { 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 } @@ -2221,6 +2225,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"` @@ -2268,6 +2286,98 @@ func (x *GpuResourceRequirements) GetCount() uint32 { return 0 } +// Public CPU resource requirements. +type CpuResourceRequirements struct { + state protoimpl.MessageState `protogen:"open.v1"` + // Portable CPU quantity for the sandbox workload (e.g. "500m", "2"). + Quantity *string `protobuf:"bytes,1,opt,name=quantity,proto3,oneof" json:"quantity,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) GetQuantity() string { + if x != nil && x.Quantity != nil { + return *x.Quantity + } + return "" +} + +// Public memory resource requirements. +type MemoryResourceRequirements struct { + state protoimpl.MessageState `protogen:"open.v1"` + // Portable memory quantity for the sandbox workload (e.g. "512Mi", "4Gi"). + Quantity *string `protobuf:"bytes,1,opt,name=quantity,proto3,oneof" json:"quantity,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) GetQuantity() string { + if x != nil && x.Quantity != nil { + return *x.Quantity + } + return "" +} + // Historical inline compute template mapped onto compute-driver template inputs. // // Despite its name, this is not a reusable named sandbox template resource. It @@ -2288,7 +2398,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 @@ -2307,7 +2418,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) } @@ -2319,7 +2430,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 { @@ -2332,7 +2443,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 { @@ -2416,7 +2527,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) } @@ -2428,7 +2539,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 { @@ -2441,7 +2552,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 { @@ -2472,7 +2583,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) } @@ -2484,7 +2595,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 { @@ -2497,7 +2608,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 { @@ -2527,15 +2638,20 @@ type SandboxWorkloadConfig struct { Image string `protobuf:"bytes,1,opt,name=image,proto3" json:"image,omitempty"` // 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"` + // Legacy resource requirements retained only to decode templates persisted + // before ResourceRequirements became the shared portable resource model. + // + // Deprecated: Marked as deprecated in openshell.proto. + LegacyResources *LegacySandboxResources `protobuf:"bytes,3,opt,name=legacy_resources,json=legacyResources,proto3" json:"legacy_resources,omitempty"` // 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,4,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) } @@ -2547,7 +2663,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 { @@ -2560,7 +2676,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 { @@ -2577,42 +2693,48 @@ func (x *SandboxWorkloadConfig) GetEnvironment() map[string]string { return nil } -func (x *SandboxWorkloadConfig) GetResources() *SandboxResources { +// Deprecated: Marked as deprecated in openshell.proto. +func (x *SandboxWorkloadConfig) GetLegacyResources() *LegacySandboxResources { + if x != nil { + return x.LegacyResources + } + return nil +} + +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. +// Legacy persisted resource shape. New API writes must not populate this +// message; the gateway converts it to ResourceRequirements when loading stored +// workload templates. +type LegacySandboxResources struct { + state protoimpl.MessageState `protogen:"open.v1"` + Cpu string `protobuf:"bytes,1,opt,name=cpu,proto3" json:"cpu,omitempty"` + Memory string `protobuf:"bytes,2,opt,name=memory,proto3" json:"memory,omitempty"` 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] +func (x *LegacySandboxResources) Reset() { + *x = LegacySandboxResources{} + mi := &file_openshell_proto_msgTypes[26] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *SandboxResources) String() string { +func (x *LegacySandboxResources) String() string { return protoimpl.X.MessageStringOf(x) } -func (*SandboxResources) ProtoMessage() {} +func (*LegacySandboxResources) ProtoMessage() {} -func (x *SandboxResources) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[24] +func (x *LegacySandboxResources) ProtoReflect() protoreflect.Message { + mi := &file_openshell_proto_msgTypes[26] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2623,26 +2745,26 @@ func (x *SandboxResources) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use SandboxResources.ProtoReflect.Descriptor instead. -func (*SandboxResources) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{24} +// Deprecated: Use LegacySandboxResources.ProtoReflect.Descriptor instead. +func (*LegacySandboxResources) Descriptor() ([]byte, []int) { + return file_openshell_proto_rawDescGZIP(), []int{26} } -func (x *SandboxResources) GetCpu() string { +func (x *LegacySandboxResources) GetCpu() string { if x != nil { return x.Cpu } return "" } -func (x *SandboxResources) GetMemory() string { +func (x *LegacySandboxResources) GetMemory() string { if x != nil { return x.Memory } return "" } -func (x *SandboxResources) GetGpu() *GpuResourceRequirements { +func (x *LegacySandboxResources) GetGpu() *GpuResourceRequirements { if x != nil { return x.Gpu } @@ -2658,7 +2780,7 @@ type SandboxServiceLevel struct { func (x *SandboxServiceLevel) Reset() { *x = SandboxServiceLevel{} - mi := &file_openshell_proto_msgTypes[25] + mi := &file_openshell_proto_msgTypes[27] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2670,7 +2792,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[27] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2683,7 +2805,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{27} } func (x *SandboxServiceLevel) GetStartup() *SandboxStartup { @@ -2703,7 +2825,7 @@ type SandboxStartup struct { func (x *SandboxStartup) Reset() { *x = SandboxStartup{} - mi := &file_openshell_proto_msgTypes[26] + mi := &file_openshell_proto_msgTypes[28] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2715,7 +2837,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[28] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2728,7 +2850,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{28} } func (x *SandboxStartup) GetReadyWithin() *durationpb.Duration { @@ -2755,7 +2877,7 @@ type SandboxWorkloadTemplateProvenance struct { func (x *SandboxWorkloadTemplateProvenance) Reset() { *x = SandboxWorkloadTemplateProvenance{} - mi := &file_openshell_proto_msgTypes[27] + mi := &file_openshell_proto_msgTypes[29] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2767,7 +2889,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[29] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2780,7 +2902,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{29} } func (x *SandboxWorkloadTemplateProvenance) GetName() string { @@ -2839,7 +2961,7 @@ type SandboxStatus struct { func (x *SandboxStatus) Reset() { *x = SandboxStatus{} - mi := &file_openshell_proto_msgTypes[28] + mi := &file_openshell_proto_msgTypes[30] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2851,7 +2973,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[30] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2864,7 +2986,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{30} } func (x *SandboxStatus) GetSandboxName() string { @@ -2977,7 +3099,7 @@ type SandboxCondition struct { func (x *SandboxCondition) Reset() { *x = SandboxCondition{} - mi := &file_openshell_proto_msgTypes[29] + mi := &file_openshell_proto_msgTypes[31] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2989,7 +3111,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[31] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3002,7 +3124,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{31} } func (x *SandboxCondition) GetType() string { @@ -3061,7 +3183,7 @@ type PlatformEvent struct { func (x *PlatformEvent) Reset() { *x = PlatformEvent{} - mi := &file_openshell_proto_msgTypes[30] + mi := &file_openshell_proto_msgTypes[32] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3073,7 +3195,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[32] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3086,7 +3208,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{32} } func (x *PlatformEvent) GetEventTime() *timestamppb.Timestamp { @@ -3158,7 +3280,7 @@ type CreateSandboxRequest struct { func (x *CreateSandboxRequest) Reset() { *x = CreateSandboxRequest{} - mi := &file_openshell_proto_msgTypes[31] + mi := &file_openshell_proto_msgTypes[33] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3170,7 +3292,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[33] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3183,7 +3305,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{33} } func (x *CreateSandboxRequest) GetSpec() *SandboxSpec { @@ -3256,7 +3378,7 @@ type CreateSandboxTemplateRequest struct { func (x *CreateSandboxTemplateRequest) Reset() { *x = CreateSandboxTemplateRequest{} - mi := &file_openshell_proto_msgTypes[32] + mi := &file_openshell_proto_msgTypes[34] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3268,7 +3390,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[34] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3281,7 +3403,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{34} } func (x *CreateSandboxTemplateRequest) GetTemplate() *SandboxWorkloadTemplate { @@ -3316,7 +3438,7 @@ type GetSandboxTemplateRequest struct { func (x *GetSandboxTemplateRequest) Reset() { *x = GetSandboxTemplateRequest{} - mi := &file_openshell_proto_msgTypes[33] + mi := &file_openshell_proto_msgTypes[35] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3328,7 +3450,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[35] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3341,7 +3463,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{35} } func (x *GetSandboxTemplateRequest) GetName() string { @@ -3376,7 +3498,7 @@ type ListSandboxTemplatesRequest struct { func (x *ListSandboxTemplatesRequest) Reset() { *x = ListSandboxTemplatesRequest{} - mi := &file_openshell_proto_msgTypes[34] + mi := &file_openshell_proto_msgTypes[36] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3388,7 +3510,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[36] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3401,7 +3523,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{36} } func (x *ListSandboxTemplatesRequest) GetPageSize() int32 { @@ -3448,7 +3570,7 @@ type DeleteSandboxTemplateRequest struct { func (x *DeleteSandboxTemplateRequest) Reset() { *x = DeleteSandboxTemplateRequest{} - mi := &file_openshell_proto_msgTypes[35] + mi := &file_openshell_proto_msgTypes[37] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3460,7 +3582,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[37] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3473,7 +3595,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{37} } func (x *DeleteSandboxTemplateRequest) GetName() string { @@ -3513,7 +3635,7 @@ type SandboxTemplateResponse struct { func (x *SandboxTemplateResponse) Reset() { *x = SandboxTemplateResponse{} - mi := &file_openshell_proto_msgTypes[36] + mi := &file_openshell_proto_msgTypes[38] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3525,7 +3647,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[38] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3538,7 +3660,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{38} } func (x *SandboxTemplateResponse) GetTemplate() *SandboxWorkloadTemplate { @@ -3559,7 +3681,7 @@ type ListSandboxTemplatesResponse struct { func (x *ListSandboxTemplatesResponse) Reset() { *x = ListSandboxTemplatesResponse{} - mi := &file_openshell_proto_msgTypes[37] + mi := &file_openshell_proto_msgTypes[39] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3571,7 +3693,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[39] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3584,7 +3706,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{39} } func (x *ListSandboxTemplatesResponse) GetTemplates() []*SandboxWorkloadTemplate { @@ -3610,7 +3732,7 @@ type DeleteSandboxTemplateResponse struct { func (x *DeleteSandboxTemplateResponse) Reset() { *x = DeleteSandboxTemplateResponse{} - mi := &file_openshell_proto_msgTypes[38] + mi := &file_openshell_proto_msgTypes[40] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3622,7 +3744,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[40] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3635,7 +3757,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{40} } func (x *DeleteSandboxTemplateResponse) GetOutcome() DeletionOutcome { @@ -3663,7 +3785,7 @@ type BeginRootfsTarStagingRequest struct { func (x *BeginRootfsTarStagingRequest) Reset() { *x = BeginRootfsTarStagingRequest{} - mi := &file_openshell_proto_msgTypes[39] + mi := &file_openshell_proto_msgTypes[41] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3675,7 +3797,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[41] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3688,7 +3810,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{41} } func (x *BeginRootfsTarStagingRequest) GetFileName() string { @@ -3731,7 +3853,7 @@ type BeginRootfsTarStagingResponse struct { func (x *BeginRootfsTarStagingResponse) Reset() { *x = BeginRootfsTarStagingResponse{} - mi := &file_openshell_proto_msgTypes[40] + mi := &file_openshell_proto_msgTypes[42] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3743,7 +3865,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[42] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3756,7 +3878,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{42} } func (x *BeginRootfsTarStagingResponse) GetStagingToken() string { @@ -3800,7 +3922,7 @@ type GetSandboxRequest struct { func (x *GetSandboxRequest) Reset() { *x = GetSandboxRequest{} - mi := &file_openshell_proto_msgTypes[41] + mi := &file_openshell_proto_msgTypes[43] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3812,7 +3934,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[43] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3825,7 +3947,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{43} } func (x *GetSandboxRequest) GetName() string { @@ -3861,7 +3983,7 @@ type ListSandboxesRequest struct { func (x *ListSandboxesRequest) Reset() { *x = ListSandboxesRequest{} - mi := &file_openshell_proto_msgTypes[42] + mi := &file_openshell_proto_msgTypes[44] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3873,7 +3995,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[44] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3886,7 +4008,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{44} } func (x *ListSandboxesRequest) GetPageSize() int32 { @@ -3930,7 +4052,7 @@ type ListSandboxProvidersRequest struct { func (x *ListSandboxProvidersRequest) Reset() { *x = ListSandboxProvidersRequest{} - mi := &file_openshell_proto_msgTypes[43] + mi := &file_openshell_proto_msgTypes[45] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3942,7 +4064,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[45] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3955,7 +4077,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{45} } func (x *ListSandboxProvidersRequest) GetSandboxName() string { @@ -3995,7 +4117,7 @@ type AttachSandboxProviderRequest struct { func (x *AttachSandboxProviderRequest) Reset() { *x = AttachSandboxProviderRequest{} - mi := &file_openshell_proto_msgTypes[44] + mi := &file_openshell_proto_msgTypes[46] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4007,7 +4129,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[46] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4020,7 +4142,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{46} } func (x *AttachSandboxProviderRequest) GetSandboxName() string { @@ -4081,7 +4203,7 @@ type DetachSandboxProviderRequest struct { func (x *DetachSandboxProviderRequest) Reset() { *x = DetachSandboxProviderRequest{} - mi := &file_openshell_proto_msgTypes[45] + mi := &file_openshell_proto_msgTypes[47] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4093,7 +4215,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[47] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4106,7 +4228,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{47} } func (x *DetachSandboxProviderRequest) GetSandboxName() string { @@ -4163,7 +4285,7 @@ type DeleteSandboxRequest struct { func (x *DeleteSandboxRequest) Reset() { *x = DeleteSandboxRequest{} - mi := &file_openshell_proto_msgTypes[46] + mi := &file_openshell_proto_msgTypes[48] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4175,7 +4297,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[48] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4188,7 +4310,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{48} } func (x *DeleteSandboxRequest) GetName() string { @@ -4235,7 +4357,7 @@ type StopSandboxRequest struct { func (x *StopSandboxRequest) Reset() { *x = StopSandboxRequest{} - mi := &file_openshell_proto_msgTypes[47] + mi := &file_openshell_proto_msgTypes[49] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4247,7 +4369,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[49] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4260,7 +4382,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{49} } func (x *StopSandboxRequest) GetName() string { @@ -4300,7 +4422,7 @@ type StartSandboxRequest struct { func (x *StartSandboxRequest) Reset() { *x = StartSandboxRequest{} - mi := &file_openshell_proto_msgTypes[48] + mi := &file_openshell_proto_msgTypes[50] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4312,7 +4434,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[50] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4325,7 +4447,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{50} } func (x *StartSandboxRequest) GetName() string { @@ -4359,7 +4481,7 @@ type SandboxResponse struct { func (x *SandboxResponse) Reset() { *x = SandboxResponse{} - mi := &file_openshell_proto_msgTypes[49] + mi := &file_openshell_proto_msgTypes[51] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4371,7 +4493,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[51] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4384,7 +4506,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{51} } func (x *SandboxResponse) GetSandbox() *Sandbox { @@ -4406,7 +4528,7 @@ type ListSandboxesResponse struct { func (x *ListSandboxesResponse) Reset() { *x = ListSandboxesResponse{} - mi := &file_openshell_proto_msgTypes[50] + mi := &file_openshell_proto_msgTypes[52] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4418,7 +4540,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[52] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4431,7 +4553,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{52} } func (x *ListSandboxesResponse) GetSandboxes() []*Sandbox { @@ -4458,7 +4580,7 @@ type ListSandboxProvidersResponse struct { func (x *ListSandboxProvidersResponse) Reset() { *x = ListSandboxProvidersResponse{} - mi := &file_openshell_proto_msgTypes[51] + mi := &file_openshell_proto_msgTypes[53] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4470,7 +4592,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[53] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4483,7 +4605,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{53} } func (x *ListSandboxProvidersResponse) GetProviders() []*datamodelv1.Provider { @@ -4507,7 +4629,7 @@ type AttachSandboxProviderResponse struct { func (x *AttachSandboxProviderResponse) Reset() { *x = AttachSandboxProviderResponse{} - mi := &file_openshell_proto_msgTypes[52] + mi := &file_openshell_proto_msgTypes[54] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4519,7 +4641,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[54] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4532,7 +4654,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{54} } func (x *AttachSandboxProviderResponse) GetSandbox() *Sandbox { @@ -4570,7 +4692,7 @@ type DetachSandboxProviderResponse struct { func (x *DetachSandboxProviderResponse) Reset() { *x = DetachSandboxProviderResponse{} - mi := &file_openshell_proto_msgTypes[53] + mi := &file_openshell_proto_msgTypes[55] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4582,7 +4704,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[55] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4595,7 +4717,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{55} } func (x *DetachSandboxProviderResponse) GetSandbox() *Sandbox { @@ -4637,7 +4759,7 @@ type ProviderDesiredIdentity struct { func (x *ProviderDesiredIdentity) Reset() { *x = ProviderDesiredIdentity{} - mi := &file_openshell_proto_msgTypes[54] + mi := &file_openshell_proto_msgTypes[56] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4649,7 +4771,7 @@ func (x *ProviderDesiredIdentity) String() string { func (*ProviderDesiredIdentity) ProtoMessage() {} func (x *ProviderDesiredIdentity) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[54] + mi := &file_openshell_proto_msgTypes[56] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4662,7 +4784,7 @@ func (x *ProviderDesiredIdentity) ProtoReflect() protoreflect.Message { // Deprecated: Use ProviderDesiredIdentity.ProtoReflect.Descriptor instead. func (*ProviderDesiredIdentity) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{54} + return file_openshell_proto_rawDescGZIP(), []int{56} } func (x *ProviderDesiredIdentity) GetSandboxId() string { @@ -4737,7 +4859,7 @@ type ConfigSnapshotRevision struct { func (x *ConfigSnapshotRevision) Reset() { *x = ConfigSnapshotRevision{} - mi := &file_openshell_proto_msgTypes[55] + mi := &file_openshell_proto_msgTypes[57] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4749,7 +4871,7 @@ func (x *ConfigSnapshotRevision) String() string { func (*ConfigSnapshotRevision) ProtoMessage() {} func (x *ConfigSnapshotRevision) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[55] + mi := &file_openshell_proto_msgTypes[57] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4762,7 +4884,7 @@ func (x *ConfigSnapshotRevision) ProtoReflect() protoreflect.Message { // Deprecated: Use ConfigSnapshotRevision.ProtoReflect.Descriptor instead. func (*ConfigSnapshotRevision) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{55} + return file_openshell_proto_rawDescGZIP(), []int{57} } func (x *ConfigSnapshotRevision) GetComponent() isConfigSnapshotRevision_Component { @@ -4839,7 +4961,7 @@ type SandboxConfigRevision struct { func (x *SandboxConfigRevision) Reset() { *x = SandboxConfigRevision{} - mi := &file_openshell_proto_msgTypes[56] + mi := &file_openshell_proto_msgTypes[58] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4851,7 +4973,7 @@ func (x *SandboxConfigRevision) String() string { func (*SandboxConfigRevision) ProtoMessage() {} func (x *SandboxConfigRevision) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[56] + mi := &file_openshell_proto_msgTypes[58] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4864,7 +4986,7 @@ func (x *SandboxConfigRevision) ProtoReflect() protoreflect.Message { // Deprecated: Use SandboxConfigRevision.ProtoReflect.Descriptor instead. func (*SandboxConfigRevision) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{56} + return file_openshell_proto_rawDescGZIP(), []int{58} } func (x *SandboxConfigRevision) GetConfigRevision() uint64 { @@ -4923,7 +5045,7 @@ type ConfigUpdateOperation struct { func (x *ConfigUpdateOperation) Reset() { *x = ConfigUpdateOperation{} - mi := &file_openshell_proto_msgTypes[57] + mi := &file_openshell_proto_msgTypes[59] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4935,7 +5057,7 @@ func (x *ConfigUpdateOperation) String() string { func (*ConfigUpdateOperation) ProtoMessage() {} func (x *ConfigUpdateOperation) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[57] + mi := &file_openshell_proto_msgTypes[59] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4948,7 +5070,7 @@ func (x *ConfigUpdateOperation) ProtoReflect() protoreflect.Message { // Deprecated: Use ConfigUpdateOperation.ProtoReflect.Descriptor instead. func (*ConfigUpdateOperation) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{57} + return file_openshell_proto_rawDescGZIP(), []int{59} } func (x *ConfigUpdateOperation) GetOperationId() string { @@ -5038,7 +5160,7 @@ type ProviderMutationReceipt struct { func (x *ProviderMutationReceipt) Reset() { *x = ProviderMutationReceipt{} - mi := &file_openshell_proto_msgTypes[58] + mi := &file_openshell_proto_msgTypes[60] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5050,7 +5172,7 @@ func (x *ProviderMutationReceipt) String() string { func (*ProviderMutationReceipt) ProtoMessage() {} func (x *ProviderMutationReceipt) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[58] + mi := &file_openshell_proto_msgTypes[60] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5063,7 +5185,7 @@ func (x *ProviderMutationReceipt) ProtoReflect() protoreflect.Message { // Deprecated: Use ProviderMutationReceipt.ProtoReflect.Descriptor instead. func (*ProviderMutationReceipt) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{58} + return file_openshell_proto_rawDescGZIP(), []int{60} } func (x *ProviderMutationReceipt) GetReceiptId() string { @@ -5139,7 +5261,7 @@ type ProviderReadinessObservation struct { func (x *ProviderReadinessObservation) Reset() { *x = ProviderReadinessObservation{} - mi := &file_openshell_proto_msgTypes[59] + mi := &file_openshell_proto_msgTypes[61] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5151,7 +5273,7 @@ func (x *ProviderReadinessObservation) String() string { func (*ProviderReadinessObservation) ProtoMessage() {} func (x *ProviderReadinessObservation) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[59] + mi := &file_openshell_proto_msgTypes[61] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5164,7 +5286,7 @@ func (x *ProviderReadinessObservation) ProtoReflect() protoreflect.Message { // Deprecated: Use ProviderReadinessObservation.ProtoReflect.Descriptor instead. func (*ProviderReadinessObservation) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{59} + return file_openshell_proto_rawDescGZIP(), []int{61} } func (x *ProviderReadinessObservation) GetSessionId() string { @@ -5263,7 +5385,7 @@ type ProviderReadinessStatus struct { func (x *ProviderReadinessStatus) Reset() { *x = ProviderReadinessStatus{} - mi := &file_openshell_proto_msgTypes[60] + mi := &file_openshell_proto_msgTypes[62] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5275,7 +5397,7 @@ func (x *ProviderReadinessStatus) String() string { func (*ProviderReadinessStatus) ProtoMessage() {} func (x *ProviderReadinessStatus) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[60] + mi := &file_openshell_proto_msgTypes[62] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5288,7 +5410,7 @@ func (x *ProviderReadinessStatus) ProtoReflect() protoreflect.Message { // Deprecated: Use ProviderReadinessStatus.ProtoReflect.Descriptor instead. func (*ProviderReadinessStatus) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{60} + return file_openshell_proto_rawDescGZIP(), []int{62} } func (x *ProviderReadinessStatus) GetReceipt() *ProviderMutationReceipt { @@ -5361,7 +5483,7 @@ type GetSandboxProviderStatusRequest struct { func (x *GetSandboxProviderStatusRequest) Reset() { *x = GetSandboxProviderStatusRequest{} - mi := &file_openshell_proto_msgTypes[61] + mi := &file_openshell_proto_msgTypes[63] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5373,7 +5495,7 @@ func (x *GetSandboxProviderStatusRequest) String() string { func (*GetSandboxProviderStatusRequest) ProtoMessage() {} func (x *GetSandboxProviderStatusRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[61] + mi := &file_openshell_proto_msgTypes[63] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5386,7 +5508,7 @@ func (x *GetSandboxProviderStatusRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetSandboxProviderStatusRequest.ProtoReflect.Descriptor instead. func (*GetSandboxProviderStatusRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{61} + return file_openshell_proto_rawDescGZIP(), []int{63} } func (x *GetSandboxProviderStatusRequest) GetSandboxName() string { @@ -5426,7 +5548,7 @@ type GetSandboxProviderStatusResponse struct { func (x *GetSandboxProviderStatusResponse) Reset() { *x = GetSandboxProviderStatusResponse{} - mi := &file_openshell_proto_msgTypes[62] + mi := &file_openshell_proto_msgTypes[64] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5438,7 +5560,7 @@ func (x *GetSandboxProviderStatusResponse) String() string { func (*GetSandboxProviderStatusResponse) ProtoMessage() {} func (x *GetSandboxProviderStatusResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[62] + mi := &file_openshell_proto_msgTypes[64] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5451,7 +5573,7 @@ func (x *GetSandboxProviderStatusResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use GetSandboxProviderStatusResponse.ProtoReflect.Descriptor instead. func (*GetSandboxProviderStatusResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{62} + return file_openshell_proto_rawDescGZIP(), []int{64} } func (x *GetSandboxProviderStatusResponse) GetStatus() *ProviderReadinessStatus { @@ -5473,7 +5595,7 @@ type ReportProviderReadinessRequest struct { func (x *ReportProviderReadinessRequest) Reset() { *x = ReportProviderReadinessRequest{} - mi := &file_openshell_proto_msgTypes[63] + mi := &file_openshell_proto_msgTypes[65] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5485,7 +5607,7 @@ func (x *ReportProviderReadinessRequest) String() string { func (*ReportProviderReadinessRequest) ProtoMessage() {} func (x *ReportProviderReadinessRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[63] + mi := &file_openshell_proto_msgTypes[65] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5498,7 +5620,7 @@ func (x *ReportProviderReadinessRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ReportProviderReadinessRequest.ProtoReflect.Descriptor instead. func (*ReportProviderReadinessRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{63} + return file_openshell_proto_rawDescGZIP(), []int{65} } func (x *ReportProviderReadinessRequest) GetSandboxId() string { @@ -5528,7 +5650,7 @@ type ReportProviderReadinessResponse struct { func (x *ReportProviderReadinessResponse) Reset() { *x = ReportProviderReadinessResponse{} - mi := &file_openshell_proto_msgTypes[64] + mi := &file_openshell_proto_msgTypes[66] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5540,7 +5662,7 @@ func (x *ReportProviderReadinessResponse) String() string { func (*ReportProviderReadinessResponse) ProtoMessage() {} func (x *ReportProviderReadinessResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[64] + mi := &file_openshell_proto_msgTypes[66] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5553,7 +5675,7 @@ func (x *ReportProviderReadinessResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ReportProviderReadinessResponse.ProtoReflect.Descriptor instead. func (*ReportProviderReadinessResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{64} + return file_openshell_proto_rawDescGZIP(), []int{66} } func (x *ReportProviderReadinessResponse) GetAcceptedSequence() uint64 { @@ -5590,7 +5712,7 @@ type DeleteSandboxResponse struct { func (x *DeleteSandboxResponse) Reset() { *x = DeleteSandboxResponse{} - mi := &file_openshell_proto_msgTypes[65] + mi := &file_openshell_proto_msgTypes[67] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5602,7 +5724,7 @@ func (x *DeleteSandboxResponse) String() string { func (*DeleteSandboxResponse) ProtoMessage() {} func (x *DeleteSandboxResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[65] + mi := &file_openshell_proto_msgTypes[67] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5615,7 +5737,7 @@ func (x *DeleteSandboxResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteSandboxResponse.ProtoReflect.Descriptor instead. func (*DeleteSandboxResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{65} + return file_openshell_proto_rawDescGZIP(), []int{67} } func (x *DeleteSandboxResponse) GetOutcome() DeletionOutcome { @@ -5643,7 +5765,7 @@ type CreateSshSessionRequest struct { func (x *CreateSshSessionRequest) Reset() { *x = CreateSshSessionRequest{} - mi := &file_openshell_proto_msgTypes[66] + mi := &file_openshell_proto_msgTypes[68] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5655,7 +5777,7 @@ func (x *CreateSshSessionRequest) String() string { func (*CreateSshSessionRequest) ProtoMessage() {} func (x *CreateSshSessionRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[66] + mi := &file_openshell_proto_msgTypes[68] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5668,7 +5790,7 @@ func (x *CreateSshSessionRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use CreateSshSessionRequest.ProtoReflect.Descriptor instead. func (*CreateSshSessionRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{66} + return file_openshell_proto_rawDescGZIP(), []int{68} } func (x *CreateSshSessionRequest) GetSandboxId() string { @@ -5711,7 +5833,7 @@ type CreateSshSessionResponse struct { func (x *CreateSshSessionResponse) Reset() { *x = CreateSshSessionResponse{} - mi := &file_openshell_proto_msgTypes[67] + mi := &file_openshell_proto_msgTypes[69] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5723,7 +5845,7 @@ func (x *CreateSshSessionResponse) String() string { func (*CreateSshSessionResponse) ProtoMessage() {} func (x *CreateSshSessionResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[67] + mi := &file_openshell_proto_msgTypes[69] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5736,7 +5858,7 @@ func (x *CreateSshSessionResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use CreateSshSessionResponse.ProtoReflect.Descriptor instead. func (*CreateSshSessionResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{67} + return file_openshell_proto_rawDescGZIP(), []int{69} } func (x *CreateSshSessionResponse) GetSandboxId() string { @@ -5810,7 +5932,7 @@ type ExposeServiceRequest struct { func (x *ExposeServiceRequest) Reset() { *x = ExposeServiceRequest{} - mi := &file_openshell_proto_msgTypes[68] + mi := &file_openshell_proto_msgTypes[70] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5822,7 +5944,7 @@ func (x *ExposeServiceRequest) String() string { func (*ExposeServiceRequest) ProtoMessage() {} func (x *ExposeServiceRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[68] + mi := &file_openshell_proto_msgTypes[70] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5835,7 +5957,7 @@ func (x *ExposeServiceRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ExposeServiceRequest.ProtoReflect.Descriptor instead. func (*ExposeServiceRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{68} + return file_openshell_proto_rawDescGZIP(), []int{70} } func (x *ExposeServiceRequest) GetSandbox() string { @@ -5895,7 +6017,7 @@ type GetServiceRequest struct { func (x *GetServiceRequest) Reset() { *x = GetServiceRequest{} - mi := &file_openshell_proto_msgTypes[69] + mi := &file_openshell_proto_msgTypes[71] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5907,7 +6029,7 @@ func (x *GetServiceRequest) String() string { func (*GetServiceRequest) ProtoMessage() {} func (x *GetServiceRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[69] + mi := &file_openshell_proto_msgTypes[71] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5920,7 +6042,7 @@ func (x *GetServiceRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetServiceRequest.ProtoReflect.Descriptor instead. func (*GetServiceRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{69} + return file_openshell_proto_rawDescGZIP(), []int{71} } func (x *GetServiceRequest) GetSandbox() string { @@ -5963,7 +6085,7 @@ type ListServicesRequest struct { func (x *ListServicesRequest) Reset() { *x = ListServicesRequest{} - mi := &file_openshell_proto_msgTypes[70] + mi := &file_openshell_proto_msgTypes[72] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5975,7 +6097,7 @@ func (x *ListServicesRequest) String() string { func (*ListServicesRequest) ProtoMessage() {} func (x *ListServicesRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[70] + mi := &file_openshell_proto_msgTypes[72] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5988,7 +6110,7 @@ func (x *ListServicesRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListServicesRequest.ProtoReflect.Descriptor instead. func (*ListServicesRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{70} + return file_openshell_proto_rawDescGZIP(), []int{72} } func (x *ListServicesRequest) GetSandbox() string { @@ -6031,7 +6153,7 @@ type ListServicesResponse struct { func (x *ListServicesResponse) Reset() { *x = ListServicesResponse{} - mi := &file_openshell_proto_msgTypes[71] + mi := &file_openshell_proto_msgTypes[73] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6043,7 +6165,7 @@ func (x *ListServicesResponse) String() string { func (*ListServicesResponse) ProtoMessage() {} func (x *ListServicesResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[71] + mi := &file_openshell_proto_msgTypes[73] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6056,7 +6178,7 @@ func (x *ListServicesResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListServicesResponse.ProtoReflect.Descriptor instead. func (*ListServicesResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{71} + return file_openshell_proto_rawDescGZIP(), []int{73} } func (x *ListServicesResponse) GetServices() []*ServiceEndpointResponse { @@ -6092,7 +6214,7 @@ type DeleteServiceRequest struct { func (x *DeleteServiceRequest) Reset() { *x = DeleteServiceRequest{} - mi := &file_openshell_proto_msgTypes[72] + mi := &file_openshell_proto_msgTypes[74] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6104,7 +6226,7 @@ func (x *DeleteServiceRequest) String() string { func (*DeleteServiceRequest) ProtoMessage() {} func (x *DeleteServiceRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[72] + mi := &file_openshell_proto_msgTypes[74] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6117,7 +6239,7 @@ func (x *DeleteServiceRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteServiceRequest.ProtoReflect.Descriptor instead. func (*DeleteServiceRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{72} + return file_openshell_proto_rawDescGZIP(), []int{74} } func (x *DeleteServiceRequest) GetSandbox() string { @@ -6165,7 +6287,7 @@ type DeleteServiceResponse struct { func (x *DeleteServiceResponse) Reset() { *x = DeleteServiceResponse{} - mi := &file_openshell_proto_msgTypes[73] + mi := &file_openshell_proto_msgTypes[75] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6177,7 +6299,7 @@ func (x *DeleteServiceResponse) String() string { func (*DeleteServiceResponse) ProtoMessage() {} func (x *DeleteServiceResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[73] + mi := &file_openshell_proto_msgTypes[75] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6190,7 +6312,7 @@ func (x *DeleteServiceResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteServiceResponse.ProtoReflect.Descriptor instead. func (*DeleteServiceResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{73} + return file_openshell_proto_rawDescGZIP(), []int{75} } func (x *DeleteServiceResponse) GetOutcome() DeletionOutcome { @@ -6221,7 +6343,7 @@ type ServiceEndpoint struct { func (x *ServiceEndpoint) Reset() { *x = ServiceEndpoint{} - mi := &file_openshell_proto_msgTypes[74] + mi := &file_openshell_proto_msgTypes[76] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6233,7 +6355,7 @@ func (x *ServiceEndpoint) String() string { func (*ServiceEndpoint) ProtoMessage() {} func (x *ServiceEndpoint) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[74] + mi := &file_openshell_proto_msgTypes[76] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6246,7 +6368,7 @@ func (x *ServiceEndpoint) ProtoReflect() protoreflect.Message { // Deprecated: Use ServiceEndpoint.ProtoReflect.Descriptor instead. func (*ServiceEndpoint) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{74} + return file_openshell_proto_rawDescGZIP(), []int{76} } func (x *ServiceEndpoint) GetMetadata() *datamodelv1.ObjectMeta { @@ -6302,7 +6424,7 @@ type ServiceEndpointResponse struct { func (x *ServiceEndpointResponse) Reset() { *x = ServiceEndpointResponse{} - mi := &file_openshell_proto_msgTypes[75] + mi := &file_openshell_proto_msgTypes[77] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6314,7 +6436,7 @@ func (x *ServiceEndpointResponse) String() string { func (*ServiceEndpointResponse) ProtoMessage() {} func (x *ServiceEndpointResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[75] + mi := &file_openshell_proto_msgTypes[77] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6327,7 +6449,7 @@ func (x *ServiceEndpointResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ServiceEndpointResponse.ProtoReflect.Descriptor instead. func (*ServiceEndpointResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{75} + return file_openshell_proto_rawDescGZIP(), []int{77} } func (x *ServiceEndpointResponse) GetEndpoint() *ServiceEndpoint { @@ -6358,7 +6480,7 @@ type RevokeSshSessionRequest struct { func (x *RevokeSshSessionRequest) Reset() { *x = RevokeSshSessionRequest{} - mi := &file_openshell_proto_msgTypes[76] + mi := &file_openshell_proto_msgTypes[78] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6370,7 +6492,7 @@ func (x *RevokeSshSessionRequest) String() string { func (*RevokeSshSessionRequest) ProtoMessage() {} func (x *RevokeSshSessionRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[76] + mi := &file_openshell_proto_msgTypes[78] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6383,7 +6505,7 @@ func (x *RevokeSshSessionRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use RevokeSshSessionRequest.ProtoReflect.Descriptor instead. func (*RevokeSshSessionRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{76} + return file_openshell_proto_rawDescGZIP(), []int{78} } func (x *RevokeSshSessionRequest) GetToken() string { @@ -6410,7 +6532,7 @@ type RevokeSshSessionResponse struct { func (x *RevokeSshSessionResponse) Reset() { *x = RevokeSshSessionResponse{} - mi := &file_openshell_proto_msgTypes[77] + mi := &file_openshell_proto_msgTypes[79] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6422,7 +6544,7 @@ func (x *RevokeSshSessionResponse) String() string { func (*RevokeSshSessionResponse) ProtoMessage() {} func (x *RevokeSshSessionResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[77] + mi := &file_openshell_proto_msgTypes[79] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6435,7 +6557,7 @@ func (x *RevokeSshSessionResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use RevokeSshSessionResponse.ProtoReflect.Descriptor instead. func (*RevokeSshSessionResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{77} + return file_openshell_proto_rawDescGZIP(), []int{79} } func (x *RevokeSshSessionResponse) GetOutcome() DeletionOutcome { @@ -6478,7 +6600,7 @@ type ExecSandboxRequest struct { func (x *ExecSandboxRequest) Reset() { *x = ExecSandboxRequest{} - mi := &file_openshell_proto_msgTypes[78] + mi := &file_openshell_proto_msgTypes[80] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6490,7 +6612,7 @@ func (x *ExecSandboxRequest) String() string { func (*ExecSandboxRequest) ProtoMessage() {} func (x *ExecSandboxRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[78] + mi := &file_openshell_proto_msgTypes[80] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6503,7 +6625,7 @@ func (x *ExecSandboxRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ExecSandboxRequest.ProtoReflect.Descriptor instead. func (*ExecSandboxRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{78} + return file_openshell_proto_rawDescGZIP(), []int{80} } func (x *ExecSandboxRequest) GetSandboxId() string { @@ -6586,7 +6708,7 @@ type ExecSandboxStdout struct { func (x *ExecSandboxStdout) Reset() { *x = ExecSandboxStdout{} - mi := &file_openshell_proto_msgTypes[79] + mi := &file_openshell_proto_msgTypes[81] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6598,7 +6720,7 @@ func (x *ExecSandboxStdout) String() string { func (*ExecSandboxStdout) ProtoMessage() {} func (x *ExecSandboxStdout) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[79] + mi := &file_openshell_proto_msgTypes[81] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6611,7 +6733,7 @@ func (x *ExecSandboxStdout) ProtoReflect() protoreflect.Message { // Deprecated: Use ExecSandboxStdout.ProtoReflect.Descriptor instead. func (*ExecSandboxStdout) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{79} + return file_openshell_proto_rawDescGZIP(), []int{81} } func (x *ExecSandboxStdout) GetData() []byte { @@ -6631,7 +6753,7 @@ type ExecSandboxStderr struct { func (x *ExecSandboxStderr) Reset() { *x = ExecSandboxStderr{} - mi := &file_openshell_proto_msgTypes[80] + mi := &file_openshell_proto_msgTypes[82] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6643,7 +6765,7 @@ func (x *ExecSandboxStderr) String() string { func (*ExecSandboxStderr) ProtoMessage() {} func (x *ExecSandboxStderr) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[80] + mi := &file_openshell_proto_msgTypes[82] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6656,7 +6778,7 @@ func (x *ExecSandboxStderr) ProtoReflect() protoreflect.Message { // Deprecated: Use ExecSandboxStderr.ProtoReflect.Descriptor instead. func (*ExecSandboxStderr) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{80} + return file_openshell_proto_rawDescGZIP(), []int{82} } func (x *ExecSandboxStderr) GetData() []byte { @@ -6676,7 +6798,7 @@ type ExecSandboxExit struct { func (x *ExecSandboxExit) Reset() { *x = ExecSandboxExit{} - mi := &file_openshell_proto_msgTypes[81] + mi := &file_openshell_proto_msgTypes[83] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6688,7 +6810,7 @@ func (x *ExecSandboxExit) String() string { func (*ExecSandboxExit) ProtoMessage() {} func (x *ExecSandboxExit) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[81] + mi := &file_openshell_proto_msgTypes[83] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6701,7 +6823,7 @@ func (x *ExecSandboxExit) ProtoReflect() protoreflect.Message { // Deprecated: Use ExecSandboxExit.ProtoReflect.Descriptor instead. func (*ExecSandboxExit) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{81} + return file_openshell_proto_rawDescGZIP(), []int{83} } func (x *ExecSandboxExit) GetExitCode() int32 { @@ -6726,7 +6848,7 @@ type ExecSandboxEvent struct { func (x *ExecSandboxEvent) Reset() { *x = ExecSandboxEvent{} - mi := &file_openshell_proto_msgTypes[82] + mi := &file_openshell_proto_msgTypes[84] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6738,7 +6860,7 @@ func (x *ExecSandboxEvent) String() string { func (*ExecSandboxEvent) ProtoMessage() {} func (x *ExecSandboxEvent) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[82] + mi := &file_openshell_proto_msgTypes[84] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6751,7 +6873,7 @@ func (x *ExecSandboxEvent) ProtoReflect() protoreflect.Message { // Deprecated: Use ExecSandboxEvent.ProtoReflect.Descriptor instead. func (*ExecSandboxEvent) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{82} + return file_openshell_proto_rawDescGZIP(), []int{84} } func (x *ExecSandboxEvent) GetPayload() isExecSandboxEvent_Payload { @@ -6833,7 +6955,7 @@ type TcpForwardInit struct { func (x *TcpForwardInit) Reset() { *x = TcpForwardInit{} - mi := &file_openshell_proto_msgTypes[83] + mi := &file_openshell_proto_msgTypes[85] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6845,7 +6967,7 @@ func (x *TcpForwardInit) String() string { func (*TcpForwardInit) ProtoMessage() {} func (x *TcpForwardInit) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[83] + mi := &file_openshell_proto_msgTypes[85] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6858,7 +6980,7 @@ func (x *TcpForwardInit) ProtoReflect() protoreflect.Message { // Deprecated: Use TcpForwardInit.ProtoReflect.Descriptor instead. func (*TcpForwardInit) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{83} + return file_openshell_proto_rawDescGZIP(), []int{85} } func (x *TcpForwardInit) GetSandboxId() string { @@ -6937,7 +7059,7 @@ type TcpForwardFrame struct { func (x *TcpForwardFrame) Reset() { *x = TcpForwardFrame{} - mi := &file_openshell_proto_msgTypes[84] + mi := &file_openshell_proto_msgTypes[86] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6949,7 +7071,7 @@ func (x *TcpForwardFrame) String() string { func (*TcpForwardFrame) ProtoMessage() {} func (x *TcpForwardFrame) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[84] + mi := &file_openshell_proto_msgTypes[86] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6962,7 +7084,7 @@ func (x *TcpForwardFrame) ProtoReflect() protoreflect.Message { // Deprecated: Use TcpForwardFrame.ProtoReflect.Descriptor instead. func (*TcpForwardFrame) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{84} + return file_openshell_proto_rawDescGZIP(), []int{86} } func (x *TcpForwardFrame) GetPayload() isTcpForwardFrame_Payload { @@ -7021,7 +7143,7 @@ type ExecSandboxInput struct { func (x *ExecSandboxInput) Reset() { *x = ExecSandboxInput{} - mi := &file_openshell_proto_msgTypes[85] + mi := &file_openshell_proto_msgTypes[87] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7033,7 +7155,7 @@ func (x *ExecSandboxInput) String() string { func (*ExecSandboxInput) ProtoMessage() {} func (x *ExecSandboxInput) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[85] + mi := &file_openshell_proto_msgTypes[87] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7046,7 +7168,7 @@ func (x *ExecSandboxInput) ProtoReflect() protoreflect.Message { // Deprecated: Use ExecSandboxInput.ProtoReflect.Descriptor instead. func (*ExecSandboxInput) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{85} + return file_openshell_proto_rawDescGZIP(), []int{87} } func (x *ExecSandboxInput) GetPayload() isExecSandboxInput_Payload { @@ -7119,7 +7241,7 @@ type ExecSandboxWindowResize struct { func (x *ExecSandboxWindowResize) Reset() { *x = ExecSandboxWindowResize{} - mi := &file_openshell_proto_msgTypes[86] + mi := &file_openshell_proto_msgTypes[88] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7131,7 +7253,7 @@ func (x *ExecSandboxWindowResize) String() string { func (*ExecSandboxWindowResize) ProtoMessage() {} func (x *ExecSandboxWindowResize) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[86] + mi := &file_openshell_proto_msgTypes[88] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7144,7 +7266,7 @@ func (x *ExecSandboxWindowResize) ProtoReflect() protoreflect.Message { // Deprecated: Use ExecSandboxWindowResize.ProtoReflect.Descriptor instead. func (*ExecSandboxWindowResize) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{86} + return file_openshell_proto_rawDescGZIP(), []int{88} } func (x *ExecSandboxWindowResize) GetCols() uint32 { @@ -7180,7 +7302,7 @@ type SshSession struct { func (x *SshSession) Reset() { *x = SshSession{} - mi := &file_openshell_proto_msgTypes[87] + mi := &file_openshell_proto_msgTypes[89] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7192,7 +7314,7 @@ func (x *SshSession) String() string { func (*SshSession) ProtoMessage() {} func (x *SshSession) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[87] + mi := &file_openshell_proto_msgTypes[89] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7205,7 +7327,7 @@ func (x *SshSession) ProtoReflect() protoreflect.Message { // Deprecated: Use SshSession.ProtoReflect.Descriptor instead. func (*SshSession) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{87} + return file_openshell_proto_rawDescGZIP(), []int{89} } func (x *SshSession) GetMetadata() *datamodelv1.ObjectMeta { @@ -7274,7 +7396,7 @@ type WatchSandboxRequest struct { func (x *WatchSandboxRequest) Reset() { *x = WatchSandboxRequest{} - mi := &file_openshell_proto_msgTypes[88] + mi := &file_openshell_proto_msgTypes[90] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7286,7 +7408,7 @@ func (x *WatchSandboxRequest) String() string { func (*WatchSandboxRequest) ProtoMessage() {} func (x *WatchSandboxRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[88] + mi := &file_openshell_proto_msgTypes[90] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7299,7 +7421,7 @@ func (x *WatchSandboxRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use WatchSandboxRequest.ProtoReflect.Descriptor instead. func (*WatchSandboxRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{88} + return file_openshell_proto_rawDescGZIP(), []int{90} } func (x *WatchSandboxRequest) GetId() string { @@ -7389,7 +7511,7 @@ type SandboxStreamEvent struct { func (x *SandboxStreamEvent) Reset() { *x = SandboxStreamEvent{} - mi := &file_openshell_proto_msgTypes[89] + mi := &file_openshell_proto_msgTypes[91] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7401,7 +7523,7 @@ func (x *SandboxStreamEvent) String() string { func (*SandboxStreamEvent) ProtoMessage() {} func (x *SandboxStreamEvent) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[89] + mi := &file_openshell_proto_msgTypes[91] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7414,7 +7536,7 @@ func (x *SandboxStreamEvent) ProtoReflect() protoreflect.Message { // Deprecated: Use SandboxStreamEvent.ProtoReflect.Descriptor instead. func (*SandboxStreamEvent) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{89} + return file_openshell_proto_rawDescGZIP(), []int{91} } func (x *SandboxStreamEvent) GetPayload() isSandboxStreamEvent_Payload { @@ -7527,7 +7649,7 @@ type SandboxLogLine struct { func (x *SandboxLogLine) Reset() { *x = SandboxLogLine{} - mi := &file_openshell_proto_msgTypes[90] + mi := &file_openshell_proto_msgTypes[92] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7539,7 +7661,7 @@ func (x *SandboxLogLine) String() string { func (*SandboxLogLine) ProtoMessage() {} func (x *SandboxLogLine) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[90] + mi := &file_openshell_proto_msgTypes[92] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7552,7 +7674,7 @@ func (x *SandboxLogLine) ProtoReflect() protoreflect.Message { // Deprecated: Use SandboxLogLine.ProtoReflect.Descriptor instead. func (*SandboxLogLine) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{90} + return file_openshell_proto_rawDescGZIP(), []int{92} } func (x *SandboxLogLine) GetSandboxId() string { @@ -7613,7 +7735,7 @@ type SandboxStreamWarning struct { func (x *SandboxStreamWarning) Reset() { *x = SandboxStreamWarning{} - mi := &file_openshell_proto_msgTypes[91] + mi := &file_openshell_proto_msgTypes[93] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7625,7 +7747,7 @@ func (x *SandboxStreamWarning) String() string { func (*SandboxStreamWarning) ProtoMessage() {} func (x *SandboxStreamWarning) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[91] + mi := &file_openshell_proto_msgTypes[93] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7638,7 +7760,7 @@ func (x *SandboxStreamWarning) ProtoReflect() protoreflect.Message { // Deprecated: Use SandboxStreamWarning.ProtoReflect.Descriptor instead. func (*SandboxStreamWarning) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{91} + return file_openshell_proto_rawDescGZIP(), []int{93} } func (x *SandboxStreamWarning) GetMessage() string { @@ -7663,7 +7785,7 @@ type CreateProviderRequest struct { func (x *CreateProviderRequest) Reset() { *x = CreateProviderRequest{} - mi := &file_openshell_proto_msgTypes[92] + mi := &file_openshell_proto_msgTypes[94] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7675,7 +7797,7 @@ func (x *CreateProviderRequest) String() string { func (*CreateProviderRequest) ProtoMessage() {} func (x *CreateProviderRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[92] + mi := &file_openshell_proto_msgTypes[94] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7688,7 +7810,7 @@ func (x *CreateProviderRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use CreateProviderRequest.ProtoReflect.Descriptor instead. func (*CreateProviderRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{92} + return file_openshell_proto_rawDescGZIP(), []int{94} } func (x *CreateProviderRequest) GetProvider() *datamodelv1.Provider { @@ -7724,7 +7846,7 @@ type GetProviderRequest struct { func (x *GetProviderRequest) Reset() { *x = GetProviderRequest{} - mi := &file_openshell_proto_msgTypes[93] + mi := &file_openshell_proto_msgTypes[95] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7736,7 +7858,7 @@ func (x *GetProviderRequest) String() string { func (*GetProviderRequest) ProtoMessage() {} func (x *GetProviderRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[93] + mi := &file_openshell_proto_msgTypes[95] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7749,7 +7871,7 @@ func (x *GetProviderRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetProviderRequest.ProtoReflect.Descriptor instead. func (*GetProviderRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{93} + return file_openshell_proto_rawDescGZIP(), []int{95} } func (x *GetProviderRequest) GetName() string { @@ -7783,7 +7905,7 @@ type ListProvidersRequest struct { func (x *ListProvidersRequest) Reset() { *x = ListProvidersRequest{} - mi := &file_openshell_proto_msgTypes[94] + mi := &file_openshell_proto_msgTypes[96] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7795,7 +7917,7 @@ func (x *ListProvidersRequest) String() string { func (*ListProvidersRequest) ProtoMessage() {} func (x *ListProvidersRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[94] + mi := &file_openshell_proto_msgTypes[96] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7808,7 +7930,7 @@ func (x *ListProvidersRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListProvidersRequest.ProtoReflect.Descriptor instead. func (*ListProvidersRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{94} + return file_openshell_proto_rawDescGZIP(), []int{96} } func (x *ListProvidersRequest) GetPageSize() int32 { @@ -7853,7 +7975,7 @@ type UpdateProviderRequest struct { func (x *UpdateProviderRequest) Reset() { *x = UpdateProviderRequest{} - mi := &file_openshell_proto_msgTypes[95] + mi := &file_openshell_proto_msgTypes[97] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7865,7 +7987,7 @@ func (x *UpdateProviderRequest) String() string { func (*UpdateProviderRequest) ProtoMessage() {} func (x *UpdateProviderRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[95] + mi := &file_openshell_proto_msgTypes[97] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7878,7 +8000,7 @@ func (x *UpdateProviderRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use UpdateProviderRequest.ProtoReflect.Descriptor instead. func (*UpdateProviderRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{95} + return file_openshell_proto_rawDescGZIP(), []int{97} } func (x *UpdateProviderRequest) GetProvider() *datamodelv1.Provider { @@ -7932,7 +8054,7 @@ type DeleteProviderRequest struct { func (x *DeleteProviderRequest) Reset() { *x = DeleteProviderRequest{} - mi := &file_openshell_proto_msgTypes[96] + mi := &file_openshell_proto_msgTypes[98] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7944,7 +8066,7 @@ func (x *DeleteProviderRequest) String() string { func (*DeleteProviderRequest) ProtoMessage() {} func (x *DeleteProviderRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[96] + mi := &file_openshell_proto_msgTypes[98] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7957,7 +8079,7 @@ func (x *DeleteProviderRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteProviderRequest.ProtoReflect.Descriptor instead. func (*DeleteProviderRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{96} + return file_openshell_proto_rawDescGZIP(), []int{98} } func (x *DeleteProviderRequest) GetName() string { @@ -8003,7 +8125,7 @@ type ProviderResponse struct { func (x *ProviderResponse) Reset() { *x = ProviderResponse{} - mi := &file_openshell_proto_msgTypes[97] + mi := &file_openshell_proto_msgTypes[99] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8015,7 +8137,7 @@ func (x *ProviderResponse) String() string { func (*ProviderResponse) ProtoMessage() {} func (x *ProviderResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[97] + mi := &file_openshell_proto_msgTypes[99] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8028,7 +8150,7 @@ func (x *ProviderResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ProviderResponse.ProtoReflect.Descriptor instead. func (*ProviderResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{97} + return file_openshell_proto_rawDescGZIP(), []int{99} } func (x *ProviderResponse) GetProvider() *datamodelv1.Provider { @@ -8064,7 +8186,7 @@ type ListProvidersResponse struct { func (x *ListProvidersResponse) Reset() { *x = ListProvidersResponse{} - mi := &file_openshell_proto_msgTypes[98] + mi := &file_openshell_proto_msgTypes[100] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8076,7 +8198,7 @@ func (x *ListProvidersResponse) String() string { func (*ListProvidersResponse) ProtoMessage() {} func (x *ListProvidersResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[98] + mi := &file_openshell_proto_msgTypes[100] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8089,7 +8211,7 @@ func (x *ListProvidersResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListProvidersResponse.ProtoReflect.Descriptor instead. func (*ListProvidersResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{98} + return file_openshell_proto_rawDescGZIP(), []int{100} } func (x *ListProvidersResponse) GetProviders() []*datamodelv1.Provider { @@ -8124,7 +8246,7 @@ type ListProviderProfilesRequest struct { func (x *ListProviderProfilesRequest) Reset() { *x = ListProviderProfilesRequest{} - mi := &file_openshell_proto_msgTypes[99] + mi := &file_openshell_proto_msgTypes[101] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8136,7 +8258,7 @@ func (x *ListProviderProfilesRequest) String() string { func (*ListProviderProfilesRequest) ProtoMessage() {} func (x *ListProviderProfilesRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[99] + mi := &file_openshell_proto_msgTypes[101] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8149,7 +8271,7 @@ func (x *ListProviderProfilesRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListProviderProfilesRequest.ProtoReflect.Descriptor instead. func (*ListProviderProfilesRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{99} + return file_openshell_proto_rawDescGZIP(), []int{101} } func (x *ListProviderProfilesRequest) GetPageSize() int32 { @@ -8187,7 +8309,7 @@ type GetProviderProfileRequest struct { func (x *GetProviderProfileRequest) Reset() { *x = GetProviderProfileRequest{} - mi := &file_openshell_proto_msgTypes[100] + mi := &file_openshell_proto_msgTypes[102] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8199,7 +8321,7 @@ func (x *GetProviderProfileRequest) String() string { func (*GetProviderProfileRequest) ProtoMessage() {} func (x *GetProviderProfileRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[100] + mi := &file_openshell_proto_msgTypes[102] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8212,7 +8334,7 @@ func (x *GetProviderProfileRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetProviderProfileRequest.ProtoReflect.Descriptor instead. func (*GetProviderProfileRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{100} + return file_openshell_proto_rawDescGZIP(), []int{102} } func (x *GetProviderProfileRequest) GetId() string { @@ -8240,7 +8362,7 @@ type ProviderProfileImportItem struct { func (x *ProviderProfileImportItem) Reset() { *x = ProviderProfileImportItem{} - mi := &file_openshell_proto_msgTypes[101] + mi := &file_openshell_proto_msgTypes[103] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8252,7 +8374,7 @@ func (x *ProviderProfileImportItem) String() string { func (*ProviderProfileImportItem) ProtoMessage() {} func (x *ProviderProfileImportItem) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[101] + mi := &file_openshell_proto_msgTypes[103] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8265,7 +8387,7 @@ func (x *ProviderProfileImportItem) ProtoReflect() protoreflect.Message { // Deprecated: Use ProviderProfileImportItem.ProtoReflect.Descriptor instead. func (*ProviderProfileImportItem) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{101} + return file_openshell_proto_rawDescGZIP(), []int{103} } func (x *ProviderProfileImportItem) GetProfile() *ProviderProfile { @@ -8296,7 +8418,7 @@ type ProviderProfileDiagnostic struct { func (x *ProviderProfileDiagnostic) Reset() { *x = ProviderProfileDiagnostic{} - mi := &file_openshell_proto_msgTypes[102] + mi := &file_openshell_proto_msgTypes[104] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8308,7 +8430,7 @@ func (x *ProviderProfileDiagnostic) String() string { func (*ProviderProfileDiagnostic) ProtoMessage() {} func (x *ProviderProfileDiagnostic) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[102] + mi := &file_openshell_proto_msgTypes[104] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8321,7 +8443,7 @@ func (x *ProviderProfileDiagnostic) ProtoReflect() protoreflect.Message { // Deprecated: Use ProviderProfileDiagnostic.ProtoReflect.Descriptor instead. func (*ProviderProfileDiagnostic) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{102} + return file_openshell_proto_rawDescGZIP(), []int{104} } func (x *ProviderProfileDiagnostic) GetSource() string { @@ -8378,7 +8500,7 @@ type ProviderCredentialTokenGrantAudienceOverride struct { func (x *ProviderCredentialTokenGrantAudienceOverride) Reset() { *x = ProviderCredentialTokenGrantAudienceOverride{} - mi := &file_openshell_proto_msgTypes[103] + mi := &file_openshell_proto_msgTypes[105] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8390,7 +8512,7 @@ func (x *ProviderCredentialTokenGrantAudienceOverride) String() string { func (*ProviderCredentialTokenGrantAudienceOverride) ProtoMessage() {} func (x *ProviderCredentialTokenGrantAudienceOverride) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[103] + mi := &file_openshell_proto_msgTypes[105] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8403,7 +8525,7 @@ func (x *ProviderCredentialTokenGrantAudienceOverride) ProtoReflect() protorefle // Deprecated: Use ProviderCredentialTokenGrantAudienceOverride.ProtoReflect.Descriptor instead. func (*ProviderCredentialTokenGrantAudienceOverride) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{103} + return file_openshell_proto_rawDescGZIP(), []int{105} } func (x *ProviderCredentialTokenGrantAudienceOverride) GetHost() string { @@ -8457,7 +8579,7 @@ type ProviderCredentialTokenGrantSubjectToken struct { func (x *ProviderCredentialTokenGrantSubjectToken) Reset() { *x = ProviderCredentialTokenGrantSubjectToken{} - mi := &file_openshell_proto_msgTypes[104] + mi := &file_openshell_proto_msgTypes[106] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8469,7 +8591,7 @@ func (x *ProviderCredentialTokenGrantSubjectToken) String() string { func (*ProviderCredentialTokenGrantSubjectToken) ProtoMessage() {} func (x *ProviderCredentialTokenGrantSubjectToken) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[104] + mi := &file_openshell_proto_msgTypes[106] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8482,7 +8604,7 @@ func (x *ProviderCredentialTokenGrantSubjectToken) ProtoReflect() protoreflect.M // Deprecated: Use ProviderCredentialTokenGrantSubjectToken.ProtoReflect.Descriptor instead. func (*ProviderCredentialTokenGrantSubjectToken) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{104} + return file_openshell_proto_rawDescGZIP(), []int{106} } func (x *ProviderCredentialTokenGrantSubjectToken) GetSource() string { @@ -8538,7 +8660,7 @@ type ProviderCredentialTokenGrant struct { func (x *ProviderCredentialTokenGrant) Reset() { *x = ProviderCredentialTokenGrant{} - mi := &file_openshell_proto_msgTypes[105] + mi := &file_openshell_proto_msgTypes[107] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8550,7 +8672,7 @@ func (x *ProviderCredentialTokenGrant) String() string { func (*ProviderCredentialTokenGrant) ProtoMessage() {} func (x *ProviderCredentialTokenGrant) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[105] + mi := &file_openshell_proto_msgTypes[107] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8563,7 +8685,7 @@ func (x *ProviderCredentialTokenGrant) ProtoReflect() protoreflect.Message { // Deprecated: Use ProviderCredentialTokenGrant.ProtoReflect.Descriptor instead. func (*ProviderCredentialTokenGrant) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{105} + return file_openshell_proto_rawDescGZIP(), []int{107} } func (x *ProviderCredentialTokenGrant) GetTokenEndpoint() string { @@ -8655,7 +8777,7 @@ type ProviderProfileCredential struct { func (x *ProviderProfileCredential) Reset() { *x = ProviderProfileCredential{} - mi := &file_openshell_proto_msgTypes[106] + mi := &file_openshell_proto_msgTypes[108] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8667,7 +8789,7 @@ func (x *ProviderProfileCredential) String() string { func (*ProviderProfileCredential) ProtoMessage() {} func (x *ProviderProfileCredential) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[106] + mi := &file_openshell_proto_msgTypes[108] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8680,7 +8802,7 @@ func (x *ProviderProfileCredential) ProtoReflect() protoreflect.Message { // Deprecated: Use ProviderProfileCredential.ProtoReflect.Descriptor instead. func (*ProviderProfileCredential) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{106} + return file_openshell_proto_rawDescGZIP(), []int{108} } func (x *ProviderProfileCredential) GetName() string { @@ -8765,7 +8887,7 @@ type ProviderCredentialRefreshMaterial struct { func (x *ProviderCredentialRefreshMaterial) Reset() { *x = ProviderCredentialRefreshMaterial{} - mi := &file_openshell_proto_msgTypes[107] + mi := &file_openshell_proto_msgTypes[109] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8777,7 +8899,7 @@ func (x *ProviderCredentialRefreshMaterial) String() string { func (*ProviderCredentialRefreshMaterial) ProtoMessage() {} func (x *ProviderCredentialRefreshMaterial) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[107] + mi := &file_openshell_proto_msgTypes[109] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8790,7 +8912,7 @@ func (x *ProviderCredentialRefreshMaterial) ProtoReflect() protoreflect.Message // Deprecated: Use ProviderCredentialRefreshMaterial.ProtoReflect.Descriptor instead. func (*ProviderCredentialRefreshMaterial) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{107} + return file_openshell_proto_rawDescGZIP(), []int{109} } func (x *ProviderCredentialRefreshMaterial) GetName() string { @@ -8835,7 +8957,7 @@ type ProviderCredentialRefreshOutput struct { func (x *ProviderCredentialRefreshOutput) Reset() { *x = ProviderCredentialRefreshOutput{} - mi := &file_openshell_proto_msgTypes[108] + mi := &file_openshell_proto_msgTypes[110] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8847,7 +8969,7 @@ func (x *ProviderCredentialRefreshOutput) String() string { func (*ProviderCredentialRefreshOutput) ProtoMessage() {} func (x *ProviderCredentialRefreshOutput) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[108] + mi := &file_openshell_proto_msgTypes[110] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8860,7 +8982,7 @@ func (x *ProviderCredentialRefreshOutput) ProtoReflect() protoreflect.Message { // Deprecated: Use ProviderCredentialRefreshOutput.ProtoReflect.Descriptor instead. func (*ProviderCredentialRefreshOutput) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{108} + return file_openshell_proto_rawDescGZIP(), []int{110} } func (x *ProviderCredentialRefreshOutput) GetOutput() string { @@ -8892,7 +9014,7 @@ type ProviderCredentialRefresh struct { func (x *ProviderCredentialRefresh) Reset() { *x = ProviderCredentialRefresh{} - mi := &file_openshell_proto_msgTypes[109] + mi := &file_openshell_proto_msgTypes[111] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8904,7 +9026,7 @@ func (x *ProviderCredentialRefresh) String() string { func (*ProviderCredentialRefresh) ProtoMessage() {} func (x *ProviderCredentialRefresh) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[109] + mi := &file_openshell_proto_msgTypes[111] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8917,7 +9039,7 @@ func (x *ProviderCredentialRefresh) ProtoReflect() protoreflect.Message { // Deprecated: Use ProviderCredentialRefresh.ProtoReflect.Descriptor instead. func (*ProviderCredentialRefresh) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{109} + return file_openshell_proto_rawDescGZIP(), []int{111} } func (x *ProviderCredentialRefresh) GetStrategy() ProviderCredentialRefreshStrategy { @@ -8998,7 +9120,7 @@ type ProviderCredentialRefreshStatus struct { func (x *ProviderCredentialRefreshStatus) Reset() { *x = ProviderCredentialRefreshStatus{} - mi := &file_openshell_proto_msgTypes[110] + mi := &file_openshell_proto_msgTypes[112] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9010,7 +9132,7 @@ func (x *ProviderCredentialRefreshStatus) String() string { func (*ProviderCredentialRefreshStatus) ProtoMessage() {} func (x *ProviderCredentialRefreshStatus) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[110] + mi := &file_openshell_proto_msgTypes[112] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9023,7 +9145,7 @@ func (x *ProviderCredentialRefreshStatus) ProtoReflect() protoreflect.Message { // Deprecated: Use ProviderCredentialRefreshStatus.ProtoReflect.Descriptor instead. func (*ProviderCredentialRefreshStatus) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{110} + return file_openshell_proto_rawDescGZIP(), []int{112} } func (x *ProviderCredentialRefreshStatus) GetProviderName() string { @@ -9128,7 +9250,7 @@ type ProviderProfileDiscovery struct { func (x *ProviderProfileDiscovery) Reset() { *x = ProviderProfileDiscovery{} - mi := &file_openshell_proto_msgTypes[111] + mi := &file_openshell_proto_msgTypes[113] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9140,7 +9262,7 @@ func (x *ProviderProfileDiscovery) String() string { func (*ProviderProfileDiscovery) ProtoMessage() {} func (x *ProviderProfileDiscovery) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[111] + mi := &file_openshell_proto_msgTypes[113] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9153,7 +9275,7 @@ func (x *ProviderProfileDiscovery) ProtoReflect() protoreflect.Message { // Deprecated: Use ProviderProfileDiscovery.ProtoReflect.Descriptor instead. func (*ProviderProfileDiscovery) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{111} + return file_openshell_proto_rawDescGZIP(), []int{113} } func (x *ProviderProfileDiscovery) GetCredentials() []string { @@ -9175,7 +9297,7 @@ type GetProviderRefreshStatusRequest struct { func (x *GetProviderRefreshStatusRequest) Reset() { *x = GetProviderRefreshStatusRequest{} - mi := &file_openshell_proto_msgTypes[112] + mi := &file_openshell_proto_msgTypes[114] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9187,7 +9309,7 @@ func (x *GetProviderRefreshStatusRequest) String() string { func (*GetProviderRefreshStatusRequest) ProtoMessage() {} func (x *GetProviderRefreshStatusRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[112] + mi := &file_openshell_proto_msgTypes[114] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9200,7 +9322,7 @@ func (x *GetProviderRefreshStatusRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetProviderRefreshStatusRequest.ProtoReflect.Descriptor instead. func (*GetProviderRefreshStatusRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{112} + return file_openshell_proto_rawDescGZIP(), []int{114} } func (x *GetProviderRefreshStatusRequest) GetProvider() string { @@ -9233,7 +9355,7 @@ type GetProviderRefreshStatusResponse struct { func (x *GetProviderRefreshStatusResponse) Reset() { *x = GetProviderRefreshStatusResponse{} - mi := &file_openshell_proto_msgTypes[113] + mi := &file_openshell_proto_msgTypes[115] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9245,7 +9367,7 @@ func (x *GetProviderRefreshStatusResponse) String() string { func (*GetProviderRefreshStatusResponse) ProtoMessage() {} func (x *GetProviderRefreshStatusResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[113] + mi := &file_openshell_proto_msgTypes[115] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9258,7 +9380,7 @@ func (x *GetProviderRefreshStatusResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use GetProviderRefreshStatusResponse.ProtoReflect.Descriptor instead. func (*GetProviderRefreshStatusResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{113} + return file_openshell_proto_rawDescGZIP(), []int{115} } func (x *GetProviderRefreshStatusResponse) GetCredentials() []*ProviderCredentialRefreshStatus { @@ -9290,7 +9412,7 @@ type ConfigureProviderRefreshRequest struct { func (x *ConfigureProviderRefreshRequest) Reset() { *x = ConfigureProviderRefreshRequest{} - mi := &file_openshell_proto_msgTypes[114] + mi := &file_openshell_proto_msgTypes[116] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9302,7 +9424,7 @@ func (x *ConfigureProviderRefreshRequest) String() string { func (*ConfigureProviderRefreshRequest) ProtoMessage() {} func (x *ConfigureProviderRefreshRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[114] + mi := &file_openshell_proto_msgTypes[116] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9315,7 +9437,7 @@ func (x *ConfigureProviderRefreshRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ConfigureProviderRefreshRequest.ProtoReflect.Descriptor instead. func (*ConfigureProviderRefreshRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{114} + return file_openshell_proto_rawDescGZIP(), []int{116} } func (x *ConfigureProviderRefreshRequest) GetProvider() string { @@ -9383,7 +9505,7 @@ type ConfigureProviderRefreshResponse struct { func (x *ConfigureProviderRefreshResponse) Reset() { *x = ConfigureProviderRefreshResponse{} - mi := &file_openshell_proto_msgTypes[115] + mi := &file_openshell_proto_msgTypes[117] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9395,7 +9517,7 @@ func (x *ConfigureProviderRefreshResponse) String() string { func (*ConfigureProviderRefreshResponse) ProtoMessage() {} func (x *ConfigureProviderRefreshResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[115] + mi := &file_openshell_proto_msgTypes[117] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9408,7 +9530,7 @@ func (x *ConfigureProviderRefreshResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ConfigureProviderRefreshResponse.ProtoReflect.Descriptor instead. func (*ConfigureProviderRefreshResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{115} + return file_openshell_proto_rawDescGZIP(), []int{117} } func (x *ConfigureProviderRefreshResponse) GetStatus() *ProviderCredentialRefreshStatus { @@ -9433,7 +9555,7 @@ type RotateProviderCredentialRequest struct { func (x *RotateProviderCredentialRequest) Reset() { *x = RotateProviderCredentialRequest{} - mi := &file_openshell_proto_msgTypes[116] + mi := &file_openshell_proto_msgTypes[118] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9445,7 +9567,7 @@ func (x *RotateProviderCredentialRequest) String() string { func (*RotateProviderCredentialRequest) ProtoMessage() {} func (x *RotateProviderCredentialRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[116] + mi := &file_openshell_proto_msgTypes[118] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9458,7 +9580,7 @@ func (x *RotateProviderCredentialRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use RotateProviderCredentialRequest.ProtoReflect.Descriptor instead. func (*RotateProviderCredentialRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{116} + return file_openshell_proto_rawDescGZIP(), []int{118} } func (x *RotateProviderCredentialRequest) GetProvider() string { @@ -9498,7 +9620,7 @@ type RotateProviderCredentialResponse struct { func (x *RotateProviderCredentialResponse) Reset() { *x = RotateProviderCredentialResponse{} - mi := &file_openshell_proto_msgTypes[117] + mi := &file_openshell_proto_msgTypes[119] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9510,7 +9632,7 @@ func (x *RotateProviderCredentialResponse) String() string { func (*RotateProviderCredentialResponse) ProtoMessage() {} func (x *RotateProviderCredentialResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[117] + mi := &file_openshell_proto_msgTypes[119] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9523,7 +9645,7 @@ func (x *RotateProviderCredentialResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use RotateProviderCredentialResponse.ProtoReflect.Descriptor instead. func (*RotateProviderCredentialResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{117} + return file_openshell_proto_rawDescGZIP(), []int{119} } func (x *RotateProviderCredentialResponse) GetStatus() *ProviderCredentialRefreshStatus { @@ -9549,7 +9671,7 @@ type DeleteProviderRefreshRequest struct { func (x *DeleteProviderRefreshRequest) Reset() { *x = DeleteProviderRefreshRequest{} - mi := &file_openshell_proto_msgTypes[118] + mi := &file_openshell_proto_msgTypes[120] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9561,7 +9683,7 @@ func (x *DeleteProviderRefreshRequest) String() string { func (*DeleteProviderRefreshRequest) ProtoMessage() {} func (x *DeleteProviderRefreshRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[118] + mi := &file_openshell_proto_msgTypes[120] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9574,7 +9696,7 @@ func (x *DeleteProviderRefreshRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteProviderRefreshRequest.ProtoReflect.Descriptor instead. func (*DeleteProviderRefreshRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{118} + return file_openshell_proto_rawDescGZIP(), []int{120} } func (x *DeleteProviderRefreshRequest) GetProvider() string { @@ -9621,7 +9743,7 @@ type DeleteProviderRefreshResponse struct { func (x *DeleteProviderRefreshResponse) Reset() { *x = DeleteProviderRefreshResponse{} - mi := &file_openshell_proto_msgTypes[119] + mi := &file_openshell_proto_msgTypes[121] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9633,7 +9755,7 @@ func (x *DeleteProviderRefreshResponse) String() string { func (*DeleteProviderRefreshResponse) ProtoMessage() {} func (x *DeleteProviderRefreshResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[119] + mi := &file_openshell_proto_msgTypes[121] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9646,7 +9768,7 @@ func (x *DeleteProviderRefreshResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteProviderRefreshResponse.ProtoReflect.Descriptor instead. func (*DeleteProviderRefreshResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{119} + return file_openshell_proto_rawDescGZIP(), []int{121} } func (x *DeleteProviderRefreshResponse) GetOutcome() DeletionOutcome { @@ -9686,7 +9808,7 @@ type ProviderProfile struct { func (x *ProviderProfile) Reset() { *x = ProviderProfile{} - mi := &file_openshell_proto_msgTypes[120] + mi := &file_openshell_proto_msgTypes[122] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9698,7 +9820,7 @@ func (x *ProviderProfile) String() string { func (*ProviderProfile) ProtoMessage() {} func (x *ProviderProfile) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[120] + mi := &file_openshell_proto_msgTypes[122] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9711,7 +9833,7 @@ func (x *ProviderProfile) ProtoReflect() protoreflect.Message { // Deprecated: Use ProviderProfile.ProtoReflect.Descriptor instead. func (*ProviderProfile) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{120} + return file_openshell_proto_rawDescGZIP(), []int{122} } func (x *ProviderProfile) GetId() string { @@ -9815,7 +9937,7 @@ type ProviderProfileResponse struct { func (x *ProviderProfileResponse) Reset() { *x = ProviderProfileResponse{} - mi := &file_openshell_proto_msgTypes[121] + mi := &file_openshell_proto_msgTypes[123] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9827,7 +9949,7 @@ func (x *ProviderProfileResponse) String() string { func (*ProviderProfileResponse) ProtoMessage() {} func (x *ProviderProfileResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[121] + mi := &file_openshell_proto_msgTypes[123] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9840,7 +9962,7 @@ func (x *ProviderProfileResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ProviderProfileResponse.ProtoReflect.Descriptor instead. func (*ProviderProfileResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{121} + return file_openshell_proto_rawDescGZIP(), []int{123} } func (x *ProviderProfileResponse) GetProfile() *ProviderProfile { @@ -9862,7 +9984,7 @@ type ListProviderProfilesResponse struct { func (x *ListProviderProfilesResponse) Reset() { *x = ListProviderProfilesResponse{} - mi := &file_openshell_proto_msgTypes[122] + mi := &file_openshell_proto_msgTypes[124] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9874,7 +9996,7 @@ func (x *ListProviderProfilesResponse) String() string { func (*ListProviderProfilesResponse) ProtoMessage() {} func (x *ListProviderProfilesResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[122] + mi := &file_openshell_proto_msgTypes[124] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9887,7 +10009,7 @@ func (x *ListProviderProfilesResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListProviderProfilesResponse.ProtoReflect.Descriptor instead. func (*ListProviderProfilesResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{122} + return file_openshell_proto_rawDescGZIP(), []int{124} } func (x *ListProviderProfilesResponse) GetProfiles() []*ProviderProfile { @@ -9920,7 +10042,7 @@ type ImportProviderProfilesRequest struct { func (x *ImportProviderProfilesRequest) Reset() { *x = ImportProviderProfilesRequest{} - mi := &file_openshell_proto_msgTypes[123] + mi := &file_openshell_proto_msgTypes[125] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9932,7 +10054,7 @@ func (x *ImportProviderProfilesRequest) String() string { func (*ImportProviderProfilesRequest) ProtoMessage() {} func (x *ImportProviderProfilesRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[123] + mi := &file_openshell_proto_msgTypes[125] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9945,7 +10067,7 @@ func (x *ImportProviderProfilesRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ImportProviderProfilesRequest.ProtoReflect.Descriptor instead. func (*ImportProviderProfilesRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{123} + return file_openshell_proto_rawDescGZIP(), []int{125} } func (x *ImportProviderProfilesRequest) GetProfiles() []*ProviderProfileImportItem { @@ -9981,7 +10103,7 @@ type ImportProviderProfilesResponse struct { func (x *ImportProviderProfilesResponse) Reset() { *x = ImportProviderProfilesResponse{} - mi := &file_openshell_proto_msgTypes[124] + mi := &file_openshell_proto_msgTypes[126] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9993,7 +10115,7 @@ func (x *ImportProviderProfilesResponse) String() string { func (*ImportProviderProfilesResponse) ProtoMessage() {} func (x *ImportProviderProfilesResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[124] + mi := &file_openshell_proto_msgTypes[126] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10006,7 +10128,7 @@ func (x *ImportProviderProfilesResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ImportProviderProfilesResponse.ProtoReflect.Descriptor instead. func (*ImportProviderProfilesResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{124} + return file_openshell_proto_rawDescGZIP(), []int{126} } func (x *ImportProviderProfilesResponse) GetDiagnostics() []*ProviderProfileDiagnostic { @@ -10053,7 +10175,7 @@ type UpdateProviderProfilesRequest struct { func (x *UpdateProviderProfilesRequest) Reset() { *x = UpdateProviderProfilesRequest{} - mi := &file_openshell_proto_msgTypes[125] + mi := &file_openshell_proto_msgTypes[127] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10065,7 +10187,7 @@ func (x *UpdateProviderProfilesRequest) String() string { func (*UpdateProviderProfilesRequest) ProtoMessage() {} func (x *UpdateProviderProfilesRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[125] + mi := &file_openshell_proto_msgTypes[127] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10078,7 +10200,7 @@ func (x *UpdateProviderProfilesRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use UpdateProviderProfilesRequest.ProtoReflect.Descriptor instead. func (*UpdateProviderProfilesRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{125} + return file_openshell_proto_rawDescGZIP(), []int{127} } func (x *UpdateProviderProfilesRequest) GetProfile() *ProviderProfileImportItem { @@ -10128,7 +10250,7 @@ type UpdateProviderProfilesResponse struct { func (x *UpdateProviderProfilesResponse) Reset() { *x = UpdateProviderProfilesResponse{} - mi := &file_openshell_proto_msgTypes[126] + mi := &file_openshell_proto_msgTypes[128] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10140,7 +10262,7 @@ func (x *UpdateProviderProfilesResponse) String() string { func (*UpdateProviderProfilesResponse) ProtoMessage() {} func (x *UpdateProviderProfilesResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[126] + mi := &file_openshell_proto_msgTypes[128] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10153,7 +10275,7 @@ func (x *UpdateProviderProfilesResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use UpdateProviderProfilesResponse.ProtoReflect.Descriptor instead. func (*UpdateProviderProfilesResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{126} + return file_openshell_proto_rawDescGZIP(), []int{128} } func (x *UpdateProviderProfilesResponse) GetDiagnostics() []*ProviderProfileDiagnostic { @@ -10190,7 +10312,7 @@ type LintProviderProfilesRequest struct { func (x *LintProviderProfilesRequest) Reset() { *x = LintProviderProfilesRequest{} - mi := &file_openshell_proto_msgTypes[127] + mi := &file_openshell_proto_msgTypes[129] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10202,7 +10324,7 @@ func (x *LintProviderProfilesRequest) String() string { func (*LintProviderProfilesRequest) ProtoMessage() {} func (x *LintProviderProfilesRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[127] + mi := &file_openshell_proto_msgTypes[129] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10215,7 +10337,7 @@ func (x *LintProviderProfilesRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use LintProviderProfilesRequest.ProtoReflect.Descriptor instead. func (*LintProviderProfilesRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{127} + return file_openshell_proto_rawDescGZIP(), []int{129} } func (x *LintProviderProfilesRequest) GetProfiles() []*ProviderProfileImportItem { @@ -10243,7 +10365,7 @@ type LintProviderProfilesResponse struct { func (x *LintProviderProfilesResponse) Reset() { *x = LintProviderProfilesResponse{} - mi := &file_openshell_proto_msgTypes[128] + mi := &file_openshell_proto_msgTypes[130] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10255,7 +10377,7 @@ func (x *LintProviderProfilesResponse) String() string { func (*LintProviderProfilesResponse) ProtoMessage() {} func (x *LintProviderProfilesResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[128] + mi := &file_openshell_proto_msgTypes[130] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10268,7 +10390,7 @@ func (x *LintProviderProfilesResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use LintProviderProfilesResponse.ProtoReflect.Descriptor instead. func (*LintProviderProfilesResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{128} + return file_openshell_proto_rawDescGZIP(), []int{130} } func (x *LintProviderProfilesResponse) GetDiagnostics() []*ProviderProfileDiagnostic { @@ -10295,7 +10417,7 @@ type DeleteProviderResponse struct { func (x *DeleteProviderResponse) Reset() { *x = DeleteProviderResponse{} - mi := &file_openshell_proto_msgTypes[129] + mi := &file_openshell_proto_msgTypes[131] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10307,7 +10429,7 @@ func (x *DeleteProviderResponse) String() string { func (*DeleteProviderResponse) ProtoMessage() {} func (x *DeleteProviderResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[129] + mi := &file_openshell_proto_msgTypes[131] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10320,7 +10442,7 @@ func (x *DeleteProviderResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteProviderResponse.ProtoReflect.Descriptor instead. func (*DeleteProviderResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{129} + return file_openshell_proto_rawDescGZIP(), []int{131} } func (x *DeleteProviderResponse) GetOutcome() DeletionOutcome { @@ -10347,7 +10469,7 @@ type DeleteProviderProfileRequest struct { func (x *DeleteProviderProfileRequest) Reset() { *x = DeleteProviderProfileRequest{} - mi := &file_openshell_proto_msgTypes[130] + mi := &file_openshell_proto_msgTypes[132] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10359,7 +10481,7 @@ func (x *DeleteProviderProfileRequest) String() string { func (*DeleteProviderProfileRequest) ProtoMessage() {} func (x *DeleteProviderProfileRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[130] + mi := &file_openshell_proto_msgTypes[132] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10372,7 +10494,7 @@ func (x *DeleteProviderProfileRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteProviderProfileRequest.ProtoReflect.Descriptor instead. func (*DeleteProviderProfileRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{130} + return file_openshell_proto_rawDescGZIP(), []int{132} } func (x *DeleteProviderProfileRequest) GetId() string { @@ -10413,7 +10535,7 @@ type DeleteProviderProfileResponse struct { func (x *DeleteProviderProfileResponse) Reset() { *x = DeleteProviderProfileResponse{} - mi := &file_openshell_proto_msgTypes[131] + mi := &file_openshell_proto_msgTypes[133] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10425,7 +10547,7 @@ func (x *DeleteProviderProfileResponse) String() string { func (*DeleteProviderProfileResponse) ProtoMessage() {} func (x *DeleteProviderProfileResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[131] + mi := &file_openshell_proto_msgTypes[133] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10438,7 +10560,7 @@ func (x *DeleteProviderProfileResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteProviderProfileResponse.ProtoReflect.Descriptor instead. func (*DeleteProviderProfileResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{131} + return file_openshell_proto_rawDescGZIP(), []int{133} } func (x *DeleteProviderProfileResponse) GetOutcome() DeletionOutcome { @@ -10463,7 +10585,7 @@ type GetSandboxProviderEnvironmentRequest struct { func (x *GetSandboxProviderEnvironmentRequest) Reset() { *x = GetSandboxProviderEnvironmentRequest{} - mi := &file_openshell_proto_msgTypes[132] + mi := &file_openshell_proto_msgTypes[134] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10475,7 +10597,7 @@ func (x *GetSandboxProviderEnvironmentRequest) String() string { func (*GetSandboxProviderEnvironmentRequest) ProtoMessage() {} func (x *GetSandboxProviderEnvironmentRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[132] + mi := &file_openshell_proto_msgTypes[134] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10488,7 +10610,7 @@ func (x *GetSandboxProviderEnvironmentRequest) ProtoReflect() protoreflect.Messa // Deprecated: Use GetSandboxProviderEnvironmentRequest.ProtoReflect.Descriptor instead. func (*GetSandboxProviderEnvironmentRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{132} + return file_openshell_proto_rawDescGZIP(), []int{134} } func (x *GetSandboxProviderEnvironmentRequest) GetSandboxId() string { @@ -10517,7 +10639,7 @@ type StaticCredentialEndpointBinding struct { func (x *StaticCredentialEndpointBinding) Reset() { *x = StaticCredentialEndpointBinding{} - mi := &file_openshell_proto_msgTypes[133] + mi := &file_openshell_proto_msgTypes[135] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10529,7 +10651,7 @@ func (x *StaticCredentialEndpointBinding) String() string { func (*StaticCredentialEndpointBinding) ProtoMessage() {} func (x *StaticCredentialEndpointBinding) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[133] + mi := &file_openshell_proto_msgTypes[135] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10542,7 +10664,7 @@ func (x *StaticCredentialEndpointBinding) ProtoReflect() protoreflect.Message { // Deprecated: Use StaticCredentialEndpointBinding.ProtoReflect.Descriptor instead. func (*StaticCredentialEndpointBinding) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{133} + return file_openshell_proto_rawDescGZIP(), []int{135} } func (x *StaticCredentialEndpointBinding) GetHost() string { @@ -10586,7 +10708,7 @@ type StaticCredentialBinding struct { func (x *StaticCredentialBinding) Reset() { *x = StaticCredentialBinding{} - mi := &file_openshell_proto_msgTypes[134] + mi := &file_openshell_proto_msgTypes[136] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10598,7 +10720,7 @@ func (x *StaticCredentialBinding) String() string { func (*StaticCredentialBinding) ProtoMessage() {} func (x *StaticCredentialBinding) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[134] + mi := &file_openshell_proto_msgTypes[136] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10611,7 +10733,7 @@ func (x *StaticCredentialBinding) ProtoReflect() protoreflect.Message { // Deprecated: Use StaticCredentialBinding.ProtoReflect.Descriptor instead. func (*StaticCredentialBinding) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{134} + return file_openshell_proto_rawDescGZIP(), []int{136} } func (x *StaticCredentialBinding) GetEndpoints() []*StaticCredentialEndpointBinding { @@ -10668,7 +10790,7 @@ type GetSandboxProviderEnvironmentResponse struct { func (x *GetSandboxProviderEnvironmentResponse) Reset() { *x = GetSandboxProviderEnvironmentResponse{} - mi := &file_openshell_proto_msgTypes[135] + mi := &file_openshell_proto_msgTypes[137] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10680,7 +10802,7 @@ func (x *GetSandboxProviderEnvironmentResponse) String() string { func (*GetSandboxProviderEnvironmentResponse) ProtoMessage() {} func (x *GetSandboxProviderEnvironmentResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[135] + mi := &file_openshell_proto_msgTypes[137] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10693,7 +10815,7 @@ func (x *GetSandboxProviderEnvironmentResponse) ProtoReflect() protoreflect.Mess // Deprecated: Use GetSandboxProviderEnvironmentResponse.ProtoReflect.Descriptor instead. func (*GetSandboxProviderEnvironmentResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{135} + return file_openshell_proto_rawDescGZIP(), []int{137} } func (x *GetSandboxProviderEnvironmentResponse) GetEnvironment() map[string]string { @@ -10776,7 +10898,7 @@ type ExchangeProviderSubjectTokenRequest struct { func (x *ExchangeProviderSubjectTokenRequest) Reset() { *x = ExchangeProviderSubjectTokenRequest{} - mi := &file_openshell_proto_msgTypes[136] + mi := &file_openshell_proto_msgTypes[138] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10788,7 +10910,7 @@ func (x *ExchangeProviderSubjectTokenRequest) String() string { func (*ExchangeProviderSubjectTokenRequest) ProtoMessage() {} func (x *ExchangeProviderSubjectTokenRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[136] + mi := &file_openshell_proto_msgTypes[138] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10801,7 +10923,7 @@ func (x *ExchangeProviderSubjectTokenRequest) ProtoReflect() protoreflect.Messag // Deprecated: Use ExchangeProviderSubjectTokenRequest.ProtoReflect.Descriptor instead. func (*ExchangeProviderSubjectTokenRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{136} + return file_openshell_proto_rawDescGZIP(), []int{138} } func (x *ExchangeProviderSubjectTokenRequest) GetSandboxId() string { @@ -10843,7 +10965,7 @@ type ExchangeProviderSubjectTokenResponse struct { func (x *ExchangeProviderSubjectTokenResponse) Reset() { *x = ExchangeProviderSubjectTokenResponse{} - mi := &file_openshell_proto_msgTypes[137] + mi := &file_openshell_proto_msgTypes[139] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10855,7 +10977,7 @@ func (x *ExchangeProviderSubjectTokenResponse) String() string { func (*ExchangeProviderSubjectTokenResponse) ProtoMessage() {} func (x *ExchangeProviderSubjectTokenResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[137] + mi := &file_openshell_proto_msgTypes[139] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10868,7 +10990,7 @@ func (x *ExchangeProviderSubjectTokenResponse) ProtoReflect() protoreflect.Messa // Deprecated: Use ExchangeProviderSubjectTokenResponse.ProtoReflect.Descriptor instead. func (*ExchangeProviderSubjectTokenResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{137} + return file_openshell_proto_rawDescGZIP(), []int{139} } func (x *ExchangeProviderSubjectTokenResponse) GetAccessToken() string { @@ -10943,7 +11065,7 @@ type UpdateConfigRequest struct { func (x *UpdateConfigRequest) Reset() { *x = UpdateConfigRequest{} - mi := &file_openshell_proto_msgTypes[138] + mi := &file_openshell_proto_msgTypes[140] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10955,7 +11077,7 @@ func (x *UpdateConfigRequest) String() string { func (*UpdateConfigRequest) ProtoMessage() {} func (x *UpdateConfigRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[138] + mi := &file_openshell_proto_msgTypes[140] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10968,7 +11090,7 @@ func (x *UpdateConfigRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use UpdateConfigRequest.ProtoReflect.Descriptor instead. func (*UpdateConfigRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{138} + return file_openshell_proto_rawDescGZIP(), []int{140} } func (x *UpdateConfigRequest) GetName() string { @@ -11065,7 +11187,7 @@ type PolicyMergeOperation struct { func (x *PolicyMergeOperation) Reset() { *x = PolicyMergeOperation{} - mi := &file_openshell_proto_msgTypes[139] + mi := &file_openshell_proto_msgTypes[141] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11077,7 +11199,7 @@ func (x *PolicyMergeOperation) String() string { func (*PolicyMergeOperation) ProtoMessage() {} func (x *PolicyMergeOperation) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[139] + mi := &file_openshell_proto_msgTypes[141] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11090,7 +11212,7 @@ func (x *PolicyMergeOperation) ProtoReflect() protoreflect.Message { // Deprecated: Use PolicyMergeOperation.ProtoReflect.Descriptor instead. func (*PolicyMergeOperation) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{139} + return file_openshell_proto_rawDescGZIP(), []int{141} } func (x *PolicyMergeOperation) GetOperation() isPolicyMergeOperation_Operation { @@ -11204,7 +11326,7 @@ type AddNetworkRule struct { func (x *AddNetworkRule) Reset() { *x = AddNetworkRule{} - mi := &file_openshell_proto_msgTypes[140] + mi := &file_openshell_proto_msgTypes[142] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11216,7 +11338,7 @@ func (x *AddNetworkRule) String() string { func (*AddNetworkRule) ProtoMessage() {} func (x *AddNetworkRule) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[140] + mi := &file_openshell_proto_msgTypes[142] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11229,7 +11351,7 @@ func (x *AddNetworkRule) ProtoReflect() protoreflect.Message { // Deprecated: Use AddNetworkRule.ProtoReflect.Descriptor instead. func (*AddNetworkRule) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{140} + return file_openshell_proto_rawDescGZIP(), []int{142} } func (x *AddNetworkRule) GetRuleName() string { @@ -11257,7 +11379,7 @@ type RemoveNetworkEndpoint struct { func (x *RemoveNetworkEndpoint) Reset() { *x = RemoveNetworkEndpoint{} - mi := &file_openshell_proto_msgTypes[141] + mi := &file_openshell_proto_msgTypes[143] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11269,7 +11391,7 @@ func (x *RemoveNetworkEndpoint) String() string { func (*RemoveNetworkEndpoint) ProtoMessage() {} func (x *RemoveNetworkEndpoint) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[141] + mi := &file_openshell_proto_msgTypes[143] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11282,7 +11404,7 @@ func (x *RemoveNetworkEndpoint) ProtoReflect() protoreflect.Message { // Deprecated: Use RemoveNetworkEndpoint.ProtoReflect.Descriptor instead. func (*RemoveNetworkEndpoint) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{141} + return file_openshell_proto_rawDescGZIP(), []int{143} } func (x *RemoveNetworkEndpoint) GetRuleName() string { @@ -11315,7 +11437,7 @@ type RemoveNetworkRule struct { func (x *RemoveNetworkRule) Reset() { *x = RemoveNetworkRule{} - mi := &file_openshell_proto_msgTypes[142] + mi := &file_openshell_proto_msgTypes[144] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11327,7 +11449,7 @@ func (x *RemoveNetworkRule) String() string { func (*RemoveNetworkRule) ProtoMessage() {} func (x *RemoveNetworkRule) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[142] + mi := &file_openshell_proto_msgTypes[144] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11340,7 +11462,7 @@ func (x *RemoveNetworkRule) ProtoReflect() protoreflect.Message { // Deprecated: Use RemoveNetworkRule.ProtoReflect.Descriptor instead. func (*RemoveNetworkRule) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{142} + return file_openshell_proto_rawDescGZIP(), []int{144} } func (x *RemoveNetworkRule) GetRuleName() string { @@ -11369,7 +11491,7 @@ type L7RuleTarget struct { func (x *L7RuleTarget) Reset() { *x = L7RuleTarget{} - mi := &file_openshell_proto_msgTypes[143] + mi := &file_openshell_proto_msgTypes[145] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11381,7 +11503,7 @@ func (x *L7RuleTarget) String() string { func (*L7RuleTarget) ProtoMessage() {} func (x *L7RuleTarget) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[143] + mi := &file_openshell_proto_msgTypes[145] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11394,7 +11516,7 @@ func (x *L7RuleTarget) ProtoReflect() protoreflect.Message { // Deprecated: Use L7RuleTarget.ProtoReflect.Descriptor instead. func (*L7RuleTarget) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{143} + return file_openshell_proto_rawDescGZIP(), []int{145} } func (x *L7RuleTarget) GetRuleName() string { @@ -11449,7 +11571,7 @@ type AddDenyRules struct { func (x *AddDenyRules) Reset() { *x = AddDenyRules{} - mi := &file_openshell_proto_msgTypes[144] + mi := &file_openshell_proto_msgTypes[146] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11461,7 +11583,7 @@ func (x *AddDenyRules) String() string { func (*AddDenyRules) ProtoMessage() {} func (x *AddDenyRules) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[144] + mi := &file_openshell_proto_msgTypes[146] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11474,7 +11596,7 @@ func (x *AddDenyRules) ProtoReflect() protoreflect.Message { // Deprecated: Use AddDenyRules.ProtoReflect.Descriptor instead. func (*AddDenyRules) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{144} + return file_openshell_proto_rawDescGZIP(), []int{146} } func (x *AddDenyRules) GetDenyRules() []*sandboxv1.L7DenyRule { @@ -11501,7 +11623,7 @@ type AddAllowRules struct { func (x *AddAllowRules) Reset() { *x = AddAllowRules{} - mi := &file_openshell_proto_msgTypes[145] + mi := &file_openshell_proto_msgTypes[147] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11513,7 +11635,7 @@ func (x *AddAllowRules) String() string { func (*AddAllowRules) ProtoMessage() {} func (x *AddAllowRules) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[145] + mi := &file_openshell_proto_msgTypes[147] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11526,7 +11648,7 @@ func (x *AddAllowRules) ProtoReflect() protoreflect.Message { // Deprecated: Use AddAllowRules.ProtoReflect.Descriptor instead. func (*AddAllowRules) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{145} + return file_openshell_proto_rawDescGZIP(), []int{147} } func (x *AddAllowRules) GetRules() []*sandboxv1.L7Rule { @@ -11553,7 +11675,7 @@ type RemoveNetworkBinary struct { func (x *RemoveNetworkBinary) Reset() { *x = RemoveNetworkBinary{} - mi := &file_openshell_proto_msgTypes[146] + mi := &file_openshell_proto_msgTypes[148] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11565,7 +11687,7 @@ func (x *RemoveNetworkBinary) String() string { func (*RemoveNetworkBinary) ProtoMessage() {} func (x *RemoveNetworkBinary) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[146] + mi := &file_openshell_proto_msgTypes[148] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11578,7 +11700,7 @@ func (x *RemoveNetworkBinary) ProtoReflect() protoreflect.Message { // Deprecated: Use RemoveNetworkBinary.ProtoReflect.Descriptor instead. func (*RemoveNetworkBinary) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{146} + return file_openshell_proto_rawDescGZIP(), []int{148} } func (x *RemoveNetworkBinary) GetRuleName() string { @@ -11614,7 +11736,7 @@ type UpdateConfigResponse struct { func (x *UpdateConfigResponse) Reset() { *x = UpdateConfigResponse{} - mi := &file_openshell_proto_msgTypes[147] + mi := &file_openshell_proto_msgTypes[149] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11626,7 +11748,7 @@ func (x *UpdateConfigResponse) String() string { func (*UpdateConfigResponse) ProtoMessage() {} func (x *UpdateConfigResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[147] + mi := &file_openshell_proto_msgTypes[149] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11639,7 +11761,7 @@ func (x *UpdateConfigResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use UpdateConfigResponse.ProtoReflect.Descriptor instead. func (*UpdateConfigResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{147} + return file_openshell_proto_rawDescGZIP(), []int{149} } func (x *UpdateConfigResponse) GetVersion() uint32 { @@ -11695,7 +11817,7 @@ type GetSandboxPolicyStatusRequest struct { func (x *GetSandboxPolicyStatusRequest) Reset() { *x = GetSandboxPolicyStatusRequest{} - mi := &file_openshell_proto_msgTypes[148] + mi := &file_openshell_proto_msgTypes[150] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11707,7 +11829,7 @@ func (x *GetSandboxPolicyStatusRequest) String() string { func (*GetSandboxPolicyStatusRequest) ProtoMessage() {} func (x *GetSandboxPolicyStatusRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[148] + mi := &file_openshell_proto_msgTypes[150] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11720,7 +11842,7 @@ func (x *GetSandboxPolicyStatusRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetSandboxPolicyStatusRequest.ProtoReflect.Descriptor instead. func (*GetSandboxPolicyStatusRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{148} + return file_openshell_proto_rawDescGZIP(), []int{150} } func (x *GetSandboxPolicyStatusRequest) GetName() string { @@ -11764,7 +11886,7 @@ type GetSandboxPolicyStatusResponse struct { func (x *GetSandboxPolicyStatusResponse) Reset() { *x = GetSandboxPolicyStatusResponse{} - mi := &file_openshell_proto_msgTypes[149] + mi := &file_openshell_proto_msgTypes[151] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11776,7 +11898,7 @@ func (x *GetSandboxPolicyStatusResponse) String() string { func (*GetSandboxPolicyStatusResponse) ProtoMessage() {} func (x *GetSandboxPolicyStatusResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[149] + mi := &file_openshell_proto_msgTypes[151] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11789,7 +11911,7 @@ func (x *GetSandboxPolicyStatusResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use GetSandboxPolicyStatusResponse.ProtoReflect.Descriptor instead. func (*GetSandboxPolicyStatusResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{149} + return file_openshell_proto_rawDescGZIP(), []int{151} } func (x *GetSandboxPolicyStatusResponse) GetRevision() *SandboxPolicyRevision { @@ -11828,7 +11950,7 @@ type ListSandboxPoliciesRequest struct { func (x *ListSandboxPoliciesRequest) Reset() { *x = ListSandboxPoliciesRequest{} - mi := &file_openshell_proto_msgTypes[150] + mi := &file_openshell_proto_msgTypes[152] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11840,7 +11962,7 @@ func (x *ListSandboxPoliciesRequest) String() string { func (*ListSandboxPoliciesRequest) ProtoMessage() {} func (x *ListSandboxPoliciesRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[150] + mi := &file_openshell_proto_msgTypes[152] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11853,7 +11975,7 @@ func (x *ListSandboxPoliciesRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListSandboxPoliciesRequest.ProtoReflect.Descriptor instead. func (*ListSandboxPoliciesRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{150} + return file_openshell_proto_rawDescGZIP(), []int{152} } func (x *ListSandboxPoliciesRequest) GetName() string { @@ -11905,7 +12027,7 @@ type ListSandboxPoliciesResponse struct { func (x *ListSandboxPoliciesResponse) Reset() { *x = ListSandboxPoliciesResponse{} - mi := &file_openshell_proto_msgTypes[151] + mi := &file_openshell_proto_msgTypes[153] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11917,7 +12039,7 @@ func (x *ListSandboxPoliciesResponse) String() string { func (*ListSandboxPoliciesResponse) ProtoMessage() {} func (x *ListSandboxPoliciesResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[151] + mi := &file_openshell_proto_msgTypes[153] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11930,7 +12052,7 @@ func (x *ListSandboxPoliciesResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListSandboxPoliciesResponse.ProtoReflect.Descriptor instead. func (*ListSandboxPoliciesResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{151} + return file_openshell_proto_rawDescGZIP(), []int{153} } func (x *ListSandboxPoliciesResponse) GetRevisions() []*SandboxPolicyRevision { @@ -11964,7 +12086,7 @@ type ReportPolicyStatusRequest struct { func (x *ReportPolicyStatusRequest) Reset() { *x = ReportPolicyStatusRequest{} - mi := &file_openshell_proto_msgTypes[152] + mi := &file_openshell_proto_msgTypes[154] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11976,7 +12098,7 @@ func (x *ReportPolicyStatusRequest) String() string { func (*ReportPolicyStatusRequest) ProtoMessage() {} func (x *ReportPolicyStatusRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[152] + mi := &file_openshell_proto_msgTypes[154] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11989,7 +12111,7 @@ func (x *ReportPolicyStatusRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ReportPolicyStatusRequest.ProtoReflect.Descriptor instead. func (*ReportPolicyStatusRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{152} + return file_openshell_proto_rawDescGZIP(), []int{154} } func (x *ReportPolicyStatusRequest) GetSandboxId() string { @@ -12029,7 +12151,7 @@ type ReportPolicyStatusResponse struct { func (x *ReportPolicyStatusResponse) Reset() { *x = ReportPolicyStatusResponse{} - mi := &file_openshell_proto_msgTypes[153] + mi := &file_openshell_proto_msgTypes[155] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12041,7 +12163,7 @@ func (x *ReportPolicyStatusResponse) String() string { func (*ReportPolicyStatusResponse) ProtoMessage() {} func (x *ReportPolicyStatusResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[153] + mi := &file_openshell_proto_msgTypes[155] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12054,7 +12176,7 @@ func (x *ReportPolicyStatusResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ReportPolicyStatusResponse.ProtoReflect.Descriptor instead. func (*ReportPolicyStatusResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{153} + return file_openshell_proto_rawDescGZIP(), []int{155} } type SandboxConfigurationAdmission struct { @@ -12072,7 +12194,7 @@ type SandboxConfigurationAdmission struct { func (x *SandboxConfigurationAdmission) Reset() { *x = SandboxConfigurationAdmission{} - mi := &file_openshell_proto_msgTypes[154] + mi := &file_openshell_proto_msgTypes[156] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12084,7 +12206,7 @@ func (x *SandboxConfigurationAdmission) String() string { func (*SandboxConfigurationAdmission) ProtoMessage() {} func (x *SandboxConfigurationAdmission) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[154] + mi := &file_openshell_proto_msgTypes[156] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12097,7 +12219,7 @@ func (x *SandboxConfigurationAdmission) ProtoReflect() protoreflect.Message { // Deprecated: Use SandboxConfigurationAdmission.ProtoReflect.Descriptor instead. func (*SandboxConfigurationAdmission) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{154} + return file_openshell_proto_rawDescGZIP(), []int{156} } func (x *SandboxConfigurationAdmission) GetInstanceId() string { @@ -12161,7 +12283,7 @@ type ReportSandboxConfigurationRequest struct { func (x *ReportSandboxConfigurationRequest) Reset() { *x = ReportSandboxConfigurationRequest{} - mi := &file_openshell_proto_msgTypes[155] + mi := &file_openshell_proto_msgTypes[157] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12173,7 +12295,7 @@ func (x *ReportSandboxConfigurationRequest) String() string { func (*ReportSandboxConfigurationRequest) ProtoMessage() {} func (x *ReportSandboxConfigurationRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[155] + mi := &file_openshell_proto_msgTypes[157] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12186,7 +12308,7 @@ func (x *ReportSandboxConfigurationRequest) ProtoReflect() protoreflect.Message // Deprecated: Use ReportSandboxConfigurationRequest.ProtoReflect.Descriptor instead. func (*ReportSandboxConfigurationRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{155} + return file_openshell_proto_rawDescGZIP(), []int{157} } func (x *ReportSandboxConfigurationRequest) GetSandboxId() string { @@ -12218,7 +12340,7 @@ type ReportSandboxConfigurationResponse struct { func (x *ReportSandboxConfigurationResponse) Reset() { *x = ReportSandboxConfigurationResponse{} - mi := &file_openshell_proto_msgTypes[156] + mi := &file_openshell_proto_msgTypes[158] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12230,7 +12352,7 @@ func (x *ReportSandboxConfigurationResponse) String() string { func (*ReportSandboxConfigurationResponse) ProtoMessage() {} func (x *ReportSandboxConfigurationResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[156] + mi := &file_openshell_proto_msgTypes[158] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12243,7 +12365,7 @@ func (x *ReportSandboxConfigurationResponse) ProtoReflect() protoreflect.Message // Deprecated: Use ReportSandboxConfigurationResponse.ProtoReflect.Descriptor instead. func (*ReportSandboxConfigurationResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{156} + return file_openshell_proto_rawDescGZIP(), []int{158} } // A versioned policy revision with metadata. @@ -12276,7 +12398,7 @@ type SandboxPolicyRevision struct { func (x *SandboxPolicyRevision) Reset() { *x = SandboxPolicyRevision{} - mi := &file_openshell_proto_msgTypes[157] + mi := &file_openshell_proto_msgTypes[159] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12288,7 +12410,7 @@ func (x *SandboxPolicyRevision) String() string { func (*SandboxPolicyRevision) ProtoMessage() {} func (x *SandboxPolicyRevision) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[157] + mi := &file_openshell_proto_msgTypes[159] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12301,7 +12423,7 @@ func (x *SandboxPolicyRevision) ProtoReflect() protoreflect.Message { // Deprecated: Use SandboxPolicyRevision.ProtoReflect.Descriptor instead. func (*SandboxPolicyRevision) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{157} + return file_openshell_proto_rawDescGZIP(), []int{159} } func (x *SandboxPolicyRevision) GetVersion() uint32 { @@ -12381,7 +12503,7 @@ type GetSandboxLogsRequest struct { func (x *GetSandboxLogsRequest) Reset() { *x = GetSandboxLogsRequest{} - mi := &file_openshell_proto_msgTypes[158] + mi := &file_openshell_proto_msgTypes[160] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12393,7 +12515,7 @@ func (x *GetSandboxLogsRequest) String() string { func (*GetSandboxLogsRequest) ProtoMessage() {} func (x *GetSandboxLogsRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[158] + mi := &file_openshell_proto_msgTypes[160] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12406,7 +12528,7 @@ func (x *GetSandboxLogsRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetSandboxLogsRequest.ProtoReflect.Descriptor instead. func (*GetSandboxLogsRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{158} + return file_openshell_proto_rawDescGZIP(), []int{160} } func (x *GetSandboxLogsRequest) GetSandboxId() string { @@ -12464,7 +12586,7 @@ type PushSandboxLogsRequest struct { func (x *PushSandboxLogsRequest) Reset() { *x = PushSandboxLogsRequest{} - mi := &file_openshell_proto_msgTypes[159] + mi := &file_openshell_proto_msgTypes[161] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12476,7 +12598,7 @@ func (x *PushSandboxLogsRequest) String() string { func (*PushSandboxLogsRequest) ProtoMessage() {} func (x *PushSandboxLogsRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[159] + mi := &file_openshell_proto_msgTypes[161] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12489,7 +12611,7 @@ func (x *PushSandboxLogsRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use PushSandboxLogsRequest.ProtoReflect.Descriptor instead. func (*PushSandboxLogsRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{159} + return file_openshell_proto_rawDescGZIP(), []int{161} } func (x *PushSandboxLogsRequest) GetSandboxId() string { @@ -12515,7 +12637,7 @@ type PushSandboxLogsResponse struct { func (x *PushSandboxLogsResponse) Reset() { *x = PushSandboxLogsResponse{} - mi := &file_openshell_proto_msgTypes[160] + mi := &file_openshell_proto_msgTypes[162] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12527,7 +12649,7 @@ func (x *PushSandboxLogsResponse) String() string { func (*PushSandboxLogsResponse) ProtoMessage() {} func (x *PushSandboxLogsResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[160] + mi := &file_openshell_proto_msgTypes[162] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12540,7 +12662,7 @@ func (x *PushSandboxLogsResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use PushSandboxLogsResponse.ProtoReflect.Descriptor instead. func (*PushSandboxLogsResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{160} + return file_openshell_proto_rawDescGZIP(), []int{162} } // Get sandbox logs response. @@ -12556,7 +12678,7 @@ type GetSandboxLogsResponse struct { func (x *GetSandboxLogsResponse) Reset() { *x = GetSandboxLogsResponse{} - mi := &file_openshell_proto_msgTypes[161] + mi := &file_openshell_proto_msgTypes[163] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12568,7 +12690,7 @@ func (x *GetSandboxLogsResponse) String() string { func (*GetSandboxLogsResponse) ProtoMessage() {} func (x *GetSandboxLogsResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[161] + mi := &file_openshell_proto_msgTypes[163] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12581,7 +12703,7 @@ func (x *GetSandboxLogsResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use GetSandboxLogsResponse.ProtoReflect.Descriptor instead. func (*GetSandboxLogsResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{161} + return file_openshell_proto_rawDescGZIP(), []int{163} } func (x *GetSandboxLogsResponse) GetLogs() []*SandboxLogLine { @@ -12614,7 +12736,7 @@ type SupervisorMessage struct { func (x *SupervisorMessage) Reset() { *x = SupervisorMessage{} - mi := &file_openshell_proto_msgTypes[162] + mi := &file_openshell_proto_msgTypes[164] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12626,7 +12748,7 @@ func (x *SupervisorMessage) String() string { func (*SupervisorMessage) ProtoMessage() {} func (x *SupervisorMessage) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[162] + mi := &file_openshell_proto_msgTypes[164] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12639,7 +12761,7 @@ func (x *SupervisorMessage) ProtoReflect() protoreflect.Message { // Deprecated: Use SupervisorMessage.ProtoReflect.Descriptor instead. func (*SupervisorMessage) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{162} + return file_openshell_proto_rawDescGZIP(), []int{164} } func (x *SupervisorMessage) GetPayload() isSupervisorMessage_Payload { @@ -12730,7 +12852,7 @@ type GatewayMessage struct { func (x *GatewayMessage) Reset() { *x = GatewayMessage{} - mi := &file_openshell_proto_msgTypes[163] + mi := &file_openshell_proto_msgTypes[165] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12742,7 +12864,7 @@ func (x *GatewayMessage) String() string { func (*GatewayMessage) ProtoMessage() {} func (x *GatewayMessage) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[163] + mi := &file_openshell_proto_msgTypes[165] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12755,7 +12877,7 @@ func (x *GatewayMessage) ProtoReflect() protoreflect.Message { // Deprecated: Use GatewayMessage.ProtoReflect.Descriptor instead. func (*GatewayMessage) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{163} + return file_openshell_proto_rawDescGZIP(), []int{165} } func (x *GatewayMessage) GetPayload() isGatewayMessage_Payload { @@ -12859,7 +12981,7 @@ type SupervisorHello struct { func (x *SupervisorHello) Reset() { *x = SupervisorHello{} - mi := &file_openshell_proto_msgTypes[164] + mi := &file_openshell_proto_msgTypes[166] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12871,7 +12993,7 @@ func (x *SupervisorHello) String() string { func (*SupervisorHello) ProtoMessage() {} func (x *SupervisorHello) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[164] + mi := &file_openshell_proto_msgTypes[166] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12884,7 +13006,7 @@ func (x *SupervisorHello) ProtoReflect() protoreflect.Message { // Deprecated: Use SupervisorHello.ProtoReflect.Descriptor instead. func (*SupervisorHello) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{164} + return file_openshell_proto_rawDescGZIP(), []int{166} } func (x *SupervisorHello) GetSandboxId() string { @@ -12921,7 +13043,7 @@ type SessionAccepted struct { func (x *SessionAccepted) Reset() { *x = SessionAccepted{} - mi := &file_openshell_proto_msgTypes[165] + mi := &file_openshell_proto_msgTypes[167] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12933,7 +13055,7 @@ func (x *SessionAccepted) String() string { func (*SessionAccepted) ProtoMessage() {} func (x *SessionAccepted) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[165] + mi := &file_openshell_proto_msgTypes[167] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12946,7 +13068,7 @@ func (x *SessionAccepted) ProtoReflect() protoreflect.Message { // Deprecated: Use SessionAccepted.ProtoReflect.Descriptor instead. func (*SessionAccepted) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{165} + return file_openshell_proto_rawDescGZIP(), []int{167} } func (x *SessionAccepted) GetSessionId() string { @@ -12974,7 +13096,7 @@ type SessionRejected struct { func (x *SessionRejected) Reset() { *x = SessionRejected{} - mi := &file_openshell_proto_msgTypes[166] + mi := &file_openshell_proto_msgTypes[168] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12986,7 +13108,7 @@ func (x *SessionRejected) String() string { func (*SessionRejected) ProtoMessage() {} func (x *SessionRejected) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[166] + mi := &file_openshell_proto_msgTypes[168] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12999,7 +13121,7 @@ func (x *SessionRejected) ProtoReflect() protoreflect.Message { // Deprecated: Use SessionRejected.ProtoReflect.Descriptor instead. func (*SessionRejected) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{166} + return file_openshell_proto_rawDescGZIP(), []int{168} } func (x *SessionRejected) GetReason() string { @@ -13018,7 +13140,7 @@ type SupervisorHeartbeat struct { func (x *SupervisorHeartbeat) Reset() { *x = SupervisorHeartbeat{} - mi := &file_openshell_proto_msgTypes[167] + mi := &file_openshell_proto_msgTypes[169] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13030,7 +13152,7 @@ func (x *SupervisorHeartbeat) String() string { func (*SupervisorHeartbeat) ProtoMessage() {} func (x *SupervisorHeartbeat) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[167] + mi := &file_openshell_proto_msgTypes[169] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13043,7 +13165,7 @@ func (x *SupervisorHeartbeat) ProtoReflect() protoreflect.Message { // Deprecated: Use SupervisorHeartbeat.ProtoReflect.Descriptor instead. func (*SupervisorHeartbeat) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{167} + return file_openshell_proto_rawDescGZIP(), []int{169} } // Gateway heartbeat. @@ -13055,7 +13177,7 @@ type GatewayHeartbeat struct { func (x *GatewayHeartbeat) Reset() { *x = GatewayHeartbeat{} - mi := &file_openshell_proto_msgTypes[168] + mi := &file_openshell_proto_msgTypes[170] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13067,7 +13189,7 @@ func (x *GatewayHeartbeat) String() string { func (*GatewayHeartbeat) ProtoMessage() {} func (x *GatewayHeartbeat) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[168] + mi := &file_openshell_proto_msgTypes[170] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13080,7 +13202,7 @@ func (x *GatewayHeartbeat) ProtoReflect() protoreflect.Message { // Deprecated: Use GatewayHeartbeat.ProtoReflect.Descriptor instead. func (*GatewayHeartbeat) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{168} + return file_openshell_proto_rawDescGZIP(), []int{170} } // Terminal result reported before the supervisor shuts down. A successful RPC @@ -13097,7 +13219,7 @@ type ReportMainProcessExitRequest struct { func (x *ReportMainProcessExitRequest) Reset() { *x = ReportMainProcessExitRequest{} - mi := &file_openshell_proto_msgTypes[169] + mi := &file_openshell_proto_msgTypes[171] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13109,7 +13231,7 @@ func (x *ReportMainProcessExitRequest) String() string { func (*ReportMainProcessExitRequest) ProtoMessage() {} func (x *ReportMainProcessExitRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[169] + mi := &file_openshell_proto_msgTypes[171] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13122,7 +13244,7 @@ func (x *ReportMainProcessExitRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ReportMainProcessExitRequest.ProtoReflect.Descriptor instead. func (*ReportMainProcessExitRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{169} + return file_openshell_proto_rawDescGZIP(), []int{171} } func (x *ReportMainProcessExitRequest) GetSandboxId() string { @@ -13154,7 +13276,7 @@ type ReportMainProcessExitResponse struct { func (x *ReportMainProcessExitResponse) Reset() { *x = ReportMainProcessExitResponse{} - mi := &file_openshell_proto_msgTypes[170] + mi := &file_openshell_proto_msgTypes[172] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13166,7 +13288,7 @@ func (x *ReportMainProcessExitResponse) String() string { func (*ReportMainProcessExitResponse) ProtoMessage() {} func (x *ReportMainProcessExitResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[170] + mi := &file_openshell_proto_msgTypes[172] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13179,7 +13301,7 @@ func (x *ReportMainProcessExitResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ReportMainProcessExitResponse.ProtoReflect.Descriptor instead. func (*ReportMainProcessExitResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{170} + return file_openshell_proto_rawDescGZIP(), []int{172} } // Terminal-delivery completion reported after all expected foreground SSH @@ -13194,7 +13316,7 @@ type FinalizeMainProcessExitRequest struct { func (x *FinalizeMainProcessExitRequest) Reset() { *x = FinalizeMainProcessExitRequest{} - mi := &file_openshell_proto_msgTypes[171] + mi := &file_openshell_proto_msgTypes[173] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13206,7 +13328,7 @@ func (x *FinalizeMainProcessExitRequest) String() string { func (*FinalizeMainProcessExitRequest) ProtoMessage() {} func (x *FinalizeMainProcessExitRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[171] + mi := &file_openshell_proto_msgTypes[173] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13219,7 +13341,7 @@ func (x *FinalizeMainProcessExitRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use FinalizeMainProcessExitRequest.ProtoReflect.Descriptor instead. func (*FinalizeMainProcessExitRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{171} + return file_openshell_proto_rawDescGZIP(), []int{173} } func (x *FinalizeMainProcessExitRequest) GetSandboxId() string { @@ -13244,7 +13366,7 @@ type FinalizeMainProcessExitResponse struct { func (x *FinalizeMainProcessExitResponse) Reset() { *x = FinalizeMainProcessExitResponse{} - mi := &file_openshell_proto_msgTypes[172] + mi := &file_openshell_proto_msgTypes[174] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13256,7 +13378,7 @@ func (x *FinalizeMainProcessExitResponse) String() string { func (*FinalizeMainProcessExitResponse) ProtoMessage() {} func (x *FinalizeMainProcessExitResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[172] + mi := &file_openshell_proto_msgTypes[174] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13269,7 +13391,7 @@ func (x *FinalizeMainProcessExitResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use FinalizeMainProcessExitResponse.ProtoReflect.Descriptor instead. func (*FinalizeMainProcessExitResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{172} + return file_openshell_proto_rawDescGZIP(), []int{174} } // Gateway requests the supervisor to open a relay channel. @@ -13298,7 +13420,7 @@ type RelayOpen struct { func (x *RelayOpen) Reset() { *x = RelayOpen{} - mi := &file_openshell_proto_msgTypes[173] + mi := &file_openshell_proto_msgTypes[175] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13310,7 +13432,7 @@ func (x *RelayOpen) String() string { func (*RelayOpen) ProtoMessage() {} func (x *RelayOpen) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[173] + mi := &file_openshell_proto_msgTypes[175] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13323,7 +13445,7 @@ func (x *RelayOpen) ProtoReflect() protoreflect.Message { // Deprecated: Use RelayOpen.ProtoReflect.Descriptor instead. func (*RelayOpen) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{173} + return file_openshell_proto_rawDescGZIP(), []int{175} } func (x *RelayOpen) GetChannelId() string { @@ -13390,7 +13512,7 @@ type SshRelayTarget struct { func (x *SshRelayTarget) Reset() { *x = SshRelayTarget{} - mi := &file_openshell_proto_msgTypes[174] + mi := &file_openshell_proto_msgTypes[176] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13402,7 +13524,7 @@ func (x *SshRelayTarget) String() string { func (*SshRelayTarget) ProtoMessage() {} func (x *SshRelayTarget) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[174] + mi := &file_openshell_proto_msgTypes[176] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13415,7 +13537,7 @@ func (x *SshRelayTarget) ProtoReflect() protoreflect.Message { // Deprecated: Use SshRelayTarget.ProtoReflect.Descriptor instead. func (*SshRelayTarget) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{174} + return file_openshell_proto_rawDescGZIP(), []int{176} } // TCP target dialed by the supervisor from inside the sandbox. @@ -13431,7 +13553,7 @@ type TcpRelayTarget struct { func (x *TcpRelayTarget) Reset() { *x = TcpRelayTarget{} - mi := &file_openshell_proto_msgTypes[175] + mi := &file_openshell_proto_msgTypes[177] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13443,7 +13565,7 @@ func (x *TcpRelayTarget) String() string { func (*TcpRelayTarget) ProtoMessage() {} func (x *TcpRelayTarget) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[175] + mi := &file_openshell_proto_msgTypes[177] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13456,7 +13578,7 @@ func (x *TcpRelayTarget) ProtoReflect() protoreflect.Message { // Deprecated: Use TcpRelayTarget.ProtoReflect.Descriptor instead. func (*TcpRelayTarget) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{175} + return file_openshell_proto_rawDescGZIP(), []int{177} } func (x *TcpRelayTarget) GetHost() string { @@ -13484,7 +13606,7 @@ type RelayInit struct { func (x *RelayInit) Reset() { *x = RelayInit{} - mi := &file_openshell_proto_msgTypes[176] + mi := &file_openshell_proto_msgTypes[178] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13496,7 +13618,7 @@ func (x *RelayInit) String() string { func (*RelayInit) ProtoMessage() {} func (x *RelayInit) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[176] + mi := &file_openshell_proto_msgTypes[178] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13509,7 +13631,7 @@ func (x *RelayInit) ProtoReflect() protoreflect.Message { // Deprecated: Use RelayInit.ProtoReflect.Descriptor instead. func (*RelayInit) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{176} + return file_openshell_proto_rawDescGZIP(), []int{178} } func (x *RelayInit) GetChannelId() string { @@ -13536,7 +13658,7 @@ type RelayFrame struct { func (x *RelayFrame) Reset() { *x = RelayFrame{} - mi := &file_openshell_proto_msgTypes[177] + mi := &file_openshell_proto_msgTypes[179] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13548,7 +13670,7 @@ func (x *RelayFrame) String() string { func (*RelayFrame) ProtoMessage() {} func (x *RelayFrame) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[177] + mi := &file_openshell_proto_msgTypes[179] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13561,7 +13683,7 @@ func (x *RelayFrame) ProtoReflect() protoreflect.Message { // Deprecated: Use RelayFrame.ProtoReflect.Descriptor instead. func (*RelayFrame) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{177} + return file_openshell_proto_rawDescGZIP(), []int{179} } func (x *RelayFrame) GetPayload() isRelayFrame_Payload { @@ -13620,7 +13742,7 @@ type RelayOpenResult struct { func (x *RelayOpenResult) Reset() { *x = RelayOpenResult{} - mi := &file_openshell_proto_msgTypes[178] + mi := &file_openshell_proto_msgTypes[180] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13632,7 +13754,7 @@ func (x *RelayOpenResult) String() string { func (*RelayOpenResult) ProtoMessage() {} func (x *RelayOpenResult) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[178] + mi := &file_openshell_proto_msgTypes[180] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13645,7 +13767,7 @@ func (x *RelayOpenResult) ProtoReflect() protoreflect.Message { // Deprecated: Use RelayOpenResult.ProtoReflect.Descriptor instead. func (*RelayOpenResult) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{178} + return file_openshell_proto_rawDescGZIP(), []int{180} } func (x *RelayOpenResult) GetChannelId() string { @@ -13682,7 +13804,7 @@ type RelayClose struct { func (x *RelayClose) Reset() { *x = RelayClose{} - mi := &file_openshell_proto_msgTypes[179] + mi := &file_openshell_proto_msgTypes[181] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13694,7 +13816,7 @@ func (x *RelayClose) String() string { func (*RelayClose) ProtoMessage() {} func (x *RelayClose) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[179] + mi := &file_openshell_proto_msgTypes[181] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13707,7 +13829,7 @@ func (x *RelayClose) ProtoReflect() protoreflect.Message { // Deprecated: Use RelayClose.ProtoReflect.Descriptor instead. func (*RelayClose) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{179} + return file_openshell_proto_rawDescGZIP(), []int{181} } func (x *RelayClose) GetChannelId() string { @@ -13741,7 +13863,7 @@ type L7RequestSample struct { func (x *L7RequestSample) Reset() { *x = L7RequestSample{} - mi := &file_openshell_proto_msgTypes[180] + mi := &file_openshell_proto_msgTypes[182] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13753,7 +13875,7 @@ func (x *L7RequestSample) String() string { func (*L7RequestSample) ProtoMessage() {} func (x *L7RequestSample) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[180] + mi := &file_openshell_proto_msgTypes[182] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13766,7 +13888,7 @@ func (x *L7RequestSample) ProtoReflect() protoreflect.Message { // Deprecated: Use L7RequestSample.ProtoReflect.Descriptor instead. func (*L7RequestSample) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{180} + return file_openshell_proto_rawDescGZIP(), []int{182} } func (x *L7RequestSample) GetMethod() string { @@ -13840,7 +13962,7 @@ type DenialSummary struct { func (x *DenialSummary) Reset() { *x = DenialSummary{} - mi := &file_openshell_proto_msgTypes[181] + mi := &file_openshell_proto_msgTypes[183] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13852,7 +13974,7 @@ func (x *DenialSummary) String() string { func (*DenialSummary) ProtoMessage() {} func (x *DenialSummary) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[181] + mi := &file_openshell_proto_msgTypes[183] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13865,7 +13987,7 @@ func (x *DenialSummary) ProtoReflect() protoreflect.Message { // Deprecated: Use DenialSummary.ProtoReflect.Descriptor instead. func (*DenialSummary) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{181} + return file_openshell_proto_rawDescGZIP(), []int{183} } func (x *DenialSummary) GetSandboxId() string { @@ -14000,7 +14122,7 @@ type DenialGroupCount struct { func (x *DenialGroupCount) Reset() { *x = DenialGroupCount{} - mi := &file_openshell_proto_msgTypes[182] + mi := &file_openshell_proto_msgTypes[184] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14012,7 +14134,7 @@ func (x *DenialGroupCount) String() string { func (*DenialGroupCount) ProtoMessage() {} func (x *DenialGroupCount) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[182] + mi := &file_openshell_proto_msgTypes[184] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14025,7 +14147,7 @@ func (x *DenialGroupCount) ProtoReflect() protoreflect.Message { // Deprecated: Use DenialGroupCount.ProtoReflect.Descriptor instead. func (*DenialGroupCount) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{182} + return file_openshell_proto_rawDescGZIP(), []int{184} } func (x *DenialGroupCount) GetDenyGroup() string { @@ -14058,7 +14180,7 @@ type NetworkActivitySummary struct { func (x *NetworkActivitySummary) Reset() { *x = NetworkActivitySummary{} - mi := &file_openshell_proto_msgTypes[183] + mi := &file_openshell_proto_msgTypes[185] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14070,7 +14192,7 @@ func (x *NetworkActivitySummary) String() string { func (*NetworkActivitySummary) ProtoMessage() {} func (x *NetworkActivitySummary) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[183] + mi := &file_openshell_proto_msgTypes[185] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14083,7 +14205,7 @@ func (x *NetworkActivitySummary) ProtoReflect() protoreflect.Message { // Deprecated: Use NetworkActivitySummary.ProtoReflect.Descriptor instead. func (*NetworkActivitySummary) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{183} + return file_openshell_proto_rawDescGZIP(), []int{185} } func (x *NetworkActivitySummary) GetNetworkActivityCount() uint32 { @@ -14171,7 +14293,7 @@ type PolicyChunk struct { func (x *PolicyChunk) Reset() { *x = PolicyChunk{} - mi := &file_openshell_proto_msgTypes[184] + mi := &file_openshell_proto_msgTypes[186] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14183,7 +14305,7 @@ func (x *PolicyChunk) String() string { func (*PolicyChunk) ProtoMessage() {} func (x *PolicyChunk) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[184] + mi := &file_openshell_proto_msgTypes[186] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14196,7 +14318,7 @@ func (x *PolicyChunk) ProtoReflect() protoreflect.Message { // Deprecated: Use PolicyChunk.ProtoReflect.Descriptor instead. func (*PolicyChunk) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{184} + return file_openshell_proto_rawDescGZIP(), []int{186} } func (x *PolicyChunk) GetId() string { @@ -14384,7 +14506,7 @@ type DraftPolicyUpdate struct { func (x *DraftPolicyUpdate) Reset() { *x = DraftPolicyUpdate{} - mi := &file_openshell_proto_msgTypes[185] + mi := &file_openshell_proto_msgTypes[187] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14396,7 +14518,7 @@ func (x *DraftPolicyUpdate) String() string { func (*DraftPolicyUpdate) ProtoMessage() {} func (x *DraftPolicyUpdate) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[185] + mi := &file_openshell_proto_msgTypes[187] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14409,7 +14531,7 @@ func (x *DraftPolicyUpdate) ProtoReflect() protoreflect.Message { // Deprecated: Use DraftPolicyUpdate.ProtoReflect.Descriptor instead. func (*DraftPolicyUpdate) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{185} + return file_openshell_proto_rawDescGZIP(), []int{187} } func (x *DraftPolicyUpdate) GetDraftVersion() uint64 { @@ -14467,7 +14589,7 @@ type SubmitPolicyAnalysisRequest struct { func (x *SubmitPolicyAnalysisRequest) Reset() { *x = SubmitPolicyAnalysisRequest{} - mi := &file_openshell_proto_msgTypes[186] + mi := &file_openshell_proto_msgTypes[188] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14479,7 +14601,7 @@ func (x *SubmitPolicyAnalysisRequest) String() string { func (*SubmitPolicyAnalysisRequest) ProtoMessage() {} func (x *SubmitPolicyAnalysisRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[186] + mi := &file_openshell_proto_msgTypes[188] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14492,7 +14614,7 @@ func (x *SubmitPolicyAnalysisRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use SubmitPolicyAnalysisRequest.ProtoReflect.Descriptor instead. func (*SubmitPolicyAnalysisRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{186} + return file_openshell_proto_rawDescGZIP(), []int{188} } func (x *SubmitPolicyAnalysisRequest) GetSummaries() []*DenialSummary { @@ -14555,7 +14677,7 @@ type SubmitPolicyAnalysisResponse struct { func (x *SubmitPolicyAnalysisResponse) Reset() { *x = SubmitPolicyAnalysisResponse{} - mi := &file_openshell_proto_msgTypes[187] + mi := &file_openshell_proto_msgTypes[189] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14567,7 +14689,7 @@ func (x *SubmitPolicyAnalysisResponse) String() string { func (*SubmitPolicyAnalysisResponse) ProtoMessage() {} func (x *SubmitPolicyAnalysisResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[187] + mi := &file_openshell_proto_msgTypes[189] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14580,7 +14702,7 @@ func (x *SubmitPolicyAnalysisResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use SubmitPolicyAnalysisResponse.ProtoReflect.Descriptor instead. func (*SubmitPolicyAnalysisResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{187} + return file_openshell_proto_rawDescGZIP(), []int{189} } func (x *SubmitPolicyAnalysisResponse) GetAcceptedChunks() uint32 { @@ -14626,7 +14748,7 @@ type GetDraftPolicyRequest struct { func (x *GetDraftPolicyRequest) Reset() { *x = GetDraftPolicyRequest{} - mi := &file_openshell_proto_msgTypes[188] + mi := &file_openshell_proto_msgTypes[190] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14638,7 +14760,7 @@ func (x *GetDraftPolicyRequest) String() string { func (*GetDraftPolicyRequest) ProtoMessage() {} func (x *GetDraftPolicyRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[188] + mi := &file_openshell_proto_msgTypes[190] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14651,7 +14773,7 @@ func (x *GetDraftPolicyRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetDraftPolicyRequest.ProtoReflect.Descriptor instead. func (*GetDraftPolicyRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{188} + return file_openshell_proto_rawDescGZIP(), []int{190} } func (x *GetDraftPolicyRequest) GetName() string { @@ -14691,7 +14813,7 @@ type GetDraftPolicyResponse struct { func (x *GetDraftPolicyResponse) Reset() { *x = GetDraftPolicyResponse{} - mi := &file_openshell_proto_msgTypes[189] + mi := &file_openshell_proto_msgTypes[191] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14703,7 +14825,7 @@ func (x *GetDraftPolicyResponse) String() string { func (*GetDraftPolicyResponse) ProtoMessage() {} func (x *GetDraftPolicyResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[189] + mi := &file_openshell_proto_msgTypes[191] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14716,7 +14838,7 @@ func (x *GetDraftPolicyResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use GetDraftPolicyResponse.ProtoReflect.Descriptor instead. func (*GetDraftPolicyResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{189} + return file_openshell_proto_rawDescGZIP(), []int{191} } func (x *GetDraftPolicyResponse) GetChunks() []*PolicyChunk { @@ -14768,7 +14890,7 @@ type ApproveDraftChunkRequest struct { func (x *ApproveDraftChunkRequest) Reset() { *x = ApproveDraftChunkRequest{} - mi := &file_openshell_proto_msgTypes[190] + mi := &file_openshell_proto_msgTypes[192] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14780,7 +14902,7 @@ func (x *ApproveDraftChunkRequest) String() string { func (*ApproveDraftChunkRequest) ProtoMessage() {} func (x *ApproveDraftChunkRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[190] + mi := &file_openshell_proto_msgTypes[192] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14793,7 +14915,7 @@ func (x *ApproveDraftChunkRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ApproveDraftChunkRequest.ProtoReflect.Descriptor instead. func (*ApproveDraftChunkRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{190} + return file_openshell_proto_rawDescGZIP(), []int{192} } func (x *ApproveDraftChunkRequest) GetName() string { @@ -14843,7 +14965,7 @@ type ApproveDraftChunkResponse struct { func (x *ApproveDraftChunkResponse) Reset() { *x = ApproveDraftChunkResponse{} - mi := &file_openshell_proto_msgTypes[191] + mi := &file_openshell_proto_msgTypes[193] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14855,7 +14977,7 @@ func (x *ApproveDraftChunkResponse) String() string { func (*ApproveDraftChunkResponse) ProtoMessage() {} func (x *ApproveDraftChunkResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[191] + mi := &file_openshell_proto_msgTypes[193] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14868,7 +14990,7 @@ func (x *ApproveDraftChunkResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ApproveDraftChunkResponse.ProtoReflect.Descriptor instead. func (*ApproveDraftChunkResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{191} + return file_openshell_proto_rawDescGZIP(), []int{193} } func (x *ApproveDraftChunkResponse) GetPolicyVersion() uint32 { @@ -14905,7 +15027,7 @@ type RejectDraftChunkRequest struct { func (x *RejectDraftChunkRequest) Reset() { *x = RejectDraftChunkRequest{} - mi := &file_openshell_proto_msgTypes[192] + mi := &file_openshell_proto_msgTypes[194] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14917,7 +15039,7 @@ func (x *RejectDraftChunkRequest) String() string { func (*RejectDraftChunkRequest) ProtoMessage() {} func (x *RejectDraftChunkRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[192] + mi := &file_openshell_proto_msgTypes[194] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14930,7 +15052,7 @@ func (x *RejectDraftChunkRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use RejectDraftChunkRequest.ProtoReflect.Descriptor instead. func (*RejectDraftChunkRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{192} + return file_openshell_proto_rawDescGZIP(), []int{194} } func (x *RejectDraftChunkRequest) GetName() string { @@ -14976,7 +15098,7 @@ type RejectDraftChunkResponse struct { func (x *RejectDraftChunkResponse) Reset() { *x = RejectDraftChunkResponse{} - mi := &file_openshell_proto_msgTypes[193] + mi := &file_openshell_proto_msgTypes[195] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14988,7 +15110,7 @@ func (x *RejectDraftChunkResponse) String() string { func (*RejectDraftChunkResponse) ProtoMessage() {} func (x *RejectDraftChunkResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[193] + mi := &file_openshell_proto_msgTypes[195] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15001,7 +15123,7 @@ func (x *RejectDraftChunkResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use RejectDraftChunkResponse.ProtoReflect.Descriptor instead. func (*RejectDraftChunkResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{193} + return file_openshell_proto_rawDescGZIP(), []int{195} } // Approve all pending chunks. @@ -15015,7 +15137,7 @@ type DraftChunkApproval struct { func (x *DraftChunkApproval) Reset() { *x = DraftChunkApproval{} - mi := &file_openshell_proto_msgTypes[194] + mi := &file_openshell_proto_msgTypes[196] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -15027,7 +15149,7 @@ func (x *DraftChunkApproval) String() string { func (*DraftChunkApproval) ProtoMessage() {} func (x *DraftChunkApproval) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[194] + mi := &file_openshell_proto_msgTypes[196] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15040,7 +15162,7 @@ func (x *DraftChunkApproval) ProtoReflect() protoreflect.Message { // Deprecated: Use DraftChunkApproval.ProtoReflect.Descriptor instead. func (*DraftChunkApproval) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{194} + return file_openshell_proto_rawDescGZIP(), []int{196} } func (x *DraftChunkApproval) GetChunkId() string { @@ -15077,7 +15199,7 @@ type ApproveAllDraftChunksRequest struct { func (x *ApproveAllDraftChunksRequest) Reset() { *x = ApproveAllDraftChunksRequest{} - mi := &file_openshell_proto_msgTypes[195] + mi := &file_openshell_proto_msgTypes[197] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -15089,7 +15211,7 @@ func (x *ApproveAllDraftChunksRequest) String() string { func (*ApproveAllDraftChunksRequest) ProtoMessage() {} func (x *ApproveAllDraftChunksRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[195] + mi := &file_openshell_proto_msgTypes[197] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15102,7 +15224,7 @@ func (x *ApproveAllDraftChunksRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ApproveAllDraftChunksRequest.ProtoReflect.Descriptor instead. func (*ApproveAllDraftChunksRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{195} + return file_openshell_proto_rawDescGZIP(), []int{197} } func (x *ApproveAllDraftChunksRequest) GetName() string { @@ -15157,7 +15279,7 @@ type ApproveAllDraftChunksResponse struct { func (x *ApproveAllDraftChunksResponse) Reset() { *x = ApproveAllDraftChunksResponse{} - mi := &file_openshell_proto_msgTypes[196] + mi := &file_openshell_proto_msgTypes[198] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -15169,7 +15291,7 @@ func (x *ApproveAllDraftChunksResponse) String() string { func (*ApproveAllDraftChunksResponse) ProtoMessage() {} func (x *ApproveAllDraftChunksResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[196] + mi := &file_openshell_proto_msgTypes[198] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15182,7 +15304,7 @@ func (x *ApproveAllDraftChunksResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ApproveAllDraftChunksResponse.ProtoReflect.Descriptor instead. func (*ApproveAllDraftChunksResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{196} + return file_openshell_proto_rawDescGZIP(), []int{198} } func (x *ApproveAllDraftChunksResponse) GetPolicyVersion() uint32 { @@ -15233,7 +15355,7 @@ type EditDraftChunkRequest struct { func (x *EditDraftChunkRequest) Reset() { *x = EditDraftChunkRequest{} - mi := &file_openshell_proto_msgTypes[197] + mi := &file_openshell_proto_msgTypes[199] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -15245,7 +15367,7 @@ func (x *EditDraftChunkRequest) String() string { func (*EditDraftChunkRequest) ProtoMessage() {} func (x *EditDraftChunkRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[197] + mi := &file_openshell_proto_msgTypes[199] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15258,7 +15380,7 @@ func (x *EditDraftChunkRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use EditDraftChunkRequest.ProtoReflect.Descriptor instead. func (*EditDraftChunkRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{197} + return file_openshell_proto_rawDescGZIP(), []int{199} } func (x *EditDraftChunkRequest) GetName() string { @@ -15304,7 +15426,7 @@ type EditDraftChunkResponse struct { func (x *EditDraftChunkResponse) Reset() { *x = EditDraftChunkResponse{} - mi := &file_openshell_proto_msgTypes[198] + mi := &file_openshell_proto_msgTypes[200] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -15316,7 +15438,7 @@ func (x *EditDraftChunkResponse) String() string { func (*EditDraftChunkResponse) ProtoMessage() {} func (x *EditDraftChunkResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[198] + mi := &file_openshell_proto_msgTypes[200] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15329,7 +15451,7 @@ func (x *EditDraftChunkResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use EditDraftChunkResponse.ProtoReflect.Descriptor instead. func (*EditDraftChunkResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{198} + return file_openshell_proto_rawDescGZIP(), []int{200} } // Reverse an approval (remove merged rule from active policy). @@ -15350,7 +15472,7 @@ type UndoDraftChunkRequest struct { func (x *UndoDraftChunkRequest) Reset() { *x = UndoDraftChunkRequest{} - mi := &file_openshell_proto_msgTypes[199] + mi := &file_openshell_proto_msgTypes[201] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -15362,7 +15484,7 @@ func (x *UndoDraftChunkRequest) String() string { func (*UndoDraftChunkRequest) ProtoMessage() {} func (x *UndoDraftChunkRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[199] + mi := &file_openshell_proto_msgTypes[201] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15375,7 +15497,7 @@ func (x *UndoDraftChunkRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use UndoDraftChunkRequest.ProtoReflect.Descriptor instead. func (*UndoDraftChunkRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{199} + return file_openshell_proto_rawDescGZIP(), []int{201} } func (x *UndoDraftChunkRequest) GetName() string { @@ -15418,7 +15540,7 @@ type UndoDraftChunkResponse struct { func (x *UndoDraftChunkResponse) Reset() { *x = UndoDraftChunkResponse{} - mi := &file_openshell_proto_msgTypes[200] + mi := &file_openshell_proto_msgTypes[202] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -15430,7 +15552,7 @@ func (x *UndoDraftChunkResponse) String() string { func (*UndoDraftChunkResponse) ProtoMessage() {} func (x *UndoDraftChunkResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[200] + mi := &file_openshell_proto_msgTypes[202] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15443,7 +15565,7 @@ func (x *UndoDraftChunkResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use UndoDraftChunkResponse.ProtoReflect.Descriptor instead. func (*UndoDraftChunkResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{200} + return file_openshell_proto_rawDescGZIP(), []int{202} } func (x *UndoDraftChunkResponse) GetPolicyVersion() uint32 { @@ -15476,7 +15598,7 @@ type ClearDraftChunksRequest struct { func (x *ClearDraftChunksRequest) Reset() { *x = ClearDraftChunksRequest{} - mi := &file_openshell_proto_msgTypes[201] + mi := &file_openshell_proto_msgTypes[203] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -15488,7 +15610,7 @@ func (x *ClearDraftChunksRequest) String() string { func (*ClearDraftChunksRequest) ProtoMessage() {} func (x *ClearDraftChunksRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[201] + mi := &file_openshell_proto_msgTypes[203] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15501,7 +15623,7 @@ func (x *ClearDraftChunksRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ClearDraftChunksRequest.ProtoReflect.Descriptor instead. func (*ClearDraftChunksRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{201} + return file_openshell_proto_rawDescGZIP(), []int{203} } func (x *ClearDraftChunksRequest) GetName() string { @@ -15535,7 +15657,7 @@ type ClearDraftChunksResponse struct { func (x *ClearDraftChunksResponse) Reset() { *x = ClearDraftChunksResponse{} - mi := &file_openshell_proto_msgTypes[202] + mi := &file_openshell_proto_msgTypes[204] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -15547,7 +15669,7 @@ func (x *ClearDraftChunksResponse) String() string { func (*ClearDraftChunksResponse) ProtoMessage() {} func (x *ClearDraftChunksResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[202] + mi := &file_openshell_proto_msgTypes[204] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15560,7 +15682,7 @@ func (x *ClearDraftChunksResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ClearDraftChunksResponse.ProtoReflect.Descriptor instead. func (*ClearDraftChunksResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{202} + return file_openshell_proto_rawDescGZIP(), []int{204} } func (x *ClearDraftChunksResponse) GetChunksCleared() uint32 { @@ -15583,7 +15705,7 @@ type GetDraftHistoryRequest struct { func (x *GetDraftHistoryRequest) Reset() { *x = GetDraftHistoryRequest{} - mi := &file_openshell_proto_msgTypes[203] + mi := &file_openshell_proto_msgTypes[205] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -15595,7 +15717,7 @@ func (x *GetDraftHistoryRequest) String() string { func (*GetDraftHistoryRequest) ProtoMessage() {} func (x *GetDraftHistoryRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[203] + mi := &file_openshell_proto_msgTypes[205] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15608,7 +15730,7 @@ func (x *GetDraftHistoryRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetDraftHistoryRequest.ProtoReflect.Descriptor instead. func (*GetDraftHistoryRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{203} + return file_openshell_proto_rawDescGZIP(), []int{205} } func (x *GetDraftHistoryRequest) GetName() string { @@ -15642,7 +15764,7 @@ type DraftHistoryEntry struct { func (x *DraftHistoryEntry) Reset() { *x = DraftHistoryEntry{} - mi := &file_openshell_proto_msgTypes[204] + mi := &file_openshell_proto_msgTypes[206] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -15654,7 +15776,7 @@ func (x *DraftHistoryEntry) String() string { func (*DraftHistoryEntry) ProtoMessage() {} func (x *DraftHistoryEntry) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[204] + mi := &file_openshell_proto_msgTypes[206] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15667,7 +15789,7 @@ func (x *DraftHistoryEntry) ProtoReflect() protoreflect.Message { // Deprecated: Use DraftHistoryEntry.ProtoReflect.Descriptor instead. func (*DraftHistoryEntry) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{204} + return file_openshell_proto_rawDescGZIP(), []int{206} } func (x *DraftHistoryEntry) GetEventTime() *timestamppb.Timestamp { @@ -15708,7 +15830,7 @@ type GetDraftHistoryResponse struct { func (x *GetDraftHistoryResponse) Reset() { *x = GetDraftHistoryResponse{} - mi := &file_openshell_proto_msgTypes[205] + mi := &file_openshell_proto_msgTypes[207] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -15720,7 +15842,7 @@ func (x *GetDraftHistoryResponse) String() string { func (*GetDraftHistoryResponse) ProtoMessage() {} func (x *GetDraftHistoryResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[205] + mi := &file_openshell_proto_msgTypes[207] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15733,7 +15855,7 @@ func (x *GetDraftHistoryResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use GetDraftHistoryResponse.ProtoReflect.Descriptor instead. func (*GetDraftHistoryResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{205} + return file_openshell_proto_rawDescGZIP(), []int{207} } func (x *GetDraftHistoryResponse) GetEntries() []*DraftHistoryEntry { @@ -15758,7 +15880,7 @@ type CreateWorkspaceRequest struct { func (x *CreateWorkspaceRequest) Reset() { *x = CreateWorkspaceRequest{} - mi := &file_openshell_proto_msgTypes[206] + mi := &file_openshell_proto_msgTypes[208] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -15770,7 +15892,7 @@ func (x *CreateWorkspaceRequest) String() string { func (*CreateWorkspaceRequest) ProtoMessage() {} func (x *CreateWorkspaceRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[206] + mi := &file_openshell_proto_msgTypes[208] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15783,7 +15905,7 @@ func (x *CreateWorkspaceRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use CreateWorkspaceRequest.ProtoReflect.Descriptor instead. func (*CreateWorkspaceRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{206} + return file_openshell_proto_rawDescGZIP(), []int{208} } func (x *CreateWorkspaceRequest) GetName() string { @@ -15817,7 +15939,7 @@ type CreateWorkspaceResponse struct { func (x *CreateWorkspaceResponse) Reset() { *x = CreateWorkspaceResponse{} - mi := &file_openshell_proto_msgTypes[207] + mi := &file_openshell_proto_msgTypes[209] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -15829,7 +15951,7 @@ func (x *CreateWorkspaceResponse) String() string { func (*CreateWorkspaceResponse) ProtoMessage() {} func (x *CreateWorkspaceResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[207] + mi := &file_openshell_proto_msgTypes[209] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15842,7 +15964,7 @@ func (x *CreateWorkspaceResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use CreateWorkspaceResponse.ProtoReflect.Descriptor instead. func (*CreateWorkspaceResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{207} + return file_openshell_proto_rawDescGZIP(), []int{209} } func (x *CreateWorkspaceResponse) GetWorkspace() *datamodelv1.Workspace { @@ -15863,7 +15985,7 @@ type GetWorkspaceRequest struct { func (x *GetWorkspaceRequest) Reset() { *x = GetWorkspaceRequest{} - mi := &file_openshell_proto_msgTypes[208] + mi := &file_openshell_proto_msgTypes[210] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -15875,7 +15997,7 @@ func (x *GetWorkspaceRequest) String() string { func (*GetWorkspaceRequest) ProtoMessage() {} func (x *GetWorkspaceRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[208] + mi := &file_openshell_proto_msgTypes[210] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15888,7 +16010,7 @@ func (x *GetWorkspaceRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetWorkspaceRequest.ProtoReflect.Descriptor instead. func (*GetWorkspaceRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{208} + return file_openshell_proto_rawDescGZIP(), []int{210} } func (x *GetWorkspaceRequest) GetName() string { @@ -15908,7 +16030,7 @@ type GetWorkspaceResponse struct { func (x *GetWorkspaceResponse) Reset() { *x = GetWorkspaceResponse{} - mi := &file_openshell_proto_msgTypes[209] + mi := &file_openshell_proto_msgTypes[211] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -15920,7 +16042,7 @@ func (x *GetWorkspaceResponse) String() string { func (*GetWorkspaceResponse) ProtoMessage() {} func (x *GetWorkspaceResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[209] + mi := &file_openshell_proto_msgTypes[211] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15933,7 +16055,7 @@ func (x *GetWorkspaceResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use GetWorkspaceResponse.ProtoReflect.Descriptor instead. func (*GetWorkspaceResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{209} + return file_openshell_proto_rawDescGZIP(), []int{211} } func (x *GetWorkspaceResponse) GetWorkspace() *datamodelv1.Workspace { @@ -15960,7 +16082,7 @@ type ListWorkspacesRequest struct { func (x *ListWorkspacesRequest) Reset() { *x = ListWorkspacesRequest{} - mi := &file_openshell_proto_msgTypes[210] + mi := &file_openshell_proto_msgTypes[212] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -15972,7 +16094,7 @@ func (x *ListWorkspacesRequest) String() string { func (*ListWorkspacesRequest) ProtoMessage() {} func (x *ListWorkspacesRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[210] + mi := &file_openshell_proto_msgTypes[212] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15985,7 +16107,7 @@ func (x *ListWorkspacesRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListWorkspacesRequest.ProtoReflect.Descriptor instead. func (*ListWorkspacesRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{210} + return file_openshell_proto_rawDescGZIP(), []int{212} } func (x *ListWorkspacesRequest) GetPageSize() int32 { @@ -16021,7 +16143,7 @@ type ListWorkspacesResponse struct { func (x *ListWorkspacesResponse) Reset() { *x = ListWorkspacesResponse{} - mi := &file_openshell_proto_msgTypes[211] + mi := &file_openshell_proto_msgTypes[213] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -16033,7 +16155,7 @@ func (x *ListWorkspacesResponse) String() string { func (*ListWorkspacesResponse) ProtoMessage() {} func (x *ListWorkspacesResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[211] + mi := &file_openshell_proto_msgTypes[213] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16046,7 +16168,7 @@ func (x *ListWorkspacesResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListWorkspacesResponse.ProtoReflect.Descriptor instead. func (*ListWorkspacesResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{211} + return file_openshell_proto_rawDescGZIP(), []int{213} } func (x *ListWorkspacesResponse) GetWorkspaces() []*datamodelv1.Workspace { @@ -16077,7 +16199,7 @@ type DeleteWorkspaceRequest struct { func (x *DeleteWorkspaceRequest) Reset() { *x = DeleteWorkspaceRequest{} - mi := &file_openshell_proto_msgTypes[212] + mi := &file_openshell_proto_msgTypes[214] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -16089,7 +16211,7 @@ func (x *DeleteWorkspaceRequest) String() string { func (*DeleteWorkspaceRequest) ProtoMessage() {} func (x *DeleteWorkspaceRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[212] + mi := &file_openshell_proto_msgTypes[214] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16102,7 +16224,7 @@ func (x *DeleteWorkspaceRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteWorkspaceRequest.ProtoReflect.Descriptor instead. func (*DeleteWorkspaceRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{212} + return file_openshell_proto_rawDescGZIP(), []int{214} } func (x *DeleteWorkspaceRequest) GetName() string { @@ -16136,7 +16258,7 @@ type DeleteWorkspaceResponse struct { func (x *DeleteWorkspaceResponse) Reset() { *x = DeleteWorkspaceResponse{} - mi := &file_openshell_proto_msgTypes[213] + mi := &file_openshell_proto_msgTypes[215] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -16148,7 +16270,7 @@ func (x *DeleteWorkspaceResponse) String() string { func (*DeleteWorkspaceResponse) ProtoMessage() {} func (x *DeleteWorkspaceResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[213] + mi := &file_openshell_proto_msgTypes[215] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16161,7 +16283,7 @@ func (x *DeleteWorkspaceResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteWorkspaceResponse.ProtoReflect.Descriptor instead. func (*DeleteWorkspaceResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{213} + return file_openshell_proto_rawDescGZIP(), []int{215} } func (x *DeleteWorkspaceResponse) GetOutcome() DeletionOutcome { @@ -16185,7 +16307,7 @@ type WorkspaceMember struct { func (x *WorkspaceMember) Reset() { *x = WorkspaceMember{} - mi := &file_openshell_proto_msgTypes[214] + mi := &file_openshell_proto_msgTypes[216] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -16197,7 +16319,7 @@ func (x *WorkspaceMember) String() string { func (*WorkspaceMember) ProtoMessage() {} func (x *WorkspaceMember) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[214] + mi := &file_openshell_proto_msgTypes[216] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16210,7 +16332,7 @@ func (x *WorkspaceMember) ProtoReflect() protoreflect.Message { // Deprecated: Use WorkspaceMember.ProtoReflect.Descriptor instead. func (*WorkspaceMember) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{214} + return file_openshell_proto_rawDescGZIP(), []int{216} } func (x *WorkspaceMember) GetMetadata() *datamodelv1.ObjectMeta { @@ -16251,7 +16373,7 @@ type AddWorkspaceMemberRequest struct { func (x *AddWorkspaceMemberRequest) Reset() { *x = AddWorkspaceMemberRequest{} - mi := &file_openshell_proto_msgTypes[215] + mi := &file_openshell_proto_msgTypes[217] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -16263,7 +16385,7 @@ func (x *AddWorkspaceMemberRequest) String() string { func (*AddWorkspaceMemberRequest) ProtoMessage() {} func (x *AddWorkspaceMemberRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[215] + mi := &file_openshell_proto_msgTypes[217] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16276,7 +16398,7 @@ func (x *AddWorkspaceMemberRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use AddWorkspaceMemberRequest.ProtoReflect.Descriptor instead. func (*AddWorkspaceMemberRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{215} + return file_openshell_proto_rawDescGZIP(), []int{217} } func (x *AddWorkspaceMemberRequest) GetWorkspace() string { @@ -16317,7 +16439,7 @@ type AddWorkspaceMemberResponse struct { func (x *AddWorkspaceMemberResponse) Reset() { *x = AddWorkspaceMemberResponse{} - mi := &file_openshell_proto_msgTypes[216] + mi := &file_openshell_proto_msgTypes[218] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -16329,7 +16451,7 @@ func (x *AddWorkspaceMemberResponse) String() string { func (*AddWorkspaceMemberResponse) ProtoMessage() {} func (x *AddWorkspaceMemberResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[216] + mi := &file_openshell_proto_msgTypes[218] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16342,7 +16464,7 @@ func (x *AddWorkspaceMemberResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use AddWorkspaceMemberResponse.ProtoReflect.Descriptor instead. func (*AddWorkspaceMemberResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{216} + return file_openshell_proto_rawDescGZIP(), []int{218} } func (x *AddWorkspaceMemberResponse) GetMember() *WorkspaceMember { @@ -16368,7 +16490,7 @@ type RemoveWorkspaceMemberRequest struct { func (x *RemoveWorkspaceMemberRequest) Reset() { *x = RemoveWorkspaceMemberRequest{} - mi := &file_openshell_proto_msgTypes[217] + mi := &file_openshell_proto_msgTypes[219] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -16380,7 +16502,7 @@ func (x *RemoveWorkspaceMemberRequest) String() string { func (*RemoveWorkspaceMemberRequest) ProtoMessage() {} func (x *RemoveWorkspaceMemberRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[217] + mi := &file_openshell_proto_msgTypes[219] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16393,7 +16515,7 @@ func (x *RemoveWorkspaceMemberRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use RemoveWorkspaceMemberRequest.ProtoReflect.Descriptor instead. func (*RemoveWorkspaceMemberRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{217} + return file_openshell_proto_rawDescGZIP(), []int{219} } func (x *RemoveWorkspaceMemberRequest) GetWorkspace() string { @@ -16434,7 +16556,7 @@ type RemoveWorkspaceMemberResponse struct { func (x *RemoveWorkspaceMemberResponse) Reset() { *x = RemoveWorkspaceMemberResponse{} - mi := &file_openshell_proto_msgTypes[218] + mi := &file_openshell_proto_msgTypes[220] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -16446,7 +16568,7 @@ func (x *RemoveWorkspaceMemberResponse) String() string { func (*RemoveWorkspaceMemberResponse) ProtoMessage() {} func (x *RemoveWorkspaceMemberResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[218] + mi := &file_openshell_proto_msgTypes[220] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16459,7 +16581,7 @@ func (x *RemoveWorkspaceMemberResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use RemoveWorkspaceMemberResponse.ProtoReflect.Descriptor instead. func (*RemoveWorkspaceMemberResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{218} + return file_openshell_proto_rawDescGZIP(), []int{220} } func (x *RemoveWorkspaceMemberResponse) GetOutcome() DeletionOutcome { @@ -16486,7 +16608,7 @@ type ListWorkspaceMembersRequest struct { func (x *ListWorkspaceMembersRequest) Reset() { *x = ListWorkspaceMembersRequest{} - mi := &file_openshell_proto_msgTypes[219] + mi := &file_openshell_proto_msgTypes[221] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -16498,7 +16620,7 @@ func (x *ListWorkspaceMembersRequest) String() string { func (*ListWorkspaceMembersRequest) ProtoMessage() {} func (x *ListWorkspaceMembersRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[219] + mi := &file_openshell_proto_msgTypes[221] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16511,7 +16633,7 @@ func (x *ListWorkspaceMembersRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListWorkspaceMembersRequest.ProtoReflect.Descriptor instead. func (*ListWorkspaceMembersRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{219} + return file_openshell_proto_rawDescGZIP(), []int{221} } func (x *ListWorkspaceMembersRequest) GetWorkspace() string { @@ -16547,7 +16669,7 @@ type ListWorkspaceMembersResponse struct { func (x *ListWorkspaceMembersResponse) Reset() { *x = ListWorkspaceMembersResponse{} - mi := &file_openshell_proto_msgTypes[220] + mi := &file_openshell_proto_msgTypes[222] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -16559,7 +16681,7 @@ func (x *ListWorkspaceMembersResponse) String() string { func (*ListWorkspaceMembersResponse) ProtoMessage() {} func (x *ListWorkspaceMembersResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[220] + mi := &file_openshell_proto_msgTypes[222] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16572,7 +16694,7 @@ func (x *ListWorkspaceMembersResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListWorkspaceMembersResponse.ProtoReflect.Descriptor instead. func (*ListWorkspaceMembersResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{220} + return file_openshell_proto_rawDescGZIP(), []int{222} } func (x *ListWorkspaceMembersResponse) GetMembers() []*WorkspaceMember { @@ -16607,7 +16729,7 @@ type ExtensionServiceCredential struct { func (x *ExtensionServiceCredential) Reset() { *x = ExtensionServiceCredential{} - mi := &file_openshell_proto_msgTypes[221] + mi := &file_openshell_proto_msgTypes[223] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -16619,7 +16741,7 @@ func (x *ExtensionServiceCredential) String() string { func (*ExtensionServiceCredential) ProtoMessage() {} func (x *ExtensionServiceCredential) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[221] + mi := &file_openshell_proto_msgTypes[223] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16632,7 +16754,7 @@ func (x *ExtensionServiceCredential) ProtoReflect() protoreflect.Message { // Deprecated: Use ExtensionServiceCredential.ProtoReflect.Descriptor instead. func (*ExtensionServiceCredential) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{221} + return file_openshell_proto_rawDescGZIP(), []int{223} } func (x *ExtensionServiceCredential) GetServiceName() string { @@ -16669,7 +16791,7 @@ type EndpointObservation struct { func (x *EndpointObservation) Reset() { *x = EndpointObservation{} - mi := &file_openshell_proto_msgTypes[222] + mi := &file_openshell_proto_msgTypes[224] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -16681,7 +16803,7 @@ func (x *EndpointObservation) String() string { func (*EndpointObservation) ProtoMessage() {} func (x *EndpointObservation) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[222] + mi := &file_openshell_proto_msgTypes[224] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16694,7 +16816,7 @@ func (x *EndpointObservation) ProtoReflect() protoreflect.Message { // Deprecated: Use EndpointObservation.ProtoReflect.Descriptor instead. func (*EndpointObservation) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{222} + return file_openshell_proto_rawDescGZIP(), []int{224} } func (x *EndpointObservation) GetEndpointId() string { @@ -16737,7 +16859,7 @@ type ReportEndpointStatusRequest struct { func (x *ReportEndpointStatusRequest) Reset() { *x = ReportEndpointStatusRequest{} - mi := &file_openshell_proto_msgTypes[223] + mi := &file_openshell_proto_msgTypes[225] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -16749,7 +16871,7 @@ func (x *ReportEndpointStatusRequest) String() string { func (*ReportEndpointStatusRequest) ProtoMessage() {} func (x *ReportEndpointStatusRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[223] + mi := &file_openshell_proto_msgTypes[225] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16762,7 +16884,7 @@ func (x *ReportEndpointStatusRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ReportEndpointStatusRequest.ProtoReflect.Descriptor instead. func (*ReportEndpointStatusRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{223} + return file_openshell_proto_rawDescGZIP(), []int{225} } func (x *ReportEndpointStatusRequest) GetSandboxId() string { @@ -16823,7 +16945,7 @@ type ReportEndpointStatusResponse struct { func (x *ReportEndpointStatusResponse) Reset() { *x = ReportEndpointStatusResponse{} - mi := &file_openshell_proto_msgTypes[224] + mi := &file_openshell_proto_msgTypes[226] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -16835,7 +16957,7 @@ func (x *ReportEndpointStatusResponse) String() string { func (*ReportEndpointStatusResponse) ProtoMessage() {} func (x *ReportEndpointStatusResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[224] + mi := &file_openshell_proto_msgTypes[226] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16848,7 +16970,7 @@ func (x *ReportEndpointStatusResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ReportEndpointStatusResponse.ProtoReflect.Descriptor instead. func (*ReportEndpointStatusResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{224} + return file_openshell_proto_rawDescGZIP(), []int{226} } // A configured endpoint and its last accepted network result in one record. @@ -16877,7 +16999,7 @@ type EndpointStatus struct { func (x *EndpointStatus) Reset() { *x = EndpointStatus{} - mi := &file_openshell_proto_msgTypes[225] + mi := &file_openshell_proto_msgTypes[227] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -16889,7 +17011,7 @@ func (x *EndpointStatus) String() string { func (*EndpointStatus) ProtoMessage() {} func (x *EndpointStatus) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[225] + mi := &file_openshell_proto_msgTypes[227] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16902,7 +17024,7 @@ func (x *EndpointStatus) ProtoReflect() protoreflect.Message { // Deprecated: Use EndpointStatus.ProtoReflect.Descriptor instead. func (*EndpointStatus) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{225} + return file_openshell_proto_rawDescGZIP(), []int{227} } func (x *EndpointStatus) GetEndpointId() string { @@ -16972,7 +17094,7 @@ type SandboxProvisioning struct { func (x *SandboxProvisioning) Reset() { *x = SandboxProvisioning{} - mi := &file_openshell_proto_msgTypes[226] + mi := &file_openshell_proto_msgTypes[228] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -16984,7 +17106,7 @@ func (x *SandboxProvisioning) String() string { func (*SandboxProvisioning) ProtoMessage() {} func (x *SandboxProvisioning) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[226] + mi := &file_openshell_proto_msgTypes[228] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16997,7 +17119,7 @@ func (x *SandboxProvisioning) ProtoReflect() protoreflect.Message { // Deprecated: Use SandboxProvisioning.ProtoReflect.Descriptor instead. func (*SandboxProvisioning) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{226} + return file_openshell_proto_rawDescGZIP(), []int{228} } func (x *SandboxProvisioning) GetAttemptId() string { @@ -17124,11 +17246,11 @@ const file_openshell_proto_rawDesc = "" + "\x14ResourceCapabilities\x127\n" + "\x03cpu\x18\x01 \x01(\v2%.openshell.v1.CpuResourceCapabilitiesR\x03cpu\x12@\n" + "\x06memory\x18\x02 \x01(\v2(.openshell.v1.MemoryResourceCapabilitiesR\x06memory\x127\n" + - "\x03gpu\x18\x03 \x01(\v2%.openshell.v1.GpuResourceCapabilitiesR\x03gpu\"B\n" + - "\x17CpuResourceCapabilities\x12'\n" + - "\x0flimit_supported\x18\x01 \x01(\bR\x0elimitSupported\"E\n" + - "\x1aMemoryResourceCapabilities\x12'\n" + - "\x0flimit_supported\x18\x01 \x01(\bR\x0elimitSupported\"\x95\x01\n" + + "\x03gpu\x18\x03 \x01(\v2%.openshell.v1.GpuResourceCapabilitiesR\x03gpu\"H\n" + + "\x17CpuResourceCapabilities\x12-\n" + + "\x12quantity_supported\x18\x01 \x01(\bR\x11quantitySupported\"K\n" + + "\x1aMemoryResourceCapabilities\x12-\n" + + "\x12quantity_supported\x18\x01 \x01(\bR\x11quantitySupported\"\x95\x01\n" + "\x17GpuResourceCapabilities\x12>\n" + "\x1bdefault_selection_supported\x18\x01 \x01(\bR\x19defaultSelectionSupported\x12:\n" + "\x19count_selection_supported\x18\x02 \x01(\bR\x17countSelectionSupported\"\xce\x02\n" + @@ -17151,12 +17273,20 @@ 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\"G\n" + + "\x17CpuResourceRequirements\x12\x1f\n" + + "\bquantity\x18\x01 \x01(\tH\x00R\bquantity\x88\x01\x01B\v\n" + + "\t_quantity\"J\n" + + "\x1aMemoryResourceRequirements\x12\x1f\n" + + "\bquantity\x18\x01 \x01(\tH\x00R\bquantity\x88\x01\x01B\v\n" + + "\t_quantity\"\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" + @@ -17185,15 +17315,16 @@ 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\"\xdc\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\x12S\n" + + "\x10legacy_resources\x18\x03 \x01(\v2$.openshell.v1.LegacySandboxResourcesB\x02\x18\x01R\x0flegacyResources\x12@\n" + + "\tresources\x18\x04 \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" + + "\x05value\x18\x02 \x01(\tR\x05value:\x028\x01\"{\n" + + "\x16LegacySandboxResources\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" + @@ -18659,7 +18790,7 @@ func file_openshell_proto_rawDescGZIP() []byte { } var file_openshell_proto_enumTypes = make([]protoimpl.EnumInfo, 17) -var file_openshell_proto_msgTypes = make([]protoimpl.MessageInfo, 248) +var file_openshell_proto_msgTypes = make([]protoimpl.MessageInfo, 250) var file_openshell_proto_goTypes = []any{ (SandboxPhase)(0), // 0: openshell.v1.SandboxPhase (ProviderMutationKind)(0), // 1: openshell.v1.ProviderMutationKind @@ -18698,259 +18829,261 @@ var file_openshell_proto_goTypes = []any{ (*SandboxSpec)(nil), // 34: openshell.v1.SandboxSpec (*ResourceRequirements)(nil), // 35: openshell.v1.ResourceRequirements (*GpuResourceRequirements)(nil), // 36: openshell.v1.GpuResourceRequirements - (*SandboxTemplate)(nil), // 37: openshell.v1.SandboxTemplate - (*SandboxWorkloadTemplate)(nil), // 38: openshell.v1.SandboxWorkloadTemplate - (*SandboxWorkloadTemplateSpec)(nil), // 39: openshell.v1.SandboxWorkloadTemplateSpec - (*SandboxWorkloadConfig)(nil), // 40: openshell.v1.SandboxWorkloadConfig - (*SandboxResources)(nil), // 41: openshell.v1.SandboxResources - (*SandboxServiceLevel)(nil), // 42: openshell.v1.SandboxServiceLevel - (*SandboxStartup)(nil), // 43: openshell.v1.SandboxStartup - (*SandboxWorkloadTemplateProvenance)(nil), // 44: openshell.v1.SandboxWorkloadTemplateProvenance - (*SandboxStatus)(nil), // 45: openshell.v1.SandboxStatus - (*SandboxCondition)(nil), // 46: openshell.v1.SandboxCondition - (*PlatformEvent)(nil), // 47: openshell.v1.PlatformEvent - (*CreateSandboxRequest)(nil), // 48: openshell.v1.CreateSandboxRequest - (*CreateSandboxTemplateRequest)(nil), // 49: openshell.v1.CreateSandboxTemplateRequest - (*GetSandboxTemplateRequest)(nil), // 50: openshell.v1.GetSandboxTemplateRequest - (*ListSandboxTemplatesRequest)(nil), // 51: openshell.v1.ListSandboxTemplatesRequest - (*DeleteSandboxTemplateRequest)(nil), // 52: openshell.v1.DeleteSandboxTemplateRequest - (*SandboxTemplateResponse)(nil), // 53: openshell.v1.SandboxTemplateResponse - (*ListSandboxTemplatesResponse)(nil), // 54: openshell.v1.ListSandboxTemplatesResponse - (*DeleteSandboxTemplateResponse)(nil), // 55: openshell.v1.DeleteSandboxTemplateResponse - (*BeginRootfsTarStagingRequest)(nil), // 56: openshell.v1.BeginRootfsTarStagingRequest - (*BeginRootfsTarStagingResponse)(nil), // 57: openshell.v1.BeginRootfsTarStagingResponse - (*GetSandboxRequest)(nil), // 58: openshell.v1.GetSandboxRequest - (*ListSandboxesRequest)(nil), // 59: openshell.v1.ListSandboxesRequest - (*ListSandboxProvidersRequest)(nil), // 60: openshell.v1.ListSandboxProvidersRequest - (*AttachSandboxProviderRequest)(nil), // 61: openshell.v1.AttachSandboxProviderRequest - (*DetachSandboxProviderRequest)(nil), // 62: openshell.v1.DetachSandboxProviderRequest - (*DeleteSandboxRequest)(nil), // 63: openshell.v1.DeleteSandboxRequest - (*StopSandboxRequest)(nil), // 64: openshell.v1.StopSandboxRequest - (*StartSandboxRequest)(nil), // 65: openshell.v1.StartSandboxRequest - (*SandboxResponse)(nil), // 66: openshell.v1.SandboxResponse - (*ListSandboxesResponse)(nil), // 67: openshell.v1.ListSandboxesResponse - (*ListSandboxProvidersResponse)(nil), // 68: openshell.v1.ListSandboxProvidersResponse - (*AttachSandboxProviderResponse)(nil), // 69: openshell.v1.AttachSandboxProviderResponse - (*DetachSandboxProviderResponse)(nil), // 70: openshell.v1.DetachSandboxProviderResponse - (*ProviderDesiredIdentity)(nil), // 71: openshell.v1.ProviderDesiredIdentity - (*ConfigSnapshotRevision)(nil), // 72: openshell.v1.ConfigSnapshotRevision - (*SandboxConfigRevision)(nil), // 73: openshell.v1.SandboxConfigRevision - (*ConfigUpdateOperation)(nil), // 74: openshell.v1.ConfigUpdateOperation - (*ProviderMutationReceipt)(nil), // 75: openshell.v1.ProviderMutationReceipt - (*ProviderReadinessObservation)(nil), // 76: openshell.v1.ProviderReadinessObservation - (*ProviderReadinessStatus)(nil), // 77: openshell.v1.ProviderReadinessStatus - (*GetSandboxProviderStatusRequest)(nil), // 78: openshell.v1.GetSandboxProviderStatusRequest - (*GetSandboxProviderStatusResponse)(nil), // 79: openshell.v1.GetSandboxProviderStatusResponse - (*ReportProviderReadinessRequest)(nil), // 80: openshell.v1.ReportProviderReadinessRequest - (*ReportProviderReadinessResponse)(nil), // 81: openshell.v1.ReportProviderReadinessResponse - (*DeleteSandboxResponse)(nil), // 82: openshell.v1.DeleteSandboxResponse - (*CreateSshSessionRequest)(nil), // 83: openshell.v1.CreateSshSessionRequest - (*CreateSshSessionResponse)(nil), // 84: openshell.v1.CreateSshSessionResponse - (*ExposeServiceRequest)(nil), // 85: openshell.v1.ExposeServiceRequest - (*GetServiceRequest)(nil), // 86: openshell.v1.GetServiceRequest - (*ListServicesRequest)(nil), // 87: openshell.v1.ListServicesRequest - (*ListServicesResponse)(nil), // 88: openshell.v1.ListServicesResponse - (*DeleteServiceRequest)(nil), // 89: openshell.v1.DeleteServiceRequest - (*DeleteServiceResponse)(nil), // 90: openshell.v1.DeleteServiceResponse - (*ServiceEndpoint)(nil), // 91: openshell.v1.ServiceEndpoint - (*ServiceEndpointResponse)(nil), // 92: openshell.v1.ServiceEndpointResponse - (*RevokeSshSessionRequest)(nil), // 93: openshell.v1.RevokeSshSessionRequest - (*RevokeSshSessionResponse)(nil), // 94: openshell.v1.RevokeSshSessionResponse - (*ExecSandboxRequest)(nil), // 95: openshell.v1.ExecSandboxRequest - (*ExecSandboxStdout)(nil), // 96: openshell.v1.ExecSandboxStdout - (*ExecSandboxStderr)(nil), // 97: openshell.v1.ExecSandboxStderr - (*ExecSandboxExit)(nil), // 98: openshell.v1.ExecSandboxExit - (*ExecSandboxEvent)(nil), // 99: openshell.v1.ExecSandboxEvent - (*TcpForwardInit)(nil), // 100: openshell.v1.TcpForwardInit - (*TcpForwardFrame)(nil), // 101: openshell.v1.TcpForwardFrame - (*ExecSandboxInput)(nil), // 102: openshell.v1.ExecSandboxInput - (*ExecSandboxWindowResize)(nil), // 103: openshell.v1.ExecSandboxWindowResize - (*SshSession)(nil), // 104: openshell.v1.SshSession - (*WatchSandboxRequest)(nil), // 105: openshell.v1.WatchSandboxRequest - (*SandboxStreamEvent)(nil), // 106: openshell.v1.SandboxStreamEvent - (*SandboxLogLine)(nil), // 107: openshell.v1.SandboxLogLine - (*SandboxStreamWarning)(nil), // 108: openshell.v1.SandboxStreamWarning - (*CreateProviderRequest)(nil), // 109: openshell.v1.CreateProviderRequest - (*GetProviderRequest)(nil), // 110: openshell.v1.GetProviderRequest - (*ListProvidersRequest)(nil), // 111: openshell.v1.ListProvidersRequest - (*UpdateProviderRequest)(nil), // 112: openshell.v1.UpdateProviderRequest - (*DeleteProviderRequest)(nil), // 113: openshell.v1.DeleteProviderRequest - (*ProviderResponse)(nil), // 114: openshell.v1.ProviderResponse - (*ListProvidersResponse)(nil), // 115: openshell.v1.ListProvidersResponse - (*ListProviderProfilesRequest)(nil), // 116: openshell.v1.ListProviderProfilesRequest - (*GetProviderProfileRequest)(nil), // 117: openshell.v1.GetProviderProfileRequest - (*ProviderProfileImportItem)(nil), // 118: openshell.v1.ProviderProfileImportItem - (*ProviderProfileDiagnostic)(nil), // 119: openshell.v1.ProviderProfileDiagnostic - (*ProviderCredentialTokenGrantAudienceOverride)(nil), // 120: openshell.v1.ProviderCredentialTokenGrantAudienceOverride - (*ProviderCredentialTokenGrantSubjectToken)(nil), // 121: openshell.v1.ProviderCredentialTokenGrantSubjectToken - (*ProviderCredentialTokenGrant)(nil), // 122: openshell.v1.ProviderCredentialTokenGrant - (*ProviderProfileCredential)(nil), // 123: openshell.v1.ProviderProfileCredential - (*ProviderCredentialRefreshMaterial)(nil), // 124: openshell.v1.ProviderCredentialRefreshMaterial - (*ProviderCredentialRefreshOutput)(nil), // 125: openshell.v1.ProviderCredentialRefreshOutput - (*ProviderCredentialRefresh)(nil), // 126: openshell.v1.ProviderCredentialRefresh - (*ProviderCredentialRefreshStatus)(nil), // 127: openshell.v1.ProviderCredentialRefreshStatus - (*ProviderProfileDiscovery)(nil), // 128: openshell.v1.ProviderProfileDiscovery - (*GetProviderRefreshStatusRequest)(nil), // 129: openshell.v1.GetProviderRefreshStatusRequest - (*GetProviderRefreshStatusResponse)(nil), // 130: openshell.v1.GetProviderRefreshStatusResponse - (*ConfigureProviderRefreshRequest)(nil), // 131: openshell.v1.ConfigureProviderRefreshRequest - (*ConfigureProviderRefreshResponse)(nil), // 132: openshell.v1.ConfigureProviderRefreshResponse - (*RotateProviderCredentialRequest)(nil), // 133: openshell.v1.RotateProviderCredentialRequest - (*RotateProviderCredentialResponse)(nil), // 134: openshell.v1.RotateProviderCredentialResponse - (*DeleteProviderRefreshRequest)(nil), // 135: openshell.v1.DeleteProviderRefreshRequest - (*DeleteProviderRefreshResponse)(nil), // 136: openshell.v1.DeleteProviderRefreshResponse - (*ProviderProfile)(nil), // 137: openshell.v1.ProviderProfile - (*ProviderProfileResponse)(nil), // 138: openshell.v1.ProviderProfileResponse - (*ListProviderProfilesResponse)(nil), // 139: openshell.v1.ListProviderProfilesResponse - (*ImportProviderProfilesRequest)(nil), // 140: openshell.v1.ImportProviderProfilesRequest - (*ImportProviderProfilesResponse)(nil), // 141: openshell.v1.ImportProviderProfilesResponse - (*UpdateProviderProfilesRequest)(nil), // 142: openshell.v1.UpdateProviderProfilesRequest - (*UpdateProviderProfilesResponse)(nil), // 143: openshell.v1.UpdateProviderProfilesResponse - (*LintProviderProfilesRequest)(nil), // 144: openshell.v1.LintProviderProfilesRequest - (*LintProviderProfilesResponse)(nil), // 145: openshell.v1.LintProviderProfilesResponse - (*DeleteProviderResponse)(nil), // 146: openshell.v1.DeleteProviderResponse - (*DeleteProviderProfileRequest)(nil), // 147: openshell.v1.DeleteProviderProfileRequest - (*DeleteProviderProfileResponse)(nil), // 148: openshell.v1.DeleteProviderProfileResponse - (*GetSandboxProviderEnvironmentRequest)(nil), // 149: openshell.v1.GetSandboxProviderEnvironmentRequest - (*StaticCredentialEndpointBinding)(nil), // 150: openshell.v1.StaticCredentialEndpointBinding - (*StaticCredentialBinding)(nil), // 151: openshell.v1.StaticCredentialBinding - (*GetSandboxProviderEnvironmentResponse)(nil), // 152: openshell.v1.GetSandboxProviderEnvironmentResponse - (*ExchangeProviderSubjectTokenRequest)(nil), // 153: openshell.v1.ExchangeProviderSubjectTokenRequest - (*ExchangeProviderSubjectTokenResponse)(nil), // 154: openshell.v1.ExchangeProviderSubjectTokenResponse - (*UpdateConfigRequest)(nil), // 155: openshell.v1.UpdateConfigRequest - (*PolicyMergeOperation)(nil), // 156: openshell.v1.PolicyMergeOperation - (*AddNetworkRule)(nil), // 157: openshell.v1.AddNetworkRule - (*RemoveNetworkEndpoint)(nil), // 158: openshell.v1.RemoveNetworkEndpoint - (*RemoveNetworkRule)(nil), // 159: openshell.v1.RemoveNetworkRule - (*L7RuleTarget)(nil), // 160: openshell.v1.L7RuleTarget - (*AddDenyRules)(nil), // 161: openshell.v1.AddDenyRules - (*AddAllowRules)(nil), // 162: openshell.v1.AddAllowRules - (*RemoveNetworkBinary)(nil), // 163: openshell.v1.RemoveNetworkBinary - (*UpdateConfigResponse)(nil), // 164: openshell.v1.UpdateConfigResponse - (*GetSandboxPolicyStatusRequest)(nil), // 165: openshell.v1.GetSandboxPolicyStatusRequest - (*GetSandboxPolicyStatusResponse)(nil), // 166: openshell.v1.GetSandboxPolicyStatusResponse - (*ListSandboxPoliciesRequest)(nil), // 167: openshell.v1.ListSandboxPoliciesRequest - (*ListSandboxPoliciesResponse)(nil), // 168: openshell.v1.ListSandboxPoliciesResponse - (*ReportPolicyStatusRequest)(nil), // 169: openshell.v1.ReportPolicyStatusRequest - (*ReportPolicyStatusResponse)(nil), // 170: openshell.v1.ReportPolicyStatusResponse - (*SandboxConfigurationAdmission)(nil), // 171: openshell.v1.SandboxConfigurationAdmission - (*ReportSandboxConfigurationRequest)(nil), // 172: openshell.v1.ReportSandboxConfigurationRequest - (*ReportSandboxConfigurationResponse)(nil), // 173: openshell.v1.ReportSandboxConfigurationResponse - (*SandboxPolicyRevision)(nil), // 174: openshell.v1.SandboxPolicyRevision - (*GetSandboxLogsRequest)(nil), // 175: openshell.v1.GetSandboxLogsRequest - (*PushSandboxLogsRequest)(nil), // 176: openshell.v1.PushSandboxLogsRequest - (*PushSandboxLogsResponse)(nil), // 177: openshell.v1.PushSandboxLogsResponse - (*GetSandboxLogsResponse)(nil), // 178: openshell.v1.GetSandboxLogsResponse - (*SupervisorMessage)(nil), // 179: openshell.v1.SupervisorMessage - (*GatewayMessage)(nil), // 180: openshell.v1.GatewayMessage - (*SupervisorHello)(nil), // 181: openshell.v1.SupervisorHello - (*SessionAccepted)(nil), // 182: openshell.v1.SessionAccepted - (*SessionRejected)(nil), // 183: openshell.v1.SessionRejected - (*SupervisorHeartbeat)(nil), // 184: openshell.v1.SupervisorHeartbeat - (*GatewayHeartbeat)(nil), // 185: openshell.v1.GatewayHeartbeat - (*ReportMainProcessExitRequest)(nil), // 186: openshell.v1.ReportMainProcessExitRequest - (*ReportMainProcessExitResponse)(nil), // 187: openshell.v1.ReportMainProcessExitResponse - (*FinalizeMainProcessExitRequest)(nil), // 188: openshell.v1.FinalizeMainProcessExitRequest - (*FinalizeMainProcessExitResponse)(nil), // 189: openshell.v1.FinalizeMainProcessExitResponse - (*RelayOpen)(nil), // 190: openshell.v1.RelayOpen - (*SshRelayTarget)(nil), // 191: openshell.v1.SshRelayTarget - (*TcpRelayTarget)(nil), // 192: openshell.v1.TcpRelayTarget - (*RelayInit)(nil), // 193: openshell.v1.RelayInit - (*RelayFrame)(nil), // 194: openshell.v1.RelayFrame - (*RelayOpenResult)(nil), // 195: openshell.v1.RelayOpenResult - (*RelayClose)(nil), // 196: openshell.v1.RelayClose - (*L7RequestSample)(nil), // 197: openshell.v1.L7RequestSample - (*DenialSummary)(nil), // 198: openshell.v1.DenialSummary - (*DenialGroupCount)(nil), // 199: openshell.v1.DenialGroupCount - (*NetworkActivitySummary)(nil), // 200: openshell.v1.NetworkActivitySummary - (*PolicyChunk)(nil), // 201: openshell.v1.PolicyChunk - (*DraftPolicyUpdate)(nil), // 202: openshell.v1.DraftPolicyUpdate - (*SubmitPolicyAnalysisRequest)(nil), // 203: openshell.v1.SubmitPolicyAnalysisRequest - (*SubmitPolicyAnalysisResponse)(nil), // 204: openshell.v1.SubmitPolicyAnalysisResponse - (*GetDraftPolicyRequest)(nil), // 205: openshell.v1.GetDraftPolicyRequest - (*GetDraftPolicyResponse)(nil), // 206: openshell.v1.GetDraftPolicyResponse - (*ApproveDraftChunkRequest)(nil), // 207: openshell.v1.ApproveDraftChunkRequest - (*ApproveDraftChunkResponse)(nil), // 208: openshell.v1.ApproveDraftChunkResponse - (*RejectDraftChunkRequest)(nil), // 209: openshell.v1.RejectDraftChunkRequest - (*RejectDraftChunkResponse)(nil), // 210: openshell.v1.RejectDraftChunkResponse - (*DraftChunkApproval)(nil), // 211: openshell.v1.DraftChunkApproval - (*ApproveAllDraftChunksRequest)(nil), // 212: openshell.v1.ApproveAllDraftChunksRequest - (*ApproveAllDraftChunksResponse)(nil), // 213: openshell.v1.ApproveAllDraftChunksResponse - (*EditDraftChunkRequest)(nil), // 214: openshell.v1.EditDraftChunkRequest - (*EditDraftChunkResponse)(nil), // 215: openshell.v1.EditDraftChunkResponse - (*UndoDraftChunkRequest)(nil), // 216: openshell.v1.UndoDraftChunkRequest - (*UndoDraftChunkResponse)(nil), // 217: openshell.v1.UndoDraftChunkResponse - (*ClearDraftChunksRequest)(nil), // 218: openshell.v1.ClearDraftChunksRequest - (*ClearDraftChunksResponse)(nil), // 219: openshell.v1.ClearDraftChunksResponse - (*GetDraftHistoryRequest)(nil), // 220: openshell.v1.GetDraftHistoryRequest - (*DraftHistoryEntry)(nil), // 221: openshell.v1.DraftHistoryEntry - (*GetDraftHistoryResponse)(nil), // 222: openshell.v1.GetDraftHistoryResponse - (*CreateWorkspaceRequest)(nil), // 223: openshell.v1.CreateWorkspaceRequest - (*CreateWorkspaceResponse)(nil), // 224: openshell.v1.CreateWorkspaceResponse - (*GetWorkspaceRequest)(nil), // 225: openshell.v1.GetWorkspaceRequest - (*GetWorkspaceResponse)(nil), // 226: openshell.v1.GetWorkspaceResponse - (*ListWorkspacesRequest)(nil), // 227: openshell.v1.ListWorkspacesRequest - (*ListWorkspacesResponse)(nil), // 228: openshell.v1.ListWorkspacesResponse - (*DeleteWorkspaceRequest)(nil), // 229: openshell.v1.DeleteWorkspaceRequest - (*DeleteWorkspaceResponse)(nil), // 230: openshell.v1.DeleteWorkspaceResponse - (*WorkspaceMember)(nil), // 231: openshell.v1.WorkspaceMember - (*AddWorkspaceMemberRequest)(nil), // 232: openshell.v1.AddWorkspaceMemberRequest - (*AddWorkspaceMemberResponse)(nil), // 233: openshell.v1.AddWorkspaceMemberResponse - (*RemoveWorkspaceMemberRequest)(nil), // 234: openshell.v1.RemoveWorkspaceMemberRequest - (*RemoveWorkspaceMemberResponse)(nil), // 235: openshell.v1.RemoveWorkspaceMemberResponse - (*ListWorkspaceMembersRequest)(nil), // 236: openshell.v1.ListWorkspaceMembersRequest - (*ListWorkspaceMembersResponse)(nil), // 237: openshell.v1.ListWorkspaceMembersResponse - (*ExtensionServiceCredential)(nil), // 238: openshell.v1.ExtensionServiceCredential - (*EndpointObservation)(nil), // 239: openshell.v1.EndpointObservation - (*ReportEndpointStatusRequest)(nil), // 240: openshell.v1.ReportEndpointStatusRequest - (*ReportEndpointStatusResponse)(nil), // 241: openshell.v1.ReportEndpointStatusResponse - (*EndpointStatus)(nil), // 242: openshell.v1.EndpointStatus - (*SandboxProvisioning)(nil), // 243: openshell.v1.SandboxProvisioning - nil, // 244: openshell.v1.SandboxSpec.EnvironmentEntry - nil, // 245: openshell.v1.SandboxTemplate.LabelsEntry - nil, // 246: openshell.v1.SandboxTemplate.AnnotationsEntry - nil, // 247: openshell.v1.SandboxTemplate.EnvironmentEntry - nil, // 248: openshell.v1.SandboxWorkloadConfig.EnvironmentEntry - nil, // 249: openshell.v1.PlatformEvent.MetadataEntry - nil, // 250: openshell.v1.CreateSandboxRequest.LabelsEntry - nil, // 251: openshell.v1.CreateSandboxRequest.AnnotationsEntry - nil, // 252: openshell.v1.ExecSandboxRequest.EnvironmentEntry - nil, // 253: openshell.v1.SandboxLogLine.FieldsEntry - nil, // 254: openshell.v1.UpdateProviderRequest.CredentialExpirationTimesEntry - nil, // 255: openshell.v1.ConfigureProviderRefreshRequest.MaterialEntry - nil, // 256: openshell.v1.ProviderProfile.AnnotationsEntry - nil, // 257: openshell.v1.GetSandboxProviderEnvironmentResponse.EnvironmentEntry - nil, // 258: openshell.v1.GetSandboxProviderEnvironmentResponse.CredentialExpirationTimesEntry - nil, // 259: openshell.v1.GetSandboxProviderEnvironmentResponse.DynamicCredentialsEntry - nil, // 260: openshell.v1.GetSandboxProviderEnvironmentResponse.StaticCredentialBindingsEntry - nil, // 261: openshell.v1.UpdateConfigRequest.AnnotationsEntry - nil, // 262: openshell.v1.UpdateConfigResponse.AnnotationsEntry - nil, // 263: openshell.v1.SandboxPolicyRevision.ProvenanceEntry - nil, // 264: openshell.v1.CreateWorkspaceRequest.LabelsEntry - (*timestamppb.Timestamp)(nil), // 265: google.protobuf.Timestamp - (*datamodelv1.ObjectMeta)(nil), // 266: openshell.datamodel.v1.ObjectMeta - (*sandboxv1.SandboxPolicy)(nil), // 267: openshell.sandbox.v1.SandboxPolicy - (*structpb.Struct)(nil), // 268: google.protobuf.Struct - (*durationpb.Duration)(nil), // 269: google.protobuf.Duration - (*datamodelv1.WorkspaceSelector)(nil), // 270: openshell.datamodel.v1.WorkspaceSelector - (*datamodelv1.Provider)(nil), // 271: openshell.datamodel.v1.Provider - (sandboxv1.PolicySource)(0), // 272: openshell.sandbox.v1.PolicySource - (*sandboxv1.NetworkEndpoint)(nil), // 273: openshell.sandbox.v1.NetworkEndpoint - (*sandboxv1.NetworkBinary)(nil), // 274: openshell.sandbox.v1.NetworkBinary - (*sandboxv1.SettingValue)(nil), // 275: openshell.sandbox.v1.SettingValue - (*sandboxv1.NetworkPolicyRule)(nil), // 276: openshell.sandbox.v1.NetworkPolicyRule - (*sandboxv1.L7DenyRule)(nil), // 277: openshell.sandbox.v1.L7DenyRule - (*sandboxv1.L7Rule)(nil), // 278: openshell.sandbox.v1.L7Rule - (*datamodelv1.Workspace)(nil), // 279: openshell.datamodel.v1.Workspace - (*sandboxv1.GetSandboxConfigRequest)(nil), // 280: openshell.sandbox.v1.GetSandboxConfigRequest - (*sandboxv1.GetGatewayConfigRequest)(nil), // 281: openshell.sandbox.v1.GetGatewayConfigRequest - (*sandboxv1.GetSandboxConfigResponse)(nil), // 282: openshell.sandbox.v1.GetSandboxConfigResponse - (*sandboxv1.GetGatewayConfigResponse)(nil), // 283: openshell.sandbox.v1.GetGatewayConfigResponse + (*CpuResourceRequirements)(nil), // 37: openshell.v1.CpuResourceRequirements + (*MemoryResourceRequirements)(nil), // 38: openshell.v1.MemoryResourceRequirements + (*SandboxTemplate)(nil), // 39: openshell.v1.SandboxTemplate + (*SandboxWorkloadTemplate)(nil), // 40: openshell.v1.SandboxWorkloadTemplate + (*SandboxWorkloadTemplateSpec)(nil), // 41: openshell.v1.SandboxWorkloadTemplateSpec + (*SandboxWorkloadConfig)(nil), // 42: openshell.v1.SandboxWorkloadConfig + (*LegacySandboxResources)(nil), // 43: openshell.v1.LegacySandboxResources + (*SandboxServiceLevel)(nil), // 44: openshell.v1.SandboxServiceLevel + (*SandboxStartup)(nil), // 45: openshell.v1.SandboxStartup + (*SandboxWorkloadTemplateProvenance)(nil), // 46: openshell.v1.SandboxWorkloadTemplateProvenance + (*SandboxStatus)(nil), // 47: openshell.v1.SandboxStatus + (*SandboxCondition)(nil), // 48: openshell.v1.SandboxCondition + (*PlatformEvent)(nil), // 49: openshell.v1.PlatformEvent + (*CreateSandboxRequest)(nil), // 50: openshell.v1.CreateSandboxRequest + (*CreateSandboxTemplateRequest)(nil), // 51: openshell.v1.CreateSandboxTemplateRequest + (*GetSandboxTemplateRequest)(nil), // 52: openshell.v1.GetSandboxTemplateRequest + (*ListSandboxTemplatesRequest)(nil), // 53: openshell.v1.ListSandboxTemplatesRequest + (*DeleteSandboxTemplateRequest)(nil), // 54: openshell.v1.DeleteSandboxTemplateRequest + (*SandboxTemplateResponse)(nil), // 55: openshell.v1.SandboxTemplateResponse + (*ListSandboxTemplatesResponse)(nil), // 56: openshell.v1.ListSandboxTemplatesResponse + (*DeleteSandboxTemplateResponse)(nil), // 57: openshell.v1.DeleteSandboxTemplateResponse + (*BeginRootfsTarStagingRequest)(nil), // 58: openshell.v1.BeginRootfsTarStagingRequest + (*BeginRootfsTarStagingResponse)(nil), // 59: openshell.v1.BeginRootfsTarStagingResponse + (*GetSandboxRequest)(nil), // 60: openshell.v1.GetSandboxRequest + (*ListSandboxesRequest)(nil), // 61: openshell.v1.ListSandboxesRequest + (*ListSandboxProvidersRequest)(nil), // 62: openshell.v1.ListSandboxProvidersRequest + (*AttachSandboxProviderRequest)(nil), // 63: openshell.v1.AttachSandboxProviderRequest + (*DetachSandboxProviderRequest)(nil), // 64: openshell.v1.DetachSandboxProviderRequest + (*DeleteSandboxRequest)(nil), // 65: openshell.v1.DeleteSandboxRequest + (*StopSandboxRequest)(nil), // 66: openshell.v1.StopSandboxRequest + (*StartSandboxRequest)(nil), // 67: openshell.v1.StartSandboxRequest + (*SandboxResponse)(nil), // 68: openshell.v1.SandboxResponse + (*ListSandboxesResponse)(nil), // 69: openshell.v1.ListSandboxesResponse + (*ListSandboxProvidersResponse)(nil), // 70: openshell.v1.ListSandboxProvidersResponse + (*AttachSandboxProviderResponse)(nil), // 71: openshell.v1.AttachSandboxProviderResponse + (*DetachSandboxProviderResponse)(nil), // 72: openshell.v1.DetachSandboxProviderResponse + (*ProviderDesiredIdentity)(nil), // 73: openshell.v1.ProviderDesiredIdentity + (*ConfigSnapshotRevision)(nil), // 74: openshell.v1.ConfigSnapshotRevision + (*SandboxConfigRevision)(nil), // 75: openshell.v1.SandboxConfigRevision + (*ConfigUpdateOperation)(nil), // 76: openshell.v1.ConfigUpdateOperation + (*ProviderMutationReceipt)(nil), // 77: openshell.v1.ProviderMutationReceipt + (*ProviderReadinessObservation)(nil), // 78: openshell.v1.ProviderReadinessObservation + (*ProviderReadinessStatus)(nil), // 79: openshell.v1.ProviderReadinessStatus + (*GetSandboxProviderStatusRequest)(nil), // 80: openshell.v1.GetSandboxProviderStatusRequest + (*GetSandboxProviderStatusResponse)(nil), // 81: openshell.v1.GetSandboxProviderStatusResponse + (*ReportProviderReadinessRequest)(nil), // 82: openshell.v1.ReportProviderReadinessRequest + (*ReportProviderReadinessResponse)(nil), // 83: openshell.v1.ReportProviderReadinessResponse + (*DeleteSandboxResponse)(nil), // 84: openshell.v1.DeleteSandboxResponse + (*CreateSshSessionRequest)(nil), // 85: openshell.v1.CreateSshSessionRequest + (*CreateSshSessionResponse)(nil), // 86: openshell.v1.CreateSshSessionResponse + (*ExposeServiceRequest)(nil), // 87: openshell.v1.ExposeServiceRequest + (*GetServiceRequest)(nil), // 88: openshell.v1.GetServiceRequest + (*ListServicesRequest)(nil), // 89: openshell.v1.ListServicesRequest + (*ListServicesResponse)(nil), // 90: openshell.v1.ListServicesResponse + (*DeleteServiceRequest)(nil), // 91: openshell.v1.DeleteServiceRequest + (*DeleteServiceResponse)(nil), // 92: openshell.v1.DeleteServiceResponse + (*ServiceEndpoint)(nil), // 93: openshell.v1.ServiceEndpoint + (*ServiceEndpointResponse)(nil), // 94: openshell.v1.ServiceEndpointResponse + (*RevokeSshSessionRequest)(nil), // 95: openshell.v1.RevokeSshSessionRequest + (*RevokeSshSessionResponse)(nil), // 96: openshell.v1.RevokeSshSessionResponse + (*ExecSandboxRequest)(nil), // 97: openshell.v1.ExecSandboxRequest + (*ExecSandboxStdout)(nil), // 98: openshell.v1.ExecSandboxStdout + (*ExecSandboxStderr)(nil), // 99: openshell.v1.ExecSandboxStderr + (*ExecSandboxExit)(nil), // 100: openshell.v1.ExecSandboxExit + (*ExecSandboxEvent)(nil), // 101: openshell.v1.ExecSandboxEvent + (*TcpForwardInit)(nil), // 102: openshell.v1.TcpForwardInit + (*TcpForwardFrame)(nil), // 103: openshell.v1.TcpForwardFrame + (*ExecSandboxInput)(nil), // 104: openshell.v1.ExecSandboxInput + (*ExecSandboxWindowResize)(nil), // 105: openshell.v1.ExecSandboxWindowResize + (*SshSession)(nil), // 106: openshell.v1.SshSession + (*WatchSandboxRequest)(nil), // 107: openshell.v1.WatchSandboxRequest + (*SandboxStreamEvent)(nil), // 108: openshell.v1.SandboxStreamEvent + (*SandboxLogLine)(nil), // 109: openshell.v1.SandboxLogLine + (*SandboxStreamWarning)(nil), // 110: openshell.v1.SandboxStreamWarning + (*CreateProviderRequest)(nil), // 111: openshell.v1.CreateProviderRequest + (*GetProviderRequest)(nil), // 112: openshell.v1.GetProviderRequest + (*ListProvidersRequest)(nil), // 113: openshell.v1.ListProvidersRequest + (*UpdateProviderRequest)(nil), // 114: openshell.v1.UpdateProviderRequest + (*DeleteProviderRequest)(nil), // 115: openshell.v1.DeleteProviderRequest + (*ProviderResponse)(nil), // 116: openshell.v1.ProviderResponse + (*ListProvidersResponse)(nil), // 117: openshell.v1.ListProvidersResponse + (*ListProviderProfilesRequest)(nil), // 118: openshell.v1.ListProviderProfilesRequest + (*GetProviderProfileRequest)(nil), // 119: openshell.v1.GetProviderProfileRequest + (*ProviderProfileImportItem)(nil), // 120: openshell.v1.ProviderProfileImportItem + (*ProviderProfileDiagnostic)(nil), // 121: openshell.v1.ProviderProfileDiagnostic + (*ProviderCredentialTokenGrantAudienceOverride)(nil), // 122: openshell.v1.ProviderCredentialTokenGrantAudienceOverride + (*ProviderCredentialTokenGrantSubjectToken)(nil), // 123: openshell.v1.ProviderCredentialTokenGrantSubjectToken + (*ProviderCredentialTokenGrant)(nil), // 124: openshell.v1.ProviderCredentialTokenGrant + (*ProviderProfileCredential)(nil), // 125: openshell.v1.ProviderProfileCredential + (*ProviderCredentialRefreshMaterial)(nil), // 126: openshell.v1.ProviderCredentialRefreshMaterial + (*ProviderCredentialRefreshOutput)(nil), // 127: openshell.v1.ProviderCredentialRefreshOutput + (*ProviderCredentialRefresh)(nil), // 128: openshell.v1.ProviderCredentialRefresh + (*ProviderCredentialRefreshStatus)(nil), // 129: openshell.v1.ProviderCredentialRefreshStatus + (*ProviderProfileDiscovery)(nil), // 130: openshell.v1.ProviderProfileDiscovery + (*GetProviderRefreshStatusRequest)(nil), // 131: openshell.v1.GetProviderRefreshStatusRequest + (*GetProviderRefreshStatusResponse)(nil), // 132: openshell.v1.GetProviderRefreshStatusResponse + (*ConfigureProviderRefreshRequest)(nil), // 133: openshell.v1.ConfigureProviderRefreshRequest + (*ConfigureProviderRefreshResponse)(nil), // 134: openshell.v1.ConfigureProviderRefreshResponse + (*RotateProviderCredentialRequest)(nil), // 135: openshell.v1.RotateProviderCredentialRequest + (*RotateProviderCredentialResponse)(nil), // 136: openshell.v1.RotateProviderCredentialResponse + (*DeleteProviderRefreshRequest)(nil), // 137: openshell.v1.DeleteProviderRefreshRequest + (*DeleteProviderRefreshResponse)(nil), // 138: openshell.v1.DeleteProviderRefreshResponse + (*ProviderProfile)(nil), // 139: openshell.v1.ProviderProfile + (*ProviderProfileResponse)(nil), // 140: openshell.v1.ProviderProfileResponse + (*ListProviderProfilesResponse)(nil), // 141: openshell.v1.ListProviderProfilesResponse + (*ImportProviderProfilesRequest)(nil), // 142: openshell.v1.ImportProviderProfilesRequest + (*ImportProviderProfilesResponse)(nil), // 143: openshell.v1.ImportProviderProfilesResponse + (*UpdateProviderProfilesRequest)(nil), // 144: openshell.v1.UpdateProviderProfilesRequest + (*UpdateProviderProfilesResponse)(nil), // 145: openshell.v1.UpdateProviderProfilesResponse + (*LintProviderProfilesRequest)(nil), // 146: openshell.v1.LintProviderProfilesRequest + (*LintProviderProfilesResponse)(nil), // 147: openshell.v1.LintProviderProfilesResponse + (*DeleteProviderResponse)(nil), // 148: openshell.v1.DeleteProviderResponse + (*DeleteProviderProfileRequest)(nil), // 149: openshell.v1.DeleteProviderProfileRequest + (*DeleteProviderProfileResponse)(nil), // 150: openshell.v1.DeleteProviderProfileResponse + (*GetSandboxProviderEnvironmentRequest)(nil), // 151: openshell.v1.GetSandboxProviderEnvironmentRequest + (*StaticCredentialEndpointBinding)(nil), // 152: openshell.v1.StaticCredentialEndpointBinding + (*StaticCredentialBinding)(nil), // 153: openshell.v1.StaticCredentialBinding + (*GetSandboxProviderEnvironmentResponse)(nil), // 154: openshell.v1.GetSandboxProviderEnvironmentResponse + (*ExchangeProviderSubjectTokenRequest)(nil), // 155: openshell.v1.ExchangeProviderSubjectTokenRequest + (*ExchangeProviderSubjectTokenResponse)(nil), // 156: openshell.v1.ExchangeProviderSubjectTokenResponse + (*UpdateConfigRequest)(nil), // 157: openshell.v1.UpdateConfigRequest + (*PolicyMergeOperation)(nil), // 158: openshell.v1.PolicyMergeOperation + (*AddNetworkRule)(nil), // 159: openshell.v1.AddNetworkRule + (*RemoveNetworkEndpoint)(nil), // 160: openshell.v1.RemoveNetworkEndpoint + (*RemoveNetworkRule)(nil), // 161: openshell.v1.RemoveNetworkRule + (*L7RuleTarget)(nil), // 162: openshell.v1.L7RuleTarget + (*AddDenyRules)(nil), // 163: openshell.v1.AddDenyRules + (*AddAllowRules)(nil), // 164: openshell.v1.AddAllowRules + (*RemoveNetworkBinary)(nil), // 165: openshell.v1.RemoveNetworkBinary + (*UpdateConfigResponse)(nil), // 166: openshell.v1.UpdateConfigResponse + (*GetSandboxPolicyStatusRequest)(nil), // 167: openshell.v1.GetSandboxPolicyStatusRequest + (*GetSandboxPolicyStatusResponse)(nil), // 168: openshell.v1.GetSandboxPolicyStatusResponse + (*ListSandboxPoliciesRequest)(nil), // 169: openshell.v1.ListSandboxPoliciesRequest + (*ListSandboxPoliciesResponse)(nil), // 170: openshell.v1.ListSandboxPoliciesResponse + (*ReportPolicyStatusRequest)(nil), // 171: openshell.v1.ReportPolicyStatusRequest + (*ReportPolicyStatusResponse)(nil), // 172: openshell.v1.ReportPolicyStatusResponse + (*SandboxConfigurationAdmission)(nil), // 173: openshell.v1.SandboxConfigurationAdmission + (*ReportSandboxConfigurationRequest)(nil), // 174: openshell.v1.ReportSandboxConfigurationRequest + (*ReportSandboxConfigurationResponse)(nil), // 175: openshell.v1.ReportSandboxConfigurationResponse + (*SandboxPolicyRevision)(nil), // 176: openshell.v1.SandboxPolicyRevision + (*GetSandboxLogsRequest)(nil), // 177: openshell.v1.GetSandboxLogsRequest + (*PushSandboxLogsRequest)(nil), // 178: openshell.v1.PushSandboxLogsRequest + (*PushSandboxLogsResponse)(nil), // 179: openshell.v1.PushSandboxLogsResponse + (*GetSandboxLogsResponse)(nil), // 180: openshell.v1.GetSandboxLogsResponse + (*SupervisorMessage)(nil), // 181: openshell.v1.SupervisorMessage + (*GatewayMessage)(nil), // 182: openshell.v1.GatewayMessage + (*SupervisorHello)(nil), // 183: openshell.v1.SupervisorHello + (*SessionAccepted)(nil), // 184: openshell.v1.SessionAccepted + (*SessionRejected)(nil), // 185: openshell.v1.SessionRejected + (*SupervisorHeartbeat)(nil), // 186: openshell.v1.SupervisorHeartbeat + (*GatewayHeartbeat)(nil), // 187: openshell.v1.GatewayHeartbeat + (*ReportMainProcessExitRequest)(nil), // 188: openshell.v1.ReportMainProcessExitRequest + (*ReportMainProcessExitResponse)(nil), // 189: openshell.v1.ReportMainProcessExitResponse + (*FinalizeMainProcessExitRequest)(nil), // 190: openshell.v1.FinalizeMainProcessExitRequest + (*FinalizeMainProcessExitResponse)(nil), // 191: openshell.v1.FinalizeMainProcessExitResponse + (*RelayOpen)(nil), // 192: openshell.v1.RelayOpen + (*SshRelayTarget)(nil), // 193: openshell.v1.SshRelayTarget + (*TcpRelayTarget)(nil), // 194: openshell.v1.TcpRelayTarget + (*RelayInit)(nil), // 195: openshell.v1.RelayInit + (*RelayFrame)(nil), // 196: openshell.v1.RelayFrame + (*RelayOpenResult)(nil), // 197: openshell.v1.RelayOpenResult + (*RelayClose)(nil), // 198: openshell.v1.RelayClose + (*L7RequestSample)(nil), // 199: openshell.v1.L7RequestSample + (*DenialSummary)(nil), // 200: openshell.v1.DenialSummary + (*DenialGroupCount)(nil), // 201: openshell.v1.DenialGroupCount + (*NetworkActivitySummary)(nil), // 202: openshell.v1.NetworkActivitySummary + (*PolicyChunk)(nil), // 203: openshell.v1.PolicyChunk + (*DraftPolicyUpdate)(nil), // 204: openshell.v1.DraftPolicyUpdate + (*SubmitPolicyAnalysisRequest)(nil), // 205: openshell.v1.SubmitPolicyAnalysisRequest + (*SubmitPolicyAnalysisResponse)(nil), // 206: openshell.v1.SubmitPolicyAnalysisResponse + (*GetDraftPolicyRequest)(nil), // 207: openshell.v1.GetDraftPolicyRequest + (*GetDraftPolicyResponse)(nil), // 208: openshell.v1.GetDraftPolicyResponse + (*ApproveDraftChunkRequest)(nil), // 209: openshell.v1.ApproveDraftChunkRequest + (*ApproveDraftChunkResponse)(nil), // 210: openshell.v1.ApproveDraftChunkResponse + (*RejectDraftChunkRequest)(nil), // 211: openshell.v1.RejectDraftChunkRequest + (*RejectDraftChunkResponse)(nil), // 212: openshell.v1.RejectDraftChunkResponse + (*DraftChunkApproval)(nil), // 213: openshell.v1.DraftChunkApproval + (*ApproveAllDraftChunksRequest)(nil), // 214: openshell.v1.ApproveAllDraftChunksRequest + (*ApproveAllDraftChunksResponse)(nil), // 215: openshell.v1.ApproveAllDraftChunksResponse + (*EditDraftChunkRequest)(nil), // 216: openshell.v1.EditDraftChunkRequest + (*EditDraftChunkResponse)(nil), // 217: openshell.v1.EditDraftChunkResponse + (*UndoDraftChunkRequest)(nil), // 218: openshell.v1.UndoDraftChunkRequest + (*UndoDraftChunkResponse)(nil), // 219: openshell.v1.UndoDraftChunkResponse + (*ClearDraftChunksRequest)(nil), // 220: openshell.v1.ClearDraftChunksRequest + (*ClearDraftChunksResponse)(nil), // 221: openshell.v1.ClearDraftChunksResponse + (*GetDraftHistoryRequest)(nil), // 222: openshell.v1.GetDraftHistoryRequest + (*DraftHistoryEntry)(nil), // 223: openshell.v1.DraftHistoryEntry + (*GetDraftHistoryResponse)(nil), // 224: openshell.v1.GetDraftHistoryResponse + (*CreateWorkspaceRequest)(nil), // 225: openshell.v1.CreateWorkspaceRequest + (*CreateWorkspaceResponse)(nil), // 226: openshell.v1.CreateWorkspaceResponse + (*GetWorkspaceRequest)(nil), // 227: openshell.v1.GetWorkspaceRequest + (*GetWorkspaceResponse)(nil), // 228: openshell.v1.GetWorkspaceResponse + (*ListWorkspacesRequest)(nil), // 229: openshell.v1.ListWorkspacesRequest + (*ListWorkspacesResponse)(nil), // 230: openshell.v1.ListWorkspacesResponse + (*DeleteWorkspaceRequest)(nil), // 231: openshell.v1.DeleteWorkspaceRequest + (*DeleteWorkspaceResponse)(nil), // 232: openshell.v1.DeleteWorkspaceResponse + (*WorkspaceMember)(nil), // 233: openshell.v1.WorkspaceMember + (*AddWorkspaceMemberRequest)(nil), // 234: openshell.v1.AddWorkspaceMemberRequest + (*AddWorkspaceMemberResponse)(nil), // 235: openshell.v1.AddWorkspaceMemberResponse + (*RemoveWorkspaceMemberRequest)(nil), // 236: openshell.v1.RemoveWorkspaceMemberRequest + (*RemoveWorkspaceMemberResponse)(nil), // 237: openshell.v1.RemoveWorkspaceMemberResponse + (*ListWorkspaceMembersRequest)(nil), // 238: openshell.v1.ListWorkspaceMembersRequest + (*ListWorkspaceMembersResponse)(nil), // 239: openshell.v1.ListWorkspaceMembersResponse + (*ExtensionServiceCredential)(nil), // 240: openshell.v1.ExtensionServiceCredential + (*EndpointObservation)(nil), // 241: openshell.v1.EndpointObservation + (*ReportEndpointStatusRequest)(nil), // 242: openshell.v1.ReportEndpointStatusRequest + (*ReportEndpointStatusResponse)(nil), // 243: openshell.v1.ReportEndpointStatusResponse + (*EndpointStatus)(nil), // 244: openshell.v1.EndpointStatus + (*SandboxProvisioning)(nil), // 245: openshell.v1.SandboxProvisioning + nil, // 246: openshell.v1.SandboxSpec.EnvironmentEntry + nil, // 247: openshell.v1.SandboxTemplate.LabelsEntry + nil, // 248: openshell.v1.SandboxTemplate.AnnotationsEntry + nil, // 249: openshell.v1.SandboxTemplate.EnvironmentEntry + nil, // 250: openshell.v1.SandboxWorkloadConfig.EnvironmentEntry + nil, // 251: openshell.v1.PlatformEvent.MetadataEntry + nil, // 252: openshell.v1.CreateSandboxRequest.LabelsEntry + nil, // 253: openshell.v1.CreateSandboxRequest.AnnotationsEntry + nil, // 254: openshell.v1.ExecSandboxRequest.EnvironmentEntry + nil, // 255: openshell.v1.SandboxLogLine.FieldsEntry + nil, // 256: openshell.v1.UpdateProviderRequest.CredentialExpirationTimesEntry + nil, // 257: openshell.v1.ConfigureProviderRefreshRequest.MaterialEntry + nil, // 258: openshell.v1.ProviderProfile.AnnotationsEntry + nil, // 259: openshell.v1.GetSandboxProviderEnvironmentResponse.EnvironmentEntry + nil, // 260: openshell.v1.GetSandboxProviderEnvironmentResponse.CredentialExpirationTimesEntry + nil, // 261: openshell.v1.GetSandboxProviderEnvironmentResponse.DynamicCredentialsEntry + nil, // 262: openshell.v1.GetSandboxProviderEnvironmentResponse.StaticCredentialBindingsEntry + nil, // 263: openshell.v1.UpdateConfigRequest.AnnotationsEntry + nil, // 264: openshell.v1.UpdateConfigResponse.AnnotationsEntry + nil, // 265: openshell.v1.SandboxPolicyRevision.ProvenanceEntry + nil, // 266: openshell.v1.CreateWorkspaceRequest.LabelsEntry + (*timestamppb.Timestamp)(nil), // 267: google.protobuf.Timestamp + (*datamodelv1.ObjectMeta)(nil), // 268: openshell.datamodel.v1.ObjectMeta + (*sandboxv1.SandboxPolicy)(nil), // 269: openshell.sandbox.v1.SandboxPolicy + (*structpb.Struct)(nil), // 270: google.protobuf.Struct + (*durationpb.Duration)(nil), // 271: google.protobuf.Duration + (*datamodelv1.WorkspaceSelector)(nil), // 272: openshell.datamodel.v1.WorkspaceSelector + (*datamodelv1.Provider)(nil), // 273: openshell.datamodel.v1.Provider + (sandboxv1.PolicySource)(0), // 274: openshell.sandbox.v1.PolicySource + (*sandboxv1.NetworkEndpoint)(nil), // 275: openshell.sandbox.v1.NetworkEndpoint + (*sandboxv1.NetworkBinary)(nil), // 276: openshell.sandbox.v1.NetworkBinary + (*sandboxv1.SettingValue)(nil), // 277: openshell.sandbox.v1.SettingValue + (*sandboxv1.NetworkPolicyRule)(nil), // 278: openshell.sandbox.v1.NetworkPolicyRule + (*sandboxv1.L7DenyRule)(nil), // 279: openshell.sandbox.v1.L7DenyRule + (*sandboxv1.L7Rule)(nil), // 280: openshell.sandbox.v1.L7Rule + (*datamodelv1.Workspace)(nil), // 281: openshell.datamodel.v1.Workspace + (*sandboxv1.GetSandboxConfigRequest)(nil), // 282: openshell.sandbox.v1.GetSandboxConfigRequest + (*sandboxv1.GetGatewayConfigRequest)(nil), // 283: openshell.sandbox.v1.GetGatewayConfigRequest + (*sandboxv1.GetSandboxConfigResponse)(nil), // 284: openshell.sandbox.v1.GetSandboxConfigResponse + (*sandboxv1.GetGatewayConfigResponse)(nil), // 285: openshell.sandbox.v1.GetGatewayConfigResponse } var file_openshell_proto_depIdxs = []int32{ - 265, // 0: openshell.v1.IssueSandboxTokenResponse.expiration_time:type_name -> google.protobuf.Timestamp - 265, // 1: openshell.v1.RefreshSandboxTokenResponse.expiration_time:type_name -> google.protobuf.Timestamp - 238, // 2: openshell.v1.RefreshSandboxTokenResponse.extension_credentials:type_name -> openshell.v1.ExtensionServiceCredential - 265, // 3: openshell.v1.RefreshSandboxTokenResponse.sandbox_expiration_time:type_name -> google.protobuf.Timestamp + 267, // 0: openshell.v1.IssueSandboxTokenResponse.expiration_time:type_name -> google.protobuf.Timestamp + 267, // 1: openshell.v1.RefreshSandboxTokenResponse.expiration_time:type_name -> google.protobuf.Timestamp + 240, // 2: openshell.v1.RefreshSandboxTokenResponse.extension_credentials:type_name -> openshell.v1.ExtensionServiceCredential + 267, // 3: openshell.v1.RefreshSandboxTokenResponse.sandbox_expiration_time:type_name -> google.protobuf.Timestamp 12, // 4: openshell.v1.HealthResponse.status:type_name -> openshell.v1.ServiceStatus 12, // 5: openshell.v1.GetGatewayInfoResponse.status:type_name -> openshell.v1.ServiceStatus 27, // 6: openshell.v1.GetGatewayInfoResponse.compute_drivers:type_name -> openshell.v1.ComputeDriverInfo @@ -18959,452 +19092,455 @@ var file_openshell_proto_depIdxs = []int32{ 30, // 9: openshell.v1.ResourceCapabilities.cpu:type_name -> openshell.v1.CpuResourceCapabilities 31, // 10: openshell.v1.ResourceCapabilities.memory:type_name -> openshell.v1.MemoryResourceCapabilities 32, // 11: openshell.v1.ResourceCapabilities.gpu:type_name -> openshell.v1.GpuResourceCapabilities - 266, // 12: openshell.v1.Sandbox.metadata:type_name -> openshell.datamodel.v1.ObjectMeta + 268, // 12: openshell.v1.Sandbox.metadata:type_name -> openshell.datamodel.v1.ObjectMeta 34, // 13: openshell.v1.Sandbox.spec:type_name -> openshell.v1.SandboxSpec - 45, // 14: openshell.v1.Sandbox.status:type_name -> openshell.v1.SandboxStatus - 44, // 15: openshell.v1.Sandbox.created_from_workload_template:type_name -> openshell.v1.SandboxWorkloadTemplateProvenance - 244, // 16: openshell.v1.SandboxSpec.environment:type_name -> openshell.v1.SandboxSpec.EnvironmentEntry - 37, // 17: openshell.v1.SandboxSpec.template:type_name -> openshell.v1.SandboxTemplate - 267, // 18: openshell.v1.SandboxSpec.policy:type_name -> openshell.sandbox.v1.SandboxPolicy + 47, // 14: openshell.v1.Sandbox.status:type_name -> openshell.v1.SandboxStatus + 46, // 15: openshell.v1.Sandbox.created_from_workload_template:type_name -> openshell.v1.SandboxWorkloadTemplateProvenance + 246, // 16: openshell.v1.SandboxSpec.environment:type_name -> openshell.v1.SandboxSpec.EnvironmentEntry + 39, // 17: openshell.v1.SandboxSpec.template:type_name -> openshell.v1.SandboxTemplate + 269, // 18: openshell.v1.SandboxSpec.policy:type_name -> openshell.sandbox.v1.SandboxPolicy 35, // 19: openshell.v1.SandboxSpec.resource_requirements:type_name -> openshell.v1.ResourceRequirements 36, // 20: openshell.v1.ResourceRequirements.gpu:type_name -> openshell.v1.GpuResourceRequirements - 245, // 21: openshell.v1.SandboxTemplate.labels:type_name -> openshell.v1.SandboxTemplate.LabelsEntry - 246, // 22: openshell.v1.SandboxTemplate.annotations:type_name -> openshell.v1.SandboxTemplate.AnnotationsEntry - 247, // 23: openshell.v1.SandboxTemplate.environment:type_name -> openshell.v1.SandboxTemplate.EnvironmentEntry - 268, // 24: openshell.v1.SandboxTemplate.resources:type_name -> google.protobuf.Struct - 268, // 25: openshell.v1.SandboxTemplate.driver_config:type_name -> google.protobuf.Struct - 266, // 26: openshell.v1.SandboxWorkloadTemplate.metadata:type_name -> openshell.datamodel.v1.ObjectMeta - 39, // 27: openshell.v1.SandboxWorkloadTemplate.spec:type_name -> openshell.v1.SandboxWorkloadTemplateSpec - 40, // 28: openshell.v1.SandboxWorkloadTemplateSpec.workload:type_name -> openshell.v1.SandboxWorkloadConfig - 268, // 29: openshell.v1.SandboxWorkloadTemplateSpec.driver_config:type_name -> google.protobuf.Struct - 42, // 30: openshell.v1.SandboxWorkloadTemplateSpec.desired_service_level:type_name -> openshell.v1.SandboxServiceLevel - 248, // 31: openshell.v1.SandboxWorkloadConfig.environment:type_name -> openshell.v1.SandboxWorkloadConfig.EnvironmentEntry - 41, // 32: openshell.v1.SandboxWorkloadConfig.resources:type_name -> openshell.v1.SandboxResources - 36, // 33: openshell.v1.SandboxResources.gpu:type_name -> openshell.v1.GpuResourceRequirements - 43, // 34: openshell.v1.SandboxServiceLevel.startup:type_name -> openshell.v1.SandboxStartup - 269, // 35: openshell.v1.SandboxStartup.ready_within:type_name -> google.protobuf.Duration - 46, // 36: openshell.v1.SandboxStatus.conditions:type_name -> openshell.v1.SandboxCondition - 0, // 37: openshell.v1.SandboxStatus.phase:type_name -> openshell.v1.SandboxPhase - 242, // 38: openshell.v1.SandboxStatus.endpoint_statuses:type_name -> openshell.v1.EndpointStatus - 171, // 39: openshell.v1.SandboxStatus.configuration_admission:type_name -> openshell.v1.SandboxConfigurationAdmission - 243, // 40: openshell.v1.SandboxStatus.provisioning:type_name -> openshell.v1.SandboxProvisioning - 265, // 41: openshell.v1.SandboxCondition.transition_time:type_name -> google.protobuf.Timestamp - 265, // 42: openshell.v1.PlatformEvent.event_time:type_name -> google.protobuf.Timestamp - 249, // 43: openshell.v1.PlatformEvent.metadata:type_name -> openshell.v1.PlatformEvent.MetadataEntry - 34, // 44: openshell.v1.CreateSandboxRequest.spec:type_name -> openshell.v1.SandboxSpec - 250, // 45: openshell.v1.CreateSandboxRequest.labels:type_name -> openshell.v1.CreateSandboxRequest.LabelsEntry - 251, // 46: openshell.v1.CreateSandboxRequest.annotations:type_name -> openshell.v1.CreateSandboxRequest.AnnotationsEntry - 270, // 47: openshell.v1.CreateSandboxRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 38, // 48: openshell.v1.CreateSandboxTemplateRequest.template:type_name -> openshell.v1.SandboxWorkloadTemplate - 270, // 49: openshell.v1.CreateSandboxTemplateRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 270, // 50: openshell.v1.GetSandboxTemplateRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 270, // 51: openshell.v1.ListSandboxTemplatesRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 270, // 52: openshell.v1.DeleteSandboxTemplateRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 38, // 53: openshell.v1.SandboxTemplateResponse.template:type_name -> openshell.v1.SandboxWorkloadTemplate - 38, // 54: openshell.v1.ListSandboxTemplatesResponse.templates:type_name -> openshell.v1.SandboxWorkloadTemplate - 15, // 55: openshell.v1.DeleteSandboxTemplateResponse.outcome:type_name -> openshell.v1.DeletionOutcome - 270, // 56: openshell.v1.BeginRootfsTarStagingRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 265, // 57: openshell.v1.BeginRootfsTarStagingResponse.expiration_time:type_name -> google.protobuf.Timestamp - 270, // 58: openshell.v1.GetSandboxRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 270, // 59: openshell.v1.ListSandboxesRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 270, // 60: openshell.v1.ListSandboxProvidersRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 270, // 61: openshell.v1.AttachSandboxProviderRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 270, // 62: openshell.v1.DetachSandboxProviderRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 270, // 63: openshell.v1.DeleteSandboxRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 270, // 64: openshell.v1.StopSandboxRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 270, // 65: openshell.v1.StartSandboxRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 33, // 66: openshell.v1.SandboxResponse.sandbox:type_name -> openshell.v1.Sandbox - 33, // 67: openshell.v1.ListSandboxesResponse.sandboxes:type_name -> openshell.v1.Sandbox - 271, // 68: openshell.v1.ListSandboxProvidersResponse.providers:type_name -> openshell.datamodel.v1.Provider - 33, // 69: openshell.v1.AttachSandboxProviderResponse.sandbox:type_name -> openshell.v1.Sandbox - 75, // 70: openshell.v1.AttachSandboxProviderResponse.receipt:type_name -> openshell.v1.ProviderMutationReceipt - 33, // 71: openshell.v1.DetachSandboxProviderResponse.sandbox:type_name -> openshell.v1.Sandbox - 75, // 72: openshell.v1.DetachSandboxProviderResponse.receipt:type_name -> openshell.v1.ProviderMutationReceipt - 73, // 73: openshell.v1.ConfigSnapshotRevision.sandbox_config:type_name -> openshell.v1.SandboxConfigRevision - 71, // 74: openshell.v1.ConfigSnapshotRevision.provider_target:type_name -> openshell.v1.ProviderDesiredIdentity - 272, // 75: openshell.v1.SandboxConfigRevision.policy_source:type_name -> openshell.sandbox.v1.PolicySource - 4, // 76: openshell.v1.ConfigUpdateOperation.component:type_name -> openshell.v1.ConfigComponent - 72, // 77: openshell.v1.ConfigUpdateOperation.target_revision:type_name -> openshell.v1.ConfigSnapshotRevision - 6, // 78: openshell.v1.ConfigUpdateOperation.state:type_name -> openshell.v1.ConfigUpdateOperationState - 5, // 79: openshell.v1.ConfigUpdateOperation.outcome:type_name -> openshell.v1.ConfigApplyOutcome - 265, // 80: openshell.v1.ConfigUpdateOperation.created_time:type_name -> google.protobuf.Timestamp - 265, // 81: openshell.v1.ConfigUpdateOperation.updated_time:type_name -> google.protobuf.Timestamp - 265, // 82: openshell.v1.ConfigUpdateOperation.completed_time:type_name -> google.protobuf.Timestamp - 1, // 83: openshell.v1.ProviderMutationReceipt.kind:type_name -> openshell.v1.ProviderMutationKind - 71, // 84: openshell.v1.ProviderMutationReceipt.desired:type_name -> openshell.v1.ProviderDesiredIdentity - 265, // 85: openshell.v1.ProviderMutationReceipt.persisted_time:type_name -> google.protobuf.Timestamp - 3, // 86: openshell.v1.ProviderReadinessObservation.reason:type_name -> openshell.v1.ProviderReadinessReason - 75, // 87: openshell.v1.ProviderReadinessStatus.receipt:type_name -> openshell.v1.ProviderMutationReceipt - 2, // 88: openshell.v1.ProviderReadinessStatus.state:type_name -> openshell.v1.ProviderReadinessState - 3, // 89: openshell.v1.ProviderReadinessStatus.reason:type_name -> openshell.v1.ProviderReadinessReason - 76, // 90: openshell.v1.ProviderReadinessStatus.observed:type_name -> openshell.v1.ProviderReadinessObservation - 265, // 91: openshell.v1.ProviderReadinessStatus.observed_time:type_name -> google.protobuf.Timestamp - 265, // 92: openshell.v1.ProviderReadinessStatus.evaluated_time:type_name -> google.protobuf.Timestamp - 74, // 93: openshell.v1.ProviderReadinessStatus.operation:type_name -> openshell.v1.ConfigUpdateOperation - 270, // 94: openshell.v1.GetSandboxProviderStatusRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 77, // 95: openshell.v1.GetSandboxProviderStatusResponse.status:type_name -> openshell.v1.ProviderReadinessStatus - 76, // 96: openshell.v1.ReportProviderReadinessRequest.observation:type_name -> openshell.v1.ProviderReadinessObservation - 269, // 97: openshell.v1.ReportProviderReadinessResponse.report_interval:type_name -> google.protobuf.Duration - 269, // 98: openshell.v1.ReportProviderReadinessResponse.observation_ttl:type_name -> google.protobuf.Duration - 15, // 99: openshell.v1.DeleteSandboxResponse.outcome:type_name -> openshell.v1.DeletionOutcome - 265, // 100: openshell.v1.CreateSshSessionResponse.expiration_time:type_name -> google.protobuf.Timestamp - 270, // 101: openshell.v1.ExposeServiceRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 270, // 102: openshell.v1.GetServiceRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 270, // 103: openshell.v1.ListServicesRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 92, // 104: openshell.v1.ListServicesResponse.services:type_name -> openshell.v1.ServiceEndpointResponse - 270, // 105: openshell.v1.DeleteServiceRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 15, // 106: openshell.v1.DeleteServiceResponse.outcome:type_name -> openshell.v1.DeletionOutcome - 266, // 107: openshell.v1.ServiceEndpoint.metadata:type_name -> openshell.datamodel.v1.ObjectMeta - 91, // 108: openshell.v1.ServiceEndpointResponse.endpoint:type_name -> openshell.v1.ServiceEndpoint - 15, // 109: openshell.v1.RevokeSshSessionResponse.outcome:type_name -> openshell.v1.DeletionOutcome - 252, // 110: openshell.v1.ExecSandboxRequest.environment:type_name -> openshell.v1.ExecSandboxRequest.EnvironmentEntry - 269, // 111: openshell.v1.ExecSandboxRequest.execution_timeout:type_name -> google.protobuf.Duration - 96, // 112: openshell.v1.ExecSandboxEvent.stdout:type_name -> openshell.v1.ExecSandboxStdout - 97, // 113: openshell.v1.ExecSandboxEvent.stderr:type_name -> openshell.v1.ExecSandboxStderr - 98, // 114: openshell.v1.ExecSandboxEvent.exit:type_name -> openshell.v1.ExecSandboxExit - 191, // 115: openshell.v1.TcpForwardInit.ssh:type_name -> openshell.v1.SshRelayTarget - 192, // 116: openshell.v1.TcpForwardInit.tcp:type_name -> openshell.v1.TcpRelayTarget - 100, // 117: openshell.v1.TcpForwardFrame.init:type_name -> openshell.v1.TcpForwardInit - 95, // 118: openshell.v1.ExecSandboxInput.start:type_name -> openshell.v1.ExecSandboxRequest - 103, // 119: openshell.v1.ExecSandboxInput.resize:type_name -> openshell.v1.ExecSandboxWindowResize - 266, // 120: openshell.v1.SshSession.metadata:type_name -> openshell.datamodel.v1.ObjectMeta - 265, // 121: openshell.v1.SshSession.expiration_time:type_name -> google.protobuf.Timestamp - 265, // 122: openshell.v1.WatchSandboxRequest.since_time:type_name -> google.protobuf.Timestamp - 33, // 123: openshell.v1.SandboxStreamEvent.sandbox:type_name -> openshell.v1.Sandbox - 107, // 124: openshell.v1.SandboxStreamEvent.log:type_name -> openshell.v1.SandboxLogLine - 47, // 125: openshell.v1.SandboxStreamEvent.event:type_name -> openshell.v1.PlatformEvent - 108, // 126: openshell.v1.SandboxStreamEvent.warning:type_name -> openshell.v1.SandboxStreamWarning - 202, // 127: openshell.v1.SandboxStreamEvent.draft_policy_update:type_name -> openshell.v1.DraftPolicyUpdate - 265, // 128: openshell.v1.SandboxLogLine.event_time:type_name -> google.protobuf.Timestamp - 253, // 129: openshell.v1.SandboxLogLine.fields:type_name -> openshell.v1.SandboxLogLine.FieldsEntry - 271, // 130: openshell.v1.CreateProviderRequest.provider:type_name -> openshell.datamodel.v1.Provider - 270, // 131: openshell.v1.CreateProviderRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 270, // 132: openshell.v1.GetProviderRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 270, // 133: openshell.v1.ListProvidersRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 271, // 134: openshell.v1.UpdateProviderRequest.provider:type_name -> openshell.datamodel.v1.Provider - 254, // 135: openshell.v1.UpdateProviderRequest.credential_expiration_times:type_name -> openshell.v1.UpdateProviderRequest.CredentialExpirationTimesEntry - 270, // 136: openshell.v1.UpdateProviderRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 270, // 137: openshell.v1.DeleteProviderRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 271, // 138: openshell.v1.ProviderResponse.provider:type_name -> openshell.datamodel.v1.Provider - 75, // 139: openshell.v1.ProviderResponse.target_receipts:type_name -> openshell.v1.ProviderMutationReceipt - 271, // 140: openshell.v1.ListProvidersResponse.providers:type_name -> openshell.datamodel.v1.Provider - 137, // 141: openshell.v1.ProviderProfileImportItem.profile:type_name -> openshell.v1.ProviderProfile - 269, // 142: openshell.v1.ProviderCredentialTokenGrant.cache_ttl:type_name -> google.protobuf.Duration - 120, // 143: openshell.v1.ProviderCredentialTokenGrant.audience_overrides:type_name -> openshell.v1.ProviderCredentialTokenGrantAudienceOverride - 7, // 144: openshell.v1.ProviderCredentialTokenGrant.grant_type:type_name -> openshell.v1.ProviderCredentialTokenGrantType - 121, // 145: openshell.v1.ProviderCredentialTokenGrant.subject_token:type_name -> openshell.v1.ProviderCredentialTokenGrantSubjectToken - 126, // 146: openshell.v1.ProviderProfileCredential.refresh:type_name -> openshell.v1.ProviderCredentialRefresh - 122, // 147: openshell.v1.ProviderProfileCredential.token_grant:type_name -> openshell.v1.ProviderCredentialTokenGrant - 8, // 148: openshell.v1.ProviderCredentialRefresh.strategy:type_name -> openshell.v1.ProviderCredentialRefreshStrategy - 269, // 149: openshell.v1.ProviderCredentialRefresh.refresh_before:type_name -> google.protobuf.Duration - 269, // 150: openshell.v1.ProviderCredentialRefresh.max_lifetime:type_name -> google.protobuf.Duration - 124, // 151: openshell.v1.ProviderCredentialRefresh.material:type_name -> openshell.v1.ProviderCredentialRefreshMaterial - 125, // 152: openshell.v1.ProviderCredentialRefresh.additional_outputs:type_name -> openshell.v1.ProviderCredentialRefreshOutput - 8, // 153: openshell.v1.ProviderCredentialRefreshStatus.strategy:type_name -> openshell.v1.ProviderCredentialRefreshStrategy - 265, // 154: openshell.v1.ProviderCredentialRefreshStatus.expiration_time:type_name -> google.protobuf.Timestamp - 265, // 155: openshell.v1.ProviderCredentialRefreshStatus.next_refresh_time:type_name -> google.protobuf.Timestamp - 265, // 156: openshell.v1.ProviderCredentialRefreshStatus.last_refresh_time:type_name -> google.protobuf.Timestamp - 14, // 157: openshell.v1.ProviderCredentialRefreshStatus.recovery_action:type_name -> openshell.v1.ProviderCredentialRefreshRecoveryAction - 265, // 158: openshell.v1.ProviderCredentialRefreshStatus.last_error_time:type_name -> google.protobuf.Timestamp - 270, // 159: openshell.v1.GetProviderRefreshStatusRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 127, // 160: openshell.v1.GetProviderRefreshStatusResponse.credentials:type_name -> openshell.v1.ProviderCredentialRefreshStatus - 8, // 161: openshell.v1.ConfigureProviderRefreshRequest.strategy:type_name -> openshell.v1.ProviderCredentialRefreshStrategy - 255, // 162: openshell.v1.ConfigureProviderRefreshRequest.material:type_name -> openshell.v1.ConfigureProviderRefreshRequest.MaterialEntry - 265, // 163: openshell.v1.ConfigureProviderRefreshRequest.expiration_time:type_name -> google.protobuf.Timestamp - 270, // 164: openshell.v1.ConfigureProviderRefreshRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 127, // 165: openshell.v1.ConfigureProviderRefreshResponse.status:type_name -> openshell.v1.ProviderCredentialRefreshStatus - 270, // 166: openshell.v1.RotateProviderCredentialRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 127, // 167: openshell.v1.RotateProviderCredentialResponse.status:type_name -> openshell.v1.ProviderCredentialRefreshStatus - 270, // 168: openshell.v1.DeleteProviderRefreshRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 15, // 169: openshell.v1.DeleteProviderRefreshResponse.outcome:type_name -> openshell.v1.DeletionOutcome - 9, // 170: openshell.v1.ProviderProfile.category:type_name -> openshell.v1.ProviderProfileCategory - 123, // 171: openshell.v1.ProviderProfile.credentials:type_name -> openshell.v1.ProviderProfileCredential - 273, // 172: openshell.v1.ProviderProfile.endpoints:type_name -> openshell.sandbox.v1.NetworkEndpoint - 274, // 173: openshell.v1.ProviderProfile.binaries:type_name -> openshell.sandbox.v1.NetworkBinary - 128, // 174: openshell.v1.ProviderProfile.discovery:type_name -> openshell.v1.ProviderProfileDiscovery - 256, // 175: openshell.v1.ProviderProfile.annotations:type_name -> openshell.v1.ProviderProfile.AnnotationsEntry - 137, // 176: openshell.v1.ProviderProfileResponse.profile:type_name -> openshell.v1.ProviderProfile - 137, // 177: openshell.v1.ListProviderProfilesResponse.profiles:type_name -> openshell.v1.ProviderProfile - 118, // 178: openshell.v1.ImportProviderProfilesRequest.profiles:type_name -> openshell.v1.ProviderProfileImportItem - 119, // 179: openshell.v1.ImportProviderProfilesResponse.diagnostics:type_name -> openshell.v1.ProviderProfileDiagnostic - 137, // 180: openshell.v1.ImportProviderProfilesResponse.profiles:type_name -> openshell.v1.ProviderProfile - 118, // 181: openshell.v1.UpdateProviderProfilesRequest.profile:type_name -> openshell.v1.ProviderProfileImportItem - 119, // 182: openshell.v1.UpdateProviderProfilesResponse.diagnostics:type_name -> openshell.v1.ProviderProfileDiagnostic - 137, // 183: openshell.v1.UpdateProviderProfilesResponse.profile:type_name -> openshell.v1.ProviderProfile - 118, // 184: openshell.v1.LintProviderProfilesRequest.profiles:type_name -> openshell.v1.ProviderProfileImportItem - 119, // 185: openshell.v1.LintProviderProfilesResponse.diagnostics:type_name -> openshell.v1.ProviderProfileDiagnostic - 15, // 186: openshell.v1.DeleteProviderResponse.outcome:type_name -> openshell.v1.DeletionOutcome - 15, // 187: openshell.v1.DeleteProviderProfileResponse.outcome:type_name -> openshell.v1.DeletionOutcome - 150, // 188: openshell.v1.StaticCredentialBinding.endpoints:type_name -> openshell.v1.StaticCredentialEndpointBinding - 257, // 189: openshell.v1.GetSandboxProviderEnvironmentResponse.environment:type_name -> openshell.v1.GetSandboxProviderEnvironmentResponse.EnvironmentEntry - 258, // 190: openshell.v1.GetSandboxProviderEnvironmentResponse.credential_expiration_times:type_name -> openshell.v1.GetSandboxProviderEnvironmentResponse.CredentialExpirationTimesEntry - 259, // 191: openshell.v1.GetSandboxProviderEnvironmentResponse.dynamic_credentials:type_name -> openshell.v1.GetSandboxProviderEnvironmentResponse.DynamicCredentialsEntry - 260, // 192: openshell.v1.GetSandboxProviderEnvironmentResponse.static_credential_bindings:type_name -> openshell.v1.GetSandboxProviderEnvironmentResponse.StaticCredentialBindingsEntry - 3, // 193: openshell.v1.GetSandboxProviderEnvironmentResponse.readiness_reason:type_name -> openshell.v1.ProviderReadinessReason - 269, // 194: openshell.v1.ExchangeProviderSubjectTokenResponse.expires_after:type_name -> google.protobuf.Duration - 267, // 195: openshell.v1.UpdateConfigRequest.policy:type_name -> openshell.sandbox.v1.SandboxPolicy - 275, // 196: openshell.v1.UpdateConfigRequest.setting_value:type_name -> openshell.sandbox.v1.SettingValue - 156, // 197: openshell.v1.UpdateConfigRequest.merge_operations:type_name -> openshell.v1.PolicyMergeOperation - 261, // 198: openshell.v1.UpdateConfigRequest.annotations:type_name -> openshell.v1.UpdateConfigRequest.AnnotationsEntry - 270, // 199: openshell.v1.UpdateConfigRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 157, // 200: openshell.v1.PolicyMergeOperation.add_rule:type_name -> openshell.v1.AddNetworkRule - 158, // 201: openshell.v1.PolicyMergeOperation.remove_endpoint:type_name -> openshell.v1.RemoveNetworkEndpoint - 159, // 202: openshell.v1.PolicyMergeOperation.remove_rule:type_name -> openshell.v1.RemoveNetworkRule - 161, // 203: openshell.v1.PolicyMergeOperation.add_deny_rules:type_name -> openshell.v1.AddDenyRules - 162, // 204: openshell.v1.PolicyMergeOperation.add_allow_rules:type_name -> openshell.v1.AddAllowRules - 163, // 205: openshell.v1.PolicyMergeOperation.remove_binary:type_name -> openshell.v1.RemoveNetworkBinary - 276, // 206: openshell.v1.AddNetworkRule.rule:type_name -> openshell.sandbox.v1.NetworkPolicyRule - 274, // 207: openshell.v1.L7RuleTarget.binaries:type_name -> openshell.sandbox.v1.NetworkBinary - 277, // 208: openshell.v1.AddDenyRules.deny_rules:type_name -> openshell.sandbox.v1.L7DenyRule - 160, // 209: openshell.v1.AddDenyRules.target:type_name -> openshell.v1.L7RuleTarget - 278, // 210: openshell.v1.AddAllowRules.rules:type_name -> openshell.sandbox.v1.L7Rule - 160, // 211: openshell.v1.AddAllowRules.target:type_name -> openshell.v1.L7RuleTarget - 262, // 212: openshell.v1.UpdateConfigResponse.annotations:type_name -> openshell.v1.UpdateConfigResponse.AnnotationsEntry - 270, // 213: openshell.v1.GetSandboxPolicyStatusRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 174, // 214: openshell.v1.GetSandboxPolicyStatusResponse.revision:type_name -> openshell.v1.SandboxPolicyRevision - 270, // 215: openshell.v1.ListSandboxPoliciesRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 174, // 216: openshell.v1.ListSandboxPoliciesResponse.revisions:type_name -> openshell.v1.SandboxPolicyRevision - 11, // 217: openshell.v1.ReportPolicyStatusRequest.status:type_name -> openshell.v1.PolicyStatus - 10, // 218: openshell.v1.SandboxConfigurationAdmission.state:type_name -> openshell.v1.ConfigurationAdmissionState - 171, // 219: openshell.v1.ReportSandboxConfigurationRequest.admission:type_name -> openshell.v1.SandboxConfigurationAdmission - 11, // 220: openshell.v1.SandboxPolicyRevision.status:type_name -> openshell.v1.PolicyStatus - 265, // 221: openshell.v1.SandboxPolicyRevision.created_time:type_name -> google.protobuf.Timestamp - 265, // 222: openshell.v1.SandboxPolicyRevision.loaded_time:type_name -> google.protobuf.Timestamp - 267, // 223: openshell.v1.SandboxPolicyRevision.policy:type_name -> openshell.sandbox.v1.SandboxPolicy - 263, // 224: openshell.v1.SandboxPolicyRevision.provenance:type_name -> openshell.v1.SandboxPolicyRevision.ProvenanceEntry - 265, // 225: openshell.v1.GetSandboxLogsRequest.since_time:type_name -> google.protobuf.Timestamp - 270, // 226: openshell.v1.GetSandboxLogsRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 107, // 227: openshell.v1.PushSandboxLogsRequest.logs:type_name -> openshell.v1.SandboxLogLine - 107, // 228: openshell.v1.GetSandboxLogsResponse.logs:type_name -> openshell.v1.SandboxLogLine - 181, // 229: openshell.v1.SupervisorMessage.hello:type_name -> openshell.v1.SupervisorHello - 184, // 230: openshell.v1.SupervisorMessage.heartbeat:type_name -> openshell.v1.SupervisorHeartbeat - 195, // 231: openshell.v1.SupervisorMessage.relay_open_result:type_name -> openshell.v1.RelayOpenResult - 196, // 232: openshell.v1.SupervisorMessage.relay_close:type_name -> openshell.v1.RelayClose - 182, // 233: openshell.v1.GatewayMessage.session_accepted:type_name -> openshell.v1.SessionAccepted - 183, // 234: openshell.v1.GatewayMessage.session_rejected:type_name -> openshell.v1.SessionRejected - 185, // 235: openshell.v1.GatewayMessage.heartbeat:type_name -> openshell.v1.GatewayHeartbeat - 190, // 236: openshell.v1.GatewayMessage.relay_open:type_name -> openshell.v1.RelayOpen - 196, // 237: openshell.v1.GatewayMessage.relay_close:type_name -> openshell.v1.RelayClose - 269, // 238: openshell.v1.SessionAccepted.heartbeat_interval:type_name -> google.protobuf.Duration - 191, // 239: openshell.v1.RelayOpen.ssh:type_name -> openshell.v1.SshRelayTarget - 192, // 240: openshell.v1.RelayOpen.tcp:type_name -> openshell.v1.TcpRelayTarget - 193, // 241: openshell.v1.RelayFrame.init:type_name -> openshell.v1.RelayInit - 265, // 242: openshell.v1.DenialSummary.first_seen_time:type_name -> google.protobuf.Timestamp - 265, // 243: openshell.v1.DenialSummary.last_seen_time:type_name -> google.protobuf.Timestamp - 197, // 244: openshell.v1.DenialSummary.l7_request_samples:type_name -> openshell.v1.L7RequestSample - 199, // 245: openshell.v1.NetworkActivitySummary.denials_by_group:type_name -> openshell.v1.DenialGroupCount - 276, // 246: openshell.v1.PolicyChunk.proposed_rule:type_name -> openshell.sandbox.v1.NetworkPolicyRule - 265, // 247: openshell.v1.PolicyChunk.created_time:type_name -> google.protobuf.Timestamp - 265, // 248: openshell.v1.PolicyChunk.decided_time:type_name -> google.protobuf.Timestamp - 265, // 249: openshell.v1.PolicyChunk.first_seen_time:type_name -> google.protobuf.Timestamp - 265, // 250: openshell.v1.PolicyChunk.last_seen_time:type_name -> google.protobuf.Timestamp - 267, // 251: openshell.v1.PolicyChunk.current_effective_policy:type_name -> openshell.sandbox.v1.SandboxPolicy - 267, // 252: openshell.v1.PolicyChunk.candidate_effective_policy:type_name -> openshell.sandbox.v1.SandboxPolicy - 198, // 253: openshell.v1.SubmitPolicyAnalysisRequest.summaries:type_name -> openshell.v1.DenialSummary - 201, // 254: openshell.v1.SubmitPolicyAnalysisRequest.proposed_chunks:type_name -> openshell.v1.PolicyChunk - 200, // 255: openshell.v1.SubmitPolicyAnalysisRequest.network_activity_summaries:type_name -> openshell.v1.NetworkActivitySummary - 270, // 256: openshell.v1.GetDraftPolicyRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 201, // 257: openshell.v1.GetDraftPolicyResponse.chunks:type_name -> openshell.v1.PolicyChunk - 265, // 258: openshell.v1.GetDraftPolicyResponse.last_analyzed_time:type_name -> google.protobuf.Timestamp - 270, // 259: openshell.v1.ApproveDraftChunkRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 270, // 260: openshell.v1.RejectDraftChunkRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 211, // 261: openshell.v1.ApproveAllDraftChunksRequest.approvals:type_name -> openshell.v1.DraftChunkApproval - 270, // 262: openshell.v1.ApproveAllDraftChunksRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 276, // 263: openshell.v1.EditDraftChunkRequest.proposed_rule:type_name -> openshell.sandbox.v1.NetworkPolicyRule - 270, // 264: openshell.v1.EditDraftChunkRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 270, // 265: openshell.v1.UndoDraftChunkRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 270, // 266: openshell.v1.ClearDraftChunksRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 270, // 267: openshell.v1.GetDraftHistoryRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 265, // 268: openshell.v1.DraftHistoryEntry.event_time:type_name -> google.protobuf.Timestamp - 221, // 269: openshell.v1.GetDraftHistoryResponse.entries:type_name -> openshell.v1.DraftHistoryEntry - 264, // 270: openshell.v1.CreateWorkspaceRequest.labels:type_name -> openshell.v1.CreateWorkspaceRequest.LabelsEntry - 279, // 271: openshell.v1.CreateWorkspaceResponse.workspace:type_name -> openshell.datamodel.v1.Workspace - 279, // 272: openshell.v1.GetWorkspaceResponse.workspace:type_name -> openshell.datamodel.v1.Workspace - 279, // 273: openshell.v1.ListWorkspacesResponse.workspaces:type_name -> openshell.datamodel.v1.Workspace - 15, // 274: openshell.v1.DeleteWorkspaceResponse.outcome:type_name -> openshell.v1.DeletionOutcome - 266, // 275: openshell.v1.WorkspaceMember.metadata:type_name -> openshell.datamodel.v1.ObjectMeta - 13, // 276: openshell.v1.WorkspaceMember.role:type_name -> openshell.v1.WorkspaceRole - 13, // 277: openshell.v1.AddWorkspaceMemberRequest.role:type_name -> openshell.v1.WorkspaceRole - 231, // 278: openshell.v1.AddWorkspaceMemberResponse.member:type_name -> openshell.v1.WorkspaceMember - 15, // 279: openshell.v1.RemoveWorkspaceMemberResponse.outcome:type_name -> openshell.v1.DeletionOutcome - 231, // 280: openshell.v1.ListWorkspaceMembersResponse.members:type_name -> openshell.v1.WorkspaceMember - 265, // 281: openshell.v1.ExtensionServiceCredential.expiration_time:type_name -> google.protobuf.Timestamp - 16, // 282: openshell.v1.EndpointObservation.result:type_name -> openshell.v1.EndpointResult - 239, // 283: openshell.v1.ReportEndpointStatusRequest.observations:type_name -> openshell.v1.EndpointObservation - 16, // 284: openshell.v1.EndpointStatus.last_result:type_name -> openshell.v1.EndpointResult - 265, // 285: openshell.v1.EndpointStatus.last_reported_time:type_name -> google.protobuf.Timestamp - 265, // 286: openshell.v1.SandboxProvisioning.configuration_change_time:type_name -> google.protobuf.Timestamp - 265, // 287: openshell.v1.SandboxProvisioning.first_rejection_time:type_name -> google.protobuf.Timestamp - 265, // 288: openshell.v1.SandboxProvisioning.deadline:type_name -> google.protobuf.Timestamp - 265, // 289: openshell.v1.SandboxProvisioning.timeout_time:type_name -> google.protobuf.Timestamp - 265, // 290: openshell.v1.SandboxProvisioning.cleanup_completed_time:type_name -> google.protobuf.Timestamp - 265, // 291: openshell.v1.SandboxProvisioning.cleanup_retry_time:type_name -> google.protobuf.Timestamp - 265, // 292: openshell.v1.SandboxProvisioning.attachment_change_time:type_name -> google.protobuf.Timestamp - 265, // 293: openshell.v1.UpdateProviderRequest.CredentialExpirationTimesEntry.value:type_name -> google.protobuf.Timestamp - 265, // 294: openshell.v1.GetSandboxProviderEnvironmentResponse.CredentialExpirationTimesEntry.value:type_name -> google.protobuf.Timestamp - 123, // 295: openshell.v1.GetSandboxProviderEnvironmentResponse.DynamicCredentialsEntry.value:type_name -> openshell.v1.ProviderProfileCredential - 151, // 296: openshell.v1.GetSandboxProviderEnvironmentResponse.StaticCredentialBindingsEntry.value:type_name -> openshell.v1.StaticCredentialBinding - 21, // 297: openshell.v1.OpenShell.Health:input_type -> openshell.v1.HealthRequest - 23, // 298: openshell.v1.OpenShell.GetCurrentUser:input_type -> openshell.v1.GetCurrentUserRequest - 25, // 299: openshell.v1.OpenShell.GetGatewayInfo:input_type -> openshell.v1.GetGatewayInfoRequest - 48, // 300: openshell.v1.OpenShell.CreateSandbox:input_type -> openshell.v1.CreateSandboxRequest - 56, // 301: openshell.v1.OpenShell.BeginRootfsTarStaging:input_type -> openshell.v1.BeginRootfsTarStagingRequest - 58, // 302: openshell.v1.OpenShell.GetSandbox:input_type -> openshell.v1.GetSandboxRequest - 59, // 303: openshell.v1.OpenShell.ListSandboxes:input_type -> openshell.v1.ListSandboxesRequest - 49, // 304: openshell.v1.OpenShell.CreateSandboxTemplate:input_type -> openshell.v1.CreateSandboxTemplateRequest - 50, // 305: openshell.v1.OpenShell.GetSandboxTemplate:input_type -> openshell.v1.GetSandboxTemplateRequest - 51, // 306: openshell.v1.OpenShell.ListSandboxTemplates:input_type -> openshell.v1.ListSandboxTemplatesRequest - 52, // 307: openshell.v1.OpenShell.DeleteSandboxTemplate:input_type -> openshell.v1.DeleteSandboxTemplateRequest - 60, // 308: openshell.v1.OpenShell.ListSandboxProviders:input_type -> openshell.v1.ListSandboxProvidersRequest - 61, // 309: openshell.v1.OpenShell.AttachSandboxProvider:input_type -> openshell.v1.AttachSandboxProviderRequest - 62, // 310: openshell.v1.OpenShell.DetachSandboxProvider:input_type -> openshell.v1.DetachSandboxProviderRequest - 78, // 311: openshell.v1.OpenShell.GetSandboxProviderStatus:input_type -> openshell.v1.GetSandboxProviderStatusRequest - 63, // 312: openshell.v1.OpenShell.DeleteSandbox:input_type -> openshell.v1.DeleteSandboxRequest - 64, // 313: openshell.v1.OpenShell.StopSandbox:input_type -> openshell.v1.StopSandboxRequest - 65, // 314: openshell.v1.OpenShell.StartSandbox:input_type -> openshell.v1.StartSandboxRequest - 83, // 315: openshell.v1.OpenShell.CreateSshSession:input_type -> openshell.v1.CreateSshSessionRequest - 85, // 316: openshell.v1.OpenShell.ExposeService:input_type -> openshell.v1.ExposeServiceRequest - 86, // 317: openshell.v1.OpenShell.GetService:input_type -> openshell.v1.GetServiceRequest - 87, // 318: openshell.v1.OpenShell.ListServices:input_type -> openshell.v1.ListServicesRequest - 89, // 319: openshell.v1.OpenShell.DeleteService:input_type -> openshell.v1.DeleteServiceRequest - 93, // 320: openshell.v1.OpenShell.RevokeSshSession:input_type -> openshell.v1.RevokeSshSessionRequest - 95, // 321: openshell.v1.OpenShell.ExecSandbox:input_type -> openshell.v1.ExecSandboxRequest - 101, // 322: openshell.v1.OpenShell.ForwardTcp:input_type -> openshell.v1.TcpForwardFrame - 102, // 323: openshell.v1.OpenShell.ExecSandboxInteractive:input_type -> openshell.v1.ExecSandboxInput - 109, // 324: openshell.v1.OpenShell.CreateProvider:input_type -> openshell.v1.CreateProviderRequest - 110, // 325: openshell.v1.OpenShell.GetProvider:input_type -> openshell.v1.GetProviderRequest - 111, // 326: openshell.v1.OpenShell.ListProviders:input_type -> openshell.v1.ListProvidersRequest - 116, // 327: openshell.v1.OpenShell.ListProviderProfiles:input_type -> openshell.v1.ListProviderProfilesRequest - 117, // 328: openshell.v1.OpenShell.GetProviderProfile:input_type -> openshell.v1.GetProviderProfileRequest - 140, // 329: openshell.v1.OpenShell.ImportProviderProfiles:input_type -> openshell.v1.ImportProviderProfilesRequest - 142, // 330: openshell.v1.OpenShell.UpdateProviderProfiles:input_type -> openshell.v1.UpdateProviderProfilesRequest - 144, // 331: openshell.v1.OpenShell.LintProviderProfiles:input_type -> openshell.v1.LintProviderProfilesRequest - 112, // 332: openshell.v1.OpenShell.UpdateProvider:input_type -> openshell.v1.UpdateProviderRequest - 129, // 333: openshell.v1.OpenShell.GetProviderRefreshStatus:input_type -> openshell.v1.GetProviderRefreshStatusRequest - 131, // 334: openshell.v1.OpenShell.ConfigureProviderRefresh:input_type -> openshell.v1.ConfigureProviderRefreshRequest - 133, // 335: openshell.v1.OpenShell.RotateProviderCredential:input_type -> openshell.v1.RotateProviderCredentialRequest - 135, // 336: openshell.v1.OpenShell.DeleteProviderRefresh:input_type -> openshell.v1.DeleteProviderRefreshRequest - 113, // 337: openshell.v1.OpenShell.DeleteProvider:input_type -> openshell.v1.DeleteProviderRequest - 147, // 338: openshell.v1.OpenShell.DeleteProviderProfile:input_type -> openshell.v1.DeleteProviderProfileRequest - 280, // 339: openshell.v1.OpenShell.GetSandboxConfig:input_type -> openshell.sandbox.v1.GetSandboxConfigRequest - 281, // 340: openshell.v1.OpenShell.GetGatewayConfig:input_type -> openshell.sandbox.v1.GetGatewayConfigRequest - 155, // 341: openshell.v1.OpenShell.UpdateConfig:input_type -> openshell.v1.UpdateConfigRequest - 165, // 342: openshell.v1.OpenShell.GetSandboxPolicyStatus:input_type -> openshell.v1.GetSandboxPolicyStatusRequest - 167, // 343: openshell.v1.OpenShell.ListSandboxPolicies:input_type -> openshell.v1.ListSandboxPoliciesRequest - 169, // 344: openshell.v1.OpenShell.ReportPolicyStatus:input_type -> openshell.v1.ReportPolicyStatusRequest - 240, // 345: openshell.v1.OpenShell.ReportEndpointStatus:input_type -> openshell.v1.ReportEndpointStatusRequest - 80, // 346: openshell.v1.OpenShell.ReportProviderReadiness:input_type -> openshell.v1.ReportProviderReadinessRequest - 172, // 347: openshell.v1.OpenShell.ReportSandboxConfiguration:input_type -> openshell.v1.ReportSandboxConfigurationRequest - 149, // 348: openshell.v1.OpenShell.GetSandboxProviderEnvironment:input_type -> openshell.v1.GetSandboxProviderEnvironmentRequest - 153, // 349: openshell.v1.OpenShell.ExchangeProviderSubjectToken:input_type -> openshell.v1.ExchangeProviderSubjectTokenRequest - 175, // 350: openshell.v1.OpenShell.GetSandboxLogs:input_type -> openshell.v1.GetSandboxLogsRequest - 176, // 351: openshell.v1.OpenShell.PushSandboxLogs:input_type -> openshell.v1.PushSandboxLogsRequest - 179, // 352: openshell.v1.OpenShell.ConnectSupervisor:input_type -> openshell.v1.SupervisorMessage - 186, // 353: openshell.v1.OpenShell.ReportMainProcessExit:input_type -> openshell.v1.ReportMainProcessExitRequest - 188, // 354: openshell.v1.OpenShell.FinalizeMainProcessExit:input_type -> openshell.v1.FinalizeMainProcessExitRequest - 194, // 355: openshell.v1.OpenShell.RelayStream:input_type -> openshell.v1.RelayFrame - 105, // 356: openshell.v1.OpenShell.WatchSandbox:input_type -> openshell.v1.WatchSandboxRequest - 203, // 357: openshell.v1.OpenShell.SubmitPolicyAnalysis:input_type -> openshell.v1.SubmitPolicyAnalysisRequest - 205, // 358: openshell.v1.OpenShell.GetDraftPolicy:input_type -> openshell.v1.GetDraftPolicyRequest - 207, // 359: openshell.v1.OpenShell.ApproveDraftChunk:input_type -> openshell.v1.ApproveDraftChunkRequest - 209, // 360: openshell.v1.OpenShell.RejectDraftChunk:input_type -> openshell.v1.RejectDraftChunkRequest - 212, // 361: openshell.v1.OpenShell.ApproveAllDraftChunks:input_type -> openshell.v1.ApproveAllDraftChunksRequest - 214, // 362: openshell.v1.OpenShell.EditDraftChunk:input_type -> openshell.v1.EditDraftChunkRequest - 216, // 363: openshell.v1.OpenShell.UndoDraftChunk:input_type -> openshell.v1.UndoDraftChunkRequest - 218, // 364: openshell.v1.OpenShell.ClearDraftChunks:input_type -> openshell.v1.ClearDraftChunksRequest - 220, // 365: openshell.v1.OpenShell.GetDraftHistory:input_type -> openshell.v1.GetDraftHistoryRequest - 17, // 366: openshell.v1.OpenShell.IssueSandboxToken:input_type -> openshell.v1.IssueSandboxTokenRequest - 19, // 367: openshell.v1.OpenShell.RefreshSandboxToken:input_type -> openshell.v1.RefreshSandboxTokenRequest - 223, // 368: openshell.v1.OpenShell.CreateWorkspace:input_type -> openshell.v1.CreateWorkspaceRequest - 225, // 369: openshell.v1.OpenShell.GetWorkspace:input_type -> openshell.v1.GetWorkspaceRequest - 227, // 370: openshell.v1.OpenShell.ListWorkspaces:input_type -> openshell.v1.ListWorkspacesRequest - 229, // 371: openshell.v1.OpenShell.DeleteWorkspace:input_type -> openshell.v1.DeleteWorkspaceRequest - 232, // 372: openshell.v1.OpenShell.AddWorkspaceMember:input_type -> openshell.v1.AddWorkspaceMemberRequest - 234, // 373: openshell.v1.OpenShell.RemoveWorkspaceMember:input_type -> openshell.v1.RemoveWorkspaceMemberRequest - 236, // 374: openshell.v1.OpenShell.ListWorkspaceMembers:input_type -> openshell.v1.ListWorkspaceMembersRequest - 22, // 375: openshell.v1.OpenShell.Health:output_type -> openshell.v1.HealthResponse - 24, // 376: openshell.v1.OpenShell.GetCurrentUser:output_type -> openshell.v1.GetCurrentUserResponse - 26, // 377: openshell.v1.OpenShell.GetGatewayInfo:output_type -> openshell.v1.GetGatewayInfoResponse - 66, // 378: openshell.v1.OpenShell.CreateSandbox:output_type -> openshell.v1.SandboxResponse - 57, // 379: openshell.v1.OpenShell.BeginRootfsTarStaging:output_type -> openshell.v1.BeginRootfsTarStagingResponse - 66, // 380: openshell.v1.OpenShell.GetSandbox:output_type -> openshell.v1.SandboxResponse - 67, // 381: openshell.v1.OpenShell.ListSandboxes:output_type -> openshell.v1.ListSandboxesResponse - 53, // 382: openshell.v1.OpenShell.CreateSandboxTemplate:output_type -> openshell.v1.SandboxTemplateResponse - 53, // 383: openshell.v1.OpenShell.GetSandboxTemplate:output_type -> openshell.v1.SandboxTemplateResponse - 54, // 384: openshell.v1.OpenShell.ListSandboxTemplates:output_type -> openshell.v1.ListSandboxTemplatesResponse - 55, // 385: openshell.v1.OpenShell.DeleteSandboxTemplate:output_type -> openshell.v1.DeleteSandboxTemplateResponse - 68, // 386: openshell.v1.OpenShell.ListSandboxProviders:output_type -> openshell.v1.ListSandboxProvidersResponse - 69, // 387: openshell.v1.OpenShell.AttachSandboxProvider:output_type -> openshell.v1.AttachSandboxProviderResponse - 70, // 388: openshell.v1.OpenShell.DetachSandboxProvider:output_type -> openshell.v1.DetachSandboxProviderResponse - 79, // 389: openshell.v1.OpenShell.GetSandboxProviderStatus:output_type -> openshell.v1.GetSandboxProviderStatusResponse - 82, // 390: openshell.v1.OpenShell.DeleteSandbox:output_type -> openshell.v1.DeleteSandboxResponse - 66, // 391: openshell.v1.OpenShell.StopSandbox:output_type -> openshell.v1.SandboxResponse - 66, // 392: openshell.v1.OpenShell.StartSandbox:output_type -> openshell.v1.SandboxResponse - 84, // 393: openshell.v1.OpenShell.CreateSshSession:output_type -> openshell.v1.CreateSshSessionResponse - 92, // 394: openshell.v1.OpenShell.ExposeService:output_type -> openshell.v1.ServiceEndpointResponse - 92, // 395: openshell.v1.OpenShell.GetService:output_type -> openshell.v1.ServiceEndpointResponse - 88, // 396: openshell.v1.OpenShell.ListServices:output_type -> openshell.v1.ListServicesResponse - 90, // 397: openshell.v1.OpenShell.DeleteService:output_type -> openshell.v1.DeleteServiceResponse - 94, // 398: openshell.v1.OpenShell.RevokeSshSession:output_type -> openshell.v1.RevokeSshSessionResponse - 99, // 399: openshell.v1.OpenShell.ExecSandbox:output_type -> openshell.v1.ExecSandboxEvent - 101, // 400: openshell.v1.OpenShell.ForwardTcp:output_type -> openshell.v1.TcpForwardFrame - 99, // 401: openshell.v1.OpenShell.ExecSandboxInteractive:output_type -> openshell.v1.ExecSandboxEvent - 114, // 402: openshell.v1.OpenShell.CreateProvider:output_type -> openshell.v1.ProviderResponse - 114, // 403: openshell.v1.OpenShell.GetProvider:output_type -> openshell.v1.ProviderResponse - 115, // 404: openshell.v1.OpenShell.ListProviders:output_type -> openshell.v1.ListProvidersResponse - 139, // 405: openshell.v1.OpenShell.ListProviderProfiles:output_type -> openshell.v1.ListProviderProfilesResponse - 138, // 406: openshell.v1.OpenShell.GetProviderProfile:output_type -> openshell.v1.ProviderProfileResponse - 141, // 407: openshell.v1.OpenShell.ImportProviderProfiles:output_type -> openshell.v1.ImportProviderProfilesResponse - 143, // 408: openshell.v1.OpenShell.UpdateProviderProfiles:output_type -> openshell.v1.UpdateProviderProfilesResponse - 145, // 409: openshell.v1.OpenShell.LintProviderProfiles:output_type -> openshell.v1.LintProviderProfilesResponse - 114, // 410: openshell.v1.OpenShell.UpdateProvider:output_type -> openshell.v1.ProviderResponse - 130, // 411: openshell.v1.OpenShell.GetProviderRefreshStatus:output_type -> openshell.v1.GetProviderRefreshStatusResponse - 132, // 412: openshell.v1.OpenShell.ConfigureProviderRefresh:output_type -> openshell.v1.ConfigureProviderRefreshResponse - 134, // 413: openshell.v1.OpenShell.RotateProviderCredential:output_type -> openshell.v1.RotateProviderCredentialResponse - 136, // 414: openshell.v1.OpenShell.DeleteProviderRefresh:output_type -> openshell.v1.DeleteProviderRefreshResponse - 146, // 415: openshell.v1.OpenShell.DeleteProvider:output_type -> openshell.v1.DeleteProviderResponse - 148, // 416: openshell.v1.OpenShell.DeleteProviderProfile:output_type -> openshell.v1.DeleteProviderProfileResponse - 282, // 417: openshell.v1.OpenShell.GetSandboxConfig:output_type -> openshell.sandbox.v1.GetSandboxConfigResponse - 283, // 418: openshell.v1.OpenShell.GetGatewayConfig:output_type -> openshell.sandbox.v1.GetGatewayConfigResponse - 164, // 419: openshell.v1.OpenShell.UpdateConfig:output_type -> openshell.v1.UpdateConfigResponse - 166, // 420: openshell.v1.OpenShell.GetSandboxPolicyStatus:output_type -> openshell.v1.GetSandboxPolicyStatusResponse - 168, // 421: openshell.v1.OpenShell.ListSandboxPolicies:output_type -> openshell.v1.ListSandboxPoliciesResponse - 170, // 422: openshell.v1.OpenShell.ReportPolicyStatus:output_type -> openshell.v1.ReportPolicyStatusResponse - 241, // 423: openshell.v1.OpenShell.ReportEndpointStatus:output_type -> openshell.v1.ReportEndpointStatusResponse - 81, // 424: openshell.v1.OpenShell.ReportProviderReadiness:output_type -> openshell.v1.ReportProviderReadinessResponse - 173, // 425: openshell.v1.OpenShell.ReportSandboxConfiguration:output_type -> openshell.v1.ReportSandboxConfigurationResponse - 152, // 426: openshell.v1.OpenShell.GetSandboxProviderEnvironment:output_type -> openshell.v1.GetSandboxProviderEnvironmentResponse - 154, // 427: openshell.v1.OpenShell.ExchangeProviderSubjectToken:output_type -> openshell.v1.ExchangeProviderSubjectTokenResponse - 178, // 428: openshell.v1.OpenShell.GetSandboxLogs:output_type -> openshell.v1.GetSandboxLogsResponse - 177, // 429: openshell.v1.OpenShell.PushSandboxLogs:output_type -> openshell.v1.PushSandboxLogsResponse - 180, // 430: openshell.v1.OpenShell.ConnectSupervisor:output_type -> openshell.v1.GatewayMessage - 187, // 431: openshell.v1.OpenShell.ReportMainProcessExit:output_type -> openshell.v1.ReportMainProcessExitResponse - 189, // 432: openshell.v1.OpenShell.FinalizeMainProcessExit:output_type -> openshell.v1.FinalizeMainProcessExitResponse - 194, // 433: openshell.v1.OpenShell.RelayStream:output_type -> openshell.v1.RelayFrame - 106, // 434: openshell.v1.OpenShell.WatchSandbox:output_type -> openshell.v1.SandboxStreamEvent - 204, // 435: openshell.v1.OpenShell.SubmitPolicyAnalysis:output_type -> openshell.v1.SubmitPolicyAnalysisResponse - 206, // 436: openshell.v1.OpenShell.GetDraftPolicy:output_type -> openshell.v1.GetDraftPolicyResponse - 208, // 437: openshell.v1.OpenShell.ApproveDraftChunk:output_type -> openshell.v1.ApproveDraftChunkResponse - 210, // 438: openshell.v1.OpenShell.RejectDraftChunk:output_type -> openshell.v1.RejectDraftChunkResponse - 213, // 439: openshell.v1.OpenShell.ApproveAllDraftChunks:output_type -> openshell.v1.ApproveAllDraftChunksResponse - 215, // 440: openshell.v1.OpenShell.EditDraftChunk:output_type -> openshell.v1.EditDraftChunkResponse - 217, // 441: openshell.v1.OpenShell.UndoDraftChunk:output_type -> openshell.v1.UndoDraftChunkResponse - 219, // 442: openshell.v1.OpenShell.ClearDraftChunks:output_type -> openshell.v1.ClearDraftChunksResponse - 222, // 443: openshell.v1.OpenShell.GetDraftHistory:output_type -> openshell.v1.GetDraftHistoryResponse - 18, // 444: openshell.v1.OpenShell.IssueSandboxToken:output_type -> openshell.v1.IssueSandboxTokenResponse - 20, // 445: openshell.v1.OpenShell.RefreshSandboxToken:output_type -> openshell.v1.RefreshSandboxTokenResponse - 224, // 446: openshell.v1.OpenShell.CreateWorkspace:output_type -> openshell.v1.CreateWorkspaceResponse - 226, // 447: openshell.v1.OpenShell.GetWorkspace:output_type -> openshell.v1.GetWorkspaceResponse - 228, // 448: openshell.v1.OpenShell.ListWorkspaces:output_type -> openshell.v1.ListWorkspacesResponse - 230, // 449: openshell.v1.OpenShell.DeleteWorkspace:output_type -> openshell.v1.DeleteWorkspaceResponse - 233, // 450: openshell.v1.OpenShell.AddWorkspaceMember:output_type -> openshell.v1.AddWorkspaceMemberResponse - 235, // 451: openshell.v1.OpenShell.RemoveWorkspaceMember:output_type -> openshell.v1.RemoveWorkspaceMemberResponse - 237, // 452: openshell.v1.OpenShell.ListWorkspaceMembers:output_type -> openshell.v1.ListWorkspaceMembersResponse - 375, // [375:453] is the sub-list for method output_type - 297, // [297:375] is the sub-list for method input_type - 297, // [297:297] is the sub-list for extension type_name - 297, // [297:297] is the sub-list for extension extendee - 0, // [0:297] is the sub-list for field type_name + 37, // 21: openshell.v1.ResourceRequirements.cpu:type_name -> openshell.v1.CpuResourceRequirements + 38, // 22: openshell.v1.ResourceRequirements.memory:type_name -> openshell.v1.MemoryResourceRequirements + 247, // 23: openshell.v1.SandboxTemplate.labels:type_name -> openshell.v1.SandboxTemplate.LabelsEntry + 248, // 24: openshell.v1.SandboxTemplate.annotations:type_name -> openshell.v1.SandboxTemplate.AnnotationsEntry + 249, // 25: openshell.v1.SandboxTemplate.environment:type_name -> openshell.v1.SandboxTemplate.EnvironmentEntry + 270, // 26: openshell.v1.SandboxTemplate.resources:type_name -> google.protobuf.Struct + 270, // 27: openshell.v1.SandboxTemplate.driver_config:type_name -> google.protobuf.Struct + 268, // 28: openshell.v1.SandboxWorkloadTemplate.metadata:type_name -> openshell.datamodel.v1.ObjectMeta + 41, // 29: openshell.v1.SandboxWorkloadTemplate.spec:type_name -> openshell.v1.SandboxWorkloadTemplateSpec + 42, // 30: openshell.v1.SandboxWorkloadTemplateSpec.workload:type_name -> openshell.v1.SandboxWorkloadConfig + 270, // 31: openshell.v1.SandboxWorkloadTemplateSpec.driver_config:type_name -> google.protobuf.Struct + 44, // 32: openshell.v1.SandboxWorkloadTemplateSpec.desired_service_level:type_name -> openshell.v1.SandboxServiceLevel + 250, // 33: openshell.v1.SandboxWorkloadConfig.environment:type_name -> openshell.v1.SandboxWorkloadConfig.EnvironmentEntry + 43, // 34: openshell.v1.SandboxWorkloadConfig.legacy_resources:type_name -> openshell.v1.LegacySandboxResources + 35, // 35: openshell.v1.SandboxWorkloadConfig.resources:type_name -> openshell.v1.ResourceRequirements + 36, // 36: openshell.v1.LegacySandboxResources.gpu:type_name -> openshell.v1.GpuResourceRequirements + 45, // 37: openshell.v1.SandboxServiceLevel.startup:type_name -> openshell.v1.SandboxStartup + 271, // 38: openshell.v1.SandboxStartup.ready_within:type_name -> google.protobuf.Duration + 48, // 39: openshell.v1.SandboxStatus.conditions:type_name -> openshell.v1.SandboxCondition + 0, // 40: openshell.v1.SandboxStatus.phase:type_name -> openshell.v1.SandboxPhase + 244, // 41: openshell.v1.SandboxStatus.endpoint_statuses:type_name -> openshell.v1.EndpointStatus + 173, // 42: openshell.v1.SandboxStatus.configuration_admission:type_name -> openshell.v1.SandboxConfigurationAdmission + 245, // 43: openshell.v1.SandboxStatus.provisioning:type_name -> openshell.v1.SandboxProvisioning + 267, // 44: openshell.v1.SandboxCondition.transition_time:type_name -> google.protobuf.Timestamp + 267, // 45: openshell.v1.PlatformEvent.event_time:type_name -> google.protobuf.Timestamp + 251, // 46: openshell.v1.PlatformEvent.metadata:type_name -> openshell.v1.PlatformEvent.MetadataEntry + 34, // 47: openshell.v1.CreateSandboxRequest.spec:type_name -> openshell.v1.SandboxSpec + 252, // 48: openshell.v1.CreateSandboxRequest.labels:type_name -> openshell.v1.CreateSandboxRequest.LabelsEntry + 253, // 49: openshell.v1.CreateSandboxRequest.annotations:type_name -> openshell.v1.CreateSandboxRequest.AnnotationsEntry + 272, // 50: openshell.v1.CreateSandboxRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 40, // 51: openshell.v1.CreateSandboxTemplateRequest.template:type_name -> openshell.v1.SandboxWorkloadTemplate + 272, // 52: openshell.v1.CreateSandboxTemplateRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 272, // 53: openshell.v1.GetSandboxTemplateRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 272, // 54: openshell.v1.ListSandboxTemplatesRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 272, // 55: openshell.v1.DeleteSandboxTemplateRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 40, // 56: openshell.v1.SandboxTemplateResponse.template:type_name -> openshell.v1.SandboxWorkloadTemplate + 40, // 57: openshell.v1.ListSandboxTemplatesResponse.templates:type_name -> openshell.v1.SandboxWorkloadTemplate + 15, // 58: openshell.v1.DeleteSandboxTemplateResponse.outcome:type_name -> openshell.v1.DeletionOutcome + 272, // 59: openshell.v1.BeginRootfsTarStagingRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 267, // 60: openshell.v1.BeginRootfsTarStagingResponse.expiration_time:type_name -> google.protobuf.Timestamp + 272, // 61: openshell.v1.GetSandboxRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 272, // 62: openshell.v1.ListSandboxesRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 272, // 63: openshell.v1.ListSandboxProvidersRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 272, // 64: openshell.v1.AttachSandboxProviderRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 272, // 65: openshell.v1.DetachSandboxProviderRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 272, // 66: openshell.v1.DeleteSandboxRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 272, // 67: openshell.v1.StopSandboxRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 272, // 68: openshell.v1.StartSandboxRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 33, // 69: openshell.v1.SandboxResponse.sandbox:type_name -> openshell.v1.Sandbox + 33, // 70: openshell.v1.ListSandboxesResponse.sandboxes:type_name -> openshell.v1.Sandbox + 273, // 71: openshell.v1.ListSandboxProvidersResponse.providers:type_name -> openshell.datamodel.v1.Provider + 33, // 72: openshell.v1.AttachSandboxProviderResponse.sandbox:type_name -> openshell.v1.Sandbox + 77, // 73: openshell.v1.AttachSandboxProviderResponse.receipt:type_name -> openshell.v1.ProviderMutationReceipt + 33, // 74: openshell.v1.DetachSandboxProviderResponse.sandbox:type_name -> openshell.v1.Sandbox + 77, // 75: openshell.v1.DetachSandboxProviderResponse.receipt:type_name -> openshell.v1.ProviderMutationReceipt + 75, // 76: openshell.v1.ConfigSnapshotRevision.sandbox_config:type_name -> openshell.v1.SandboxConfigRevision + 73, // 77: openshell.v1.ConfigSnapshotRevision.provider_target:type_name -> openshell.v1.ProviderDesiredIdentity + 274, // 78: openshell.v1.SandboxConfigRevision.policy_source:type_name -> openshell.sandbox.v1.PolicySource + 4, // 79: openshell.v1.ConfigUpdateOperation.component:type_name -> openshell.v1.ConfigComponent + 74, // 80: openshell.v1.ConfigUpdateOperation.target_revision:type_name -> openshell.v1.ConfigSnapshotRevision + 6, // 81: openshell.v1.ConfigUpdateOperation.state:type_name -> openshell.v1.ConfigUpdateOperationState + 5, // 82: openshell.v1.ConfigUpdateOperation.outcome:type_name -> openshell.v1.ConfigApplyOutcome + 267, // 83: openshell.v1.ConfigUpdateOperation.created_time:type_name -> google.protobuf.Timestamp + 267, // 84: openshell.v1.ConfigUpdateOperation.updated_time:type_name -> google.protobuf.Timestamp + 267, // 85: openshell.v1.ConfigUpdateOperation.completed_time:type_name -> google.protobuf.Timestamp + 1, // 86: openshell.v1.ProviderMutationReceipt.kind:type_name -> openshell.v1.ProviderMutationKind + 73, // 87: openshell.v1.ProviderMutationReceipt.desired:type_name -> openshell.v1.ProviderDesiredIdentity + 267, // 88: openshell.v1.ProviderMutationReceipt.persisted_time:type_name -> google.protobuf.Timestamp + 3, // 89: openshell.v1.ProviderReadinessObservation.reason:type_name -> openshell.v1.ProviderReadinessReason + 77, // 90: openshell.v1.ProviderReadinessStatus.receipt:type_name -> openshell.v1.ProviderMutationReceipt + 2, // 91: openshell.v1.ProviderReadinessStatus.state:type_name -> openshell.v1.ProviderReadinessState + 3, // 92: openshell.v1.ProviderReadinessStatus.reason:type_name -> openshell.v1.ProviderReadinessReason + 78, // 93: openshell.v1.ProviderReadinessStatus.observed:type_name -> openshell.v1.ProviderReadinessObservation + 267, // 94: openshell.v1.ProviderReadinessStatus.observed_time:type_name -> google.protobuf.Timestamp + 267, // 95: openshell.v1.ProviderReadinessStatus.evaluated_time:type_name -> google.protobuf.Timestamp + 76, // 96: openshell.v1.ProviderReadinessStatus.operation:type_name -> openshell.v1.ConfigUpdateOperation + 272, // 97: openshell.v1.GetSandboxProviderStatusRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 79, // 98: openshell.v1.GetSandboxProviderStatusResponse.status:type_name -> openshell.v1.ProviderReadinessStatus + 78, // 99: openshell.v1.ReportProviderReadinessRequest.observation:type_name -> openshell.v1.ProviderReadinessObservation + 271, // 100: openshell.v1.ReportProviderReadinessResponse.report_interval:type_name -> google.protobuf.Duration + 271, // 101: openshell.v1.ReportProviderReadinessResponse.observation_ttl:type_name -> google.protobuf.Duration + 15, // 102: openshell.v1.DeleteSandboxResponse.outcome:type_name -> openshell.v1.DeletionOutcome + 267, // 103: openshell.v1.CreateSshSessionResponse.expiration_time:type_name -> google.protobuf.Timestamp + 272, // 104: openshell.v1.ExposeServiceRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 272, // 105: openshell.v1.GetServiceRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 272, // 106: openshell.v1.ListServicesRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 94, // 107: openshell.v1.ListServicesResponse.services:type_name -> openshell.v1.ServiceEndpointResponse + 272, // 108: openshell.v1.DeleteServiceRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 15, // 109: openshell.v1.DeleteServiceResponse.outcome:type_name -> openshell.v1.DeletionOutcome + 268, // 110: openshell.v1.ServiceEndpoint.metadata:type_name -> openshell.datamodel.v1.ObjectMeta + 93, // 111: openshell.v1.ServiceEndpointResponse.endpoint:type_name -> openshell.v1.ServiceEndpoint + 15, // 112: openshell.v1.RevokeSshSessionResponse.outcome:type_name -> openshell.v1.DeletionOutcome + 254, // 113: openshell.v1.ExecSandboxRequest.environment:type_name -> openshell.v1.ExecSandboxRequest.EnvironmentEntry + 271, // 114: openshell.v1.ExecSandboxRequest.execution_timeout:type_name -> google.protobuf.Duration + 98, // 115: openshell.v1.ExecSandboxEvent.stdout:type_name -> openshell.v1.ExecSandboxStdout + 99, // 116: openshell.v1.ExecSandboxEvent.stderr:type_name -> openshell.v1.ExecSandboxStderr + 100, // 117: openshell.v1.ExecSandboxEvent.exit:type_name -> openshell.v1.ExecSandboxExit + 193, // 118: openshell.v1.TcpForwardInit.ssh:type_name -> openshell.v1.SshRelayTarget + 194, // 119: openshell.v1.TcpForwardInit.tcp:type_name -> openshell.v1.TcpRelayTarget + 102, // 120: openshell.v1.TcpForwardFrame.init:type_name -> openshell.v1.TcpForwardInit + 97, // 121: openshell.v1.ExecSandboxInput.start:type_name -> openshell.v1.ExecSandboxRequest + 105, // 122: openshell.v1.ExecSandboxInput.resize:type_name -> openshell.v1.ExecSandboxWindowResize + 268, // 123: openshell.v1.SshSession.metadata:type_name -> openshell.datamodel.v1.ObjectMeta + 267, // 124: openshell.v1.SshSession.expiration_time:type_name -> google.protobuf.Timestamp + 267, // 125: openshell.v1.WatchSandboxRequest.since_time:type_name -> google.protobuf.Timestamp + 33, // 126: openshell.v1.SandboxStreamEvent.sandbox:type_name -> openshell.v1.Sandbox + 109, // 127: openshell.v1.SandboxStreamEvent.log:type_name -> openshell.v1.SandboxLogLine + 49, // 128: openshell.v1.SandboxStreamEvent.event:type_name -> openshell.v1.PlatformEvent + 110, // 129: openshell.v1.SandboxStreamEvent.warning:type_name -> openshell.v1.SandboxStreamWarning + 204, // 130: openshell.v1.SandboxStreamEvent.draft_policy_update:type_name -> openshell.v1.DraftPolicyUpdate + 267, // 131: openshell.v1.SandboxLogLine.event_time:type_name -> google.protobuf.Timestamp + 255, // 132: openshell.v1.SandboxLogLine.fields:type_name -> openshell.v1.SandboxLogLine.FieldsEntry + 273, // 133: openshell.v1.CreateProviderRequest.provider:type_name -> openshell.datamodel.v1.Provider + 272, // 134: openshell.v1.CreateProviderRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 272, // 135: openshell.v1.GetProviderRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 272, // 136: openshell.v1.ListProvidersRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 273, // 137: openshell.v1.UpdateProviderRequest.provider:type_name -> openshell.datamodel.v1.Provider + 256, // 138: openshell.v1.UpdateProviderRequest.credential_expiration_times:type_name -> openshell.v1.UpdateProviderRequest.CredentialExpirationTimesEntry + 272, // 139: openshell.v1.UpdateProviderRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 272, // 140: openshell.v1.DeleteProviderRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 273, // 141: openshell.v1.ProviderResponse.provider:type_name -> openshell.datamodel.v1.Provider + 77, // 142: openshell.v1.ProviderResponse.target_receipts:type_name -> openshell.v1.ProviderMutationReceipt + 273, // 143: openshell.v1.ListProvidersResponse.providers:type_name -> openshell.datamodel.v1.Provider + 139, // 144: openshell.v1.ProviderProfileImportItem.profile:type_name -> openshell.v1.ProviderProfile + 271, // 145: openshell.v1.ProviderCredentialTokenGrant.cache_ttl:type_name -> google.protobuf.Duration + 122, // 146: openshell.v1.ProviderCredentialTokenGrant.audience_overrides:type_name -> openshell.v1.ProviderCredentialTokenGrantAudienceOverride + 7, // 147: openshell.v1.ProviderCredentialTokenGrant.grant_type:type_name -> openshell.v1.ProviderCredentialTokenGrantType + 123, // 148: openshell.v1.ProviderCredentialTokenGrant.subject_token:type_name -> openshell.v1.ProviderCredentialTokenGrantSubjectToken + 128, // 149: openshell.v1.ProviderProfileCredential.refresh:type_name -> openshell.v1.ProviderCredentialRefresh + 124, // 150: openshell.v1.ProviderProfileCredential.token_grant:type_name -> openshell.v1.ProviderCredentialTokenGrant + 8, // 151: openshell.v1.ProviderCredentialRefresh.strategy:type_name -> openshell.v1.ProviderCredentialRefreshStrategy + 271, // 152: openshell.v1.ProviderCredentialRefresh.refresh_before:type_name -> google.protobuf.Duration + 271, // 153: openshell.v1.ProviderCredentialRefresh.max_lifetime:type_name -> google.protobuf.Duration + 126, // 154: openshell.v1.ProviderCredentialRefresh.material:type_name -> openshell.v1.ProviderCredentialRefreshMaterial + 127, // 155: openshell.v1.ProviderCredentialRefresh.additional_outputs:type_name -> openshell.v1.ProviderCredentialRefreshOutput + 8, // 156: openshell.v1.ProviderCredentialRefreshStatus.strategy:type_name -> openshell.v1.ProviderCredentialRefreshStrategy + 267, // 157: openshell.v1.ProviderCredentialRefreshStatus.expiration_time:type_name -> google.protobuf.Timestamp + 267, // 158: openshell.v1.ProviderCredentialRefreshStatus.next_refresh_time:type_name -> google.protobuf.Timestamp + 267, // 159: openshell.v1.ProviderCredentialRefreshStatus.last_refresh_time:type_name -> google.protobuf.Timestamp + 14, // 160: openshell.v1.ProviderCredentialRefreshStatus.recovery_action:type_name -> openshell.v1.ProviderCredentialRefreshRecoveryAction + 267, // 161: openshell.v1.ProviderCredentialRefreshStatus.last_error_time:type_name -> google.protobuf.Timestamp + 272, // 162: openshell.v1.GetProviderRefreshStatusRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 129, // 163: openshell.v1.GetProviderRefreshStatusResponse.credentials:type_name -> openshell.v1.ProviderCredentialRefreshStatus + 8, // 164: openshell.v1.ConfigureProviderRefreshRequest.strategy:type_name -> openshell.v1.ProviderCredentialRefreshStrategy + 257, // 165: openshell.v1.ConfigureProviderRefreshRequest.material:type_name -> openshell.v1.ConfigureProviderRefreshRequest.MaterialEntry + 267, // 166: openshell.v1.ConfigureProviderRefreshRequest.expiration_time:type_name -> google.protobuf.Timestamp + 272, // 167: openshell.v1.ConfigureProviderRefreshRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 129, // 168: openshell.v1.ConfigureProviderRefreshResponse.status:type_name -> openshell.v1.ProviderCredentialRefreshStatus + 272, // 169: openshell.v1.RotateProviderCredentialRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 129, // 170: openshell.v1.RotateProviderCredentialResponse.status:type_name -> openshell.v1.ProviderCredentialRefreshStatus + 272, // 171: openshell.v1.DeleteProviderRefreshRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 15, // 172: openshell.v1.DeleteProviderRefreshResponse.outcome:type_name -> openshell.v1.DeletionOutcome + 9, // 173: openshell.v1.ProviderProfile.category:type_name -> openshell.v1.ProviderProfileCategory + 125, // 174: openshell.v1.ProviderProfile.credentials:type_name -> openshell.v1.ProviderProfileCredential + 275, // 175: openshell.v1.ProviderProfile.endpoints:type_name -> openshell.sandbox.v1.NetworkEndpoint + 276, // 176: openshell.v1.ProviderProfile.binaries:type_name -> openshell.sandbox.v1.NetworkBinary + 130, // 177: openshell.v1.ProviderProfile.discovery:type_name -> openshell.v1.ProviderProfileDiscovery + 258, // 178: openshell.v1.ProviderProfile.annotations:type_name -> openshell.v1.ProviderProfile.AnnotationsEntry + 139, // 179: openshell.v1.ProviderProfileResponse.profile:type_name -> openshell.v1.ProviderProfile + 139, // 180: openshell.v1.ListProviderProfilesResponse.profiles:type_name -> openshell.v1.ProviderProfile + 120, // 181: openshell.v1.ImportProviderProfilesRequest.profiles:type_name -> openshell.v1.ProviderProfileImportItem + 121, // 182: openshell.v1.ImportProviderProfilesResponse.diagnostics:type_name -> openshell.v1.ProviderProfileDiagnostic + 139, // 183: openshell.v1.ImportProviderProfilesResponse.profiles:type_name -> openshell.v1.ProviderProfile + 120, // 184: openshell.v1.UpdateProviderProfilesRequest.profile:type_name -> openshell.v1.ProviderProfileImportItem + 121, // 185: openshell.v1.UpdateProviderProfilesResponse.diagnostics:type_name -> openshell.v1.ProviderProfileDiagnostic + 139, // 186: openshell.v1.UpdateProviderProfilesResponse.profile:type_name -> openshell.v1.ProviderProfile + 120, // 187: openshell.v1.LintProviderProfilesRequest.profiles:type_name -> openshell.v1.ProviderProfileImportItem + 121, // 188: openshell.v1.LintProviderProfilesResponse.diagnostics:type_name -> openshell.v1.ProviderProfileDiagnostic + 15, // 189: openshell.v1.DeleteProviderResponse.outcome:type_name -> openshell.v1.DeletionOutcome + 15, // 190: openshell.v1.DeleteProviderProfileResponse.outcome:type_name -> openshell.v1.DeletionOutcome + 152, // 191: openshell.v1.StaticCredentialBinding.endpoints:type_name -> openshell.v1.StaticCredentialEndpointBinding + 259, // 192: openshell.v1.GetSandboxProviderEnvironmentResponse.environment:type_name -> openshell.v1.GetSandboxProviderEnvironmentResponse.EnvironmentEntry + 260, // 193: openshell.v1.GetSandboxProviderEnvironmentResponse.credential_expiration_times:type_name -> openshell.v1.GetSandboxProviderEnvironmentResponse.CredentialExpirationTimesEntry + 261, // 194: openshell.v1.GetSandboxProviderEnvironmentResponse.dynamic_credentials:type_name -> openshell.v1.GetSandboxProviderEnvironmentResponse.DynamicCredentialsEntry + 262, // 195: openshell.v1.GetSandboxProviderEnvironmentResponse.static_credential_bindings:type_name -> openshell.v1.GetSandboxProviderEnvironmentResponse.StaticCredentialBindingsEntry + 3, // 196: openshell.v1.GetSandboxProviderEnvironmentResponse.readiness_reason:type_name -> openshell.v1.ProviderReadinessReason + 271, // 197: openshell.v1.ExchangeProviderSubjectTokenResponse.expires_after:type_name -> google.protobuf.Duration + 269, // 198: openshell.v1.UpdateConfigRequest.policy:type_name -> openshell.sandbox.v1.SandboxPolicy + 277, // 199: openshell.v1.UpdateConfigRequest.setting_value:type_name -> openshell.sandbox.v1.SettingValue + 158, // 200: openshell.v1.UpdateConfigRequest.merge_operations:type_name -> openshell.v1.PolicyMergeOperation + 263, // 201: openshell.v1.UpdateConfigRequest.annotations:type_name -> openshell.v1.UpdateConfigRequest.AnnotationsEntry + 272, // 202: openshell.v1.UpdateConfigRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 159, // 203: openshell.v1.PolicyMergeOperation.add_rule:type_name -> openshell.v1.AddNetworkRule + 160, // 204: openshell.v1.PolicyMergeOperation.remove_endpoint:type_name -> openshell.v1.RemoveNetworkEndpoint + 161, // 205: openshell.v1.PolicyMergeOperation.remove_rule:type_name -> openshell.v1.RemoveNetworkRule + 163, // 206: openshell.v1.PolicyMergeOperation.add_deny_rules:type_name -> openshell.v1.AddDenyRules + 164, // 207: openshell.v1.PolicyMergeOperation.add_allow_rules:type_name -> openshell.v1.AddAllowRules + 165, // 208: openshell.v1.PolicyMergeOperation.remove_binary:type_name -> openshell.v1.RemoveNetworkBinary + 278, // 209: openshell.v1.AddNetworkRule.rule:type_name -> openshell.sandbox.v1.NetworkPolicyRule + 276, // 210: openshell.v1.L7RuleTarget.binaries:type_name -> openshell.sandbox.v1.NetworkBinary + 279, // 211: openshell.v1.AddDenyRules.deny_rules:type_name -> openshell.sandbox.v1.L7DenyRule + 162, // 212: openshell.v1.AddDenyRules.target:type_name -> openshell.v1.L7RuleTarget + 280, // 213: openshell.v1.AddAllowRules.rules:type_name -> openshell.sandbox.v1.L7Rule + 162, // 214: openshell.v1.AddAllowRules.target:type_name -> openshell.v1.L7RuleTarget + 264, // 215: openshell.v1.UpdateConfigResponse.annotations:type_name -> openshell.v1.UpdateConfigResponse.AnnotationsEntry + 272, // 216: openshell.v1.GetSandboxPolicyStatusRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 176, // 217: openshell.v1.GetSandboxPolicyStatusResponse.revision:type_name -> openshell.v1.SandboxPolicyRevision + 272, // 218: openshell.v1.ListSandboxPoliciesRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 176, // 219: openshell.v1.ListSandboxPoliciesResponse.revisions:type_name -> openshell.v1.SandboxPolicyRevision + 11, // 220: openshell.v1.ReportPolicyStatusRequest.status:type_name -> openshell.v1.PolicyStatus + 10, // 221: openshell.v1.SandboxConfigurationAdmission.state:type_name -> openshell.v1.ConfigurationAdmissionState + 173, // 222: openshell.v1.ReportSandboxConfigurationRequest.admission:type_name -> openshell.v1.SandboxConfigurationAdmission + 11, // 223: openshell.v1.SandboxPolicyRevision.status:type_name -> openshell.v1.PolicyStatus + 267, // 224: openshell.v1.SandboxPolicyRevision.created_time:type_name -> google.protobuf.Timestamp + 267, // 225: openshell.v1.SandboxPolicyRevision.loaded_time:type_name -> google.protobuf.Timestamp + 269, // 226: openshell.v1.SandboxPolicyRevision.policy:type_name -> openshell.sandbox.v1.SandboxPolicy + 265, // 227: openshell.v1.SandboxPolicyRevision.provenance:type_name -> openshell.v1.SandboxPolicyRevision.ProvenanceEntry + 267, // 228: openshell.v1.GetSandboxLogsRequest.since_time:type_name -> google.protobuf.Timestamp + 272, // 229: openshell.v1.GetSandboxLogsRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 109, // 230: openshell.v1.PushSandboxLogsRequest.logs:type_name -> openshell.v1.SandboxLogLine + 109, // 231: openshell.v1.GetSandboxLogsResponse.logs:type_name -> openshell.v1.SandboxLogLine + 183, // 232: openshell.v1.SupervisorMessage.hello:type_name -> openshell.v1.SupervisorHello + 186, // 233: openshell.v1.SupervisorMessage.heartbeat:type_name -> openshell.v1.SupervisorHeartbeat + 197, // 234: openshell.v1.SupervisorMessage.relay_open_result:type_name -> openshell.v1.RelayOpenResult + 198, // 235: openshell.v1.SupervisorMessage.relay_close:type_name -> openshell.v1.RelayClose + 184, // 236: openshell.v1.GatewayMessage.session_accepted:type_name -> openshell.v1.SessionAccepted + 185, // 237: openshell.v1.GatewayMessage.session_rejected:type_name -> openshell.v1.SessionRejected + 187, // 238: openshell.v1.GatewayMessage.heartbeat:type_name -> openshell.v1.GatewayHeartbeat + 192, // 239: openshell.v1.GatewayMessage.relay_open:type_name -> openshell.v1.RelayOpen + 198, // 240: openshell.v1.GatewayMessage.relay_close:type_name -> openshell.v1.RelayClose + 271, // 241: openshell.v1.SessionAccepted.heartbeat_interval:type_name -> google.protobuf.Duration + 193, // 242: openshell.v1.RelayOpen.ssh:type_name -> openshell.v1.SshRelayTarget + 194, // 243: openshell.v1.RelayOpen.tcp:type_name -> openshell.v1.TcpRelayTarget + 195, // 244: openshell.v1.RelayFrame.init:type_name -> openshell.v1.RelayInit + 267, // 245: openshell.v1.DenialSummary.first_seen_time:type_name -> google.protobuf.Timestamp + 267, // 246: openshell.v1.DenialSummary.last_seen_time:type_name -> google.protobuf.Timestamp + 199, // 247: openshell.v1.DenialSummary.l7_request_samples:type_name -> openshell.v1.L7RequestSample + 201, // 248: openshell.v1.NetworkActivitySummary.denials_by_group:type_name -> openshell.v1.DenialGroupCount + 278, // 249: openshell.v1.PolicyChunk.proposed_rule:type_name -> openshell.sandbox.v1.NetworkPolicyRule + 267, // 250: openshell.v1.PolicyChunk.created_time:type_name -> google.protobuf.Timestamp + 267, // 251: openshell.v1.PolicyChunk.decided_time:type_name -> google.protobuf.Timestamp + 267, // 252: openshell.v1.PolicyChunk.first_seen_time:type_name -> google.protobuf.Timestamp + 267, // 253: openshell.v1.PolicyChunk.last_seen_time:type_name -> google.protobuf.Timestamp + 269, // 254: openshell.v1.PolicyChunk.current_effective_policy:type_name -> openshell.sandbox.v1.SandboxPolicy + 269, // 255: openshell.v1.PolicyChunk.candidate_effective_policy:type_name -> openshell.sandbox.v1.SandboxPolicy + 200, // 256: openshell.v1.SubmitPolicyAnalysisRequest.summaries:type_name -> openshell.v1.DenialSummary + 203, // 257: openshell.v1.SubmitPolicyAnalysisRequest.proposed_chunks:type_name -> openshell.v1.PolicyChunk + 202, // 258: openshell.v1.SubmitPolicyAnalysisRequest.network_activity_summaries:type_name -> openshell.v1.NetworkActivitySummary + 272, // 259: openshell.v1.GetDraftPolicyRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 203, // 260: openshell.v1.GetDraftPolicyResponse.chunks:type_name -> openshell.v1.PolicyChunk + 267, // 261: openshell.v1.GetDraftPolicyResponse.last_analyzed_time:type_name -> google.protobuf.Timestamp + 272, // 262: openshell.v1.ApproveDraftChunkRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 272, // 263: openshell.v1.RejectDraftChunkRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 213, // 264: openshell.v1.ApproveAllDraftChunksRequest.approvals:type_name -> openshell.v1.DraftChunkApproval + 272, // 265: openshell.v1.ApproveAllDraftChunksRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 278, // 266: openshell.v1.EditDraftChunkRequest.proposed_rule:type_name -> openshell.sandbox.v1.NetworkPolicyRule + 272, // 267: openshell.v1.EditDraftChunkRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 272, // 268: openshell.v1.UndoDraftChunkRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 272, // 269: openshell.v1.ClearDraftChunksRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 272, // 270: openshell.v1.GetDraftHistoryRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 267, // 271: openshell.v1.DraftHistoryEntry.event_time:type_name -> google.protobuf.Timestamp + 223, // 272: openshell.v1.GetDraftHistoryResponse.entries:type_name -> openshell.v1.DraftHistoryEntry + 266, // 273: openshell.v1.CreateWorkspaceRequest.labels:type_name -> openshell.v1.CreateWorkspaceRequest.LabelsEntry + 281, // 274: openshell.v1.CreateWorkspaceResponse.workspace:type_name -> openshell.datamodel.v1.Workspace + 281, // 275: openshell.v1.GetWorkspaceResponse.workspace:type_name -> openshell.datamodel.v1.Workspace + 281, // 276: openshell.v1.ListWorkspacesResponse.workspaces:type_name -> openshell.datamodel.v1.Workspace + 15, // 277: openshell.v1.DeleteWorkspaceResponse.outcome:type_name -> openshell.v1.DeletionOutcome + 268, // 278: openshell.v1.WorkspaceMember.metadata:type_name -> openshell.datamodel.v1.ObjectMeta + 13, // 279: openshell.v1.WorkspaceMember.role:type_name -> openshell.v1.WorkspaceRole + 13, // 280: openshell.v1.AddWorkspaceMemberRequest.role:type_name -> openshell.v1.WorkspaceRole + 233, // 281: openshell.v1.AddWorkspaceMemberResponse.member:type_name -> openshell.v1.WorkspaceMember + 15, // 282: openshell.v1.RemoveWorkspaceMemberResponse.outcome:type_name -> openshell.v1.DeletionOutcome + 233, // 283: openshell.v1.ListWorkspaceMembersResponse.members:type_name -> openshell.v1.WorkspaceMember + 267, // 284: openshell.v1.ExtensionServiceCredential.expiration_time:type_name -> google.protobuf.Timestamp + 16, // 285: openshell.v1.EndpointObservation.result:type_name -> openshell.v1.EndpointResult + 241, // 286: openshell.v1.ReportEndpointStatusRequest.observations:type_name -> openshell.v1.EndpointObservation + 16, // 287: openshell.v1.EndpointStatus.last_result:type_name -> openshell.v1.EndpointResult + 267, // 288: openshell.v1.EndpointStatus.last_reported_time:type_name -> google.protobuf.Timestamp + 267, // 289: openshell.v1.SandboxProvisioning.configuration_change_time:type_name -> google.protobuf.Timestamp + 267, // 290: openshell.v1.SandboxProvisioning.first_rejection_time:type_name -> google.protobuf.Timestamp + 267, // 291: openshell.v1.SandboxProvisioning.deadline:type_name -> google.protobuf.Timestamp + 267, // 292: openshell.v1.SandboxProvisioning.timeout_time:type_name -> google.protobuf.Timestamp + 267, // 293: openshell.v1.SandboxProvisioning.cleanup_completed_time:type_name -> google.protobuf.Timestamp + 267, // 294: openshell.v1.SandboxProvisioning.cleanup_retry_time:type_name -> google.protobuf.Timestamp + 267, // 295: openshell.v1.SandboxProvisioning.attachment_change_time:type_name -> google.protobuf.Timestamp + 267, // 296: openshell.v1.UpdateProviderRequest.CredentialExpirationTimesEntry.value:type_name -> google.protobuf.Timestamp + 267, // 297: openshell.v1.GetSandboxProviderEnvironmentResponse.CredentialExpirationTimesEntry.value:type_name -> google.protobuf.Timestamp + 125, // 298: openshell.v1.GetSandboxProviderEnvironmentResponse.DynamicCredentialsEntry.value:type_name -> openshell.v1.ProviderProfileCredential + 153, // 299: openshell.v1.GetSandboxProviderEnvironmentResponse.StaticCredentialBindingsEntry.value:type_name -> openshell.v1.StaticCredentialBinding + 21, // 300: openshell.v1.OpenShell.Health:input_type -> openshell.v1.HealthRequest + 23, // 301: openshell.v1.OpenShell.GetCurrentUser:input_type -> openshell.v1.GetCurrentUserRequest + 25, // 302: openshell.v1.OpenShell.GetGatewayInfo:input_type -> openshell.v1.GetGatewayInfoRequest + 50, // 303: openshell.v1.OpenShell.CreateSandbox:input_type -> openshell.v1.CreateSandboxRequest + 58, // 304: openshell.v1.OpenShell.BeginRootfsTarStaging:input_type -> openshell.v1.BeginRootfsTarStagingRequest + 60, // 305: openshell.v1.OpenShell.GetSandbox:input_type -> openshell.v1.GetSandboxRequest + 61, // 306: openshell.v1.OpenShell.ListSandboxes:input_type -> openshell.v1.ListSandboxesRequest + 51, // 307: openshell.v1.OpenShell.CreateSandboxTemplate:input_type -> openshell.v1.CreateSandboxTemplateRequest + 52, // 308: openshell.v1.OpenShell.GetSandboxTemplate:input_type -> openshell.v1.GetSandboxTemplateRequest + 53, // 309: openshell.v1.OpenShell.ListSandboxTemplates:input_type -> openshell.v1.ListSandboxTemplatesRequest + 54, // 310: openshell.v1.OpenShell.DeleteSandboxTemplate:input_type -> openshell.v1.DeleteSandboxTemplateRequest + 62, // 311: openshell.v1.OpenShell.ListSandboxProviders:input_type -> openshell.v1.ListSandboxProvidersRequest + 63, // 312: openshell.v1.OpenShell.AttachSandboxProvider:input_type -> openshell.v1.AttachSandboxProviderRequest + 64, // 313: openshell.v1.OpenShell.DetachSandboxProvider:input_type -> openshell.v1.DetachSandboxProviderRequest + 80, // 314: openshell.v1.OpenShell.GetSandboxProviderStatus:input_type -> openshell.v1.GetSandboxProviderStatusRequest + 65, // 315: openshell.v1.OpenShell.DeleteSandbox:input_type -> openshell.v1.DeleteSandboxRequest + 66, // 316: openshell.v1.OpenShell.StopSandbox:input_type -> openshell.v1.StopSandboxRequest + 67, // 317: openshell.v1.OpenShell.StartSandbox:input_type -> openshell.v1.StartSandboxRequest + 85, // 318: openshell.v1.OpenShell.CreateSshSession:input_type -> openshell.v1.CreateSshSessionRequest + 87, // 319: openshell.v1.OpenShell.ExposeService:input_type -> openshell.v1.ExposeServiceRequest + 88, // 320: openshell.v1.OpenShell.GetService:input_type -> openshell.v1.GetServiceRequest + 89, // 321: openshell.v1.OpenShell.ListServices:input_type -> openshell.v1.ListServicesRequest + 91, // 322: openshell.v1.OpenShell.DeleteService:input_type -> openshell.v1.DeleteServiceRequest + 95, // 323: openshell.v1.OpenShell.RevokeSshSession:input_type -> openshell.v1.RevokeSshSessionRequest + 97, // 324: openshell.v1.OpenShell.ExecSandbox:input_type -> openshell.v1.ExecSandboxRequest + 103, // 325: openshell.v1.OpenShell.ForwardTcp:input_type -> openshell.v1.TcpForwardFrame + 104, // 326: openshell.v1.OpenShell.ExecSandboxInteractive:input_type -> openshell.v1.ExecSandboxInput + 111, // 327: openshell.v1.OpenShell.CreateProvider:input_type -> openshell.v1.CreateProviderRequest + 112, // 328: openshell.v1.OpenShell.GetProvider:input_type -> openshell.v1.GetProviderRequest + 113, // 329: openshell.v1.OpenShell.ListProviders:input_type -> openshell.v1.ListProvidersRequest + 118, // 330: openshell.v1.OpenShell.ListProviderProfiles:input_type -> openshell.v1.ListProviderProfilesRequest + 119, // 331: openshell.v1.OpenShell.GetProviderProfile:input_type -> openshell.v1.GetProviderProfileRequest + 142, // 332: openshell.v1.OpenShell.ImportProviderProfiles:input_type -> openshell.v1.ImportProviderProfilesRequest + 144, // 333: openshell.v1.OpenShell.UpdateProviderProfiles:input_type -> openshell.v1.UpdateProviderProfilesRequest + 146, // 334: openshell.v1.OpenShell.LintProviderProfiles:input_type -> openshell.v1.LintProviderProfilesRequest + 114, // 335: openshell.v1.OpenShell.UpdateProvider:input_type -> openshell.v1.UpdateProviderRequest + 131, // 336: openshell.v1.OpenShell.GetProviderRefreshStatus:input_type -> openshell.v1.GetProviderRefreshStatusRequest + 133, // 337: openshell.v1.OpenShell.ConfigureProviderRefresh:input_type -> openshell.v1.ConfigureProviderRefreshRequest + 135, // 338: openshell.v1.OpenShell.RotateProviderCredential:input_type -> openshell.v1.RotateProviderCredentialRequest + 137, // 339: openshell.v1.OpenShell.DeleteProviderRefresh:input_type -> openshell.v1.DeleteProviderRefreshRequest + 115, // 340: openshell.v1.OpenShell.DeleteProvider:input_type -> openshell.v1.DeleteProviderRequest + 149, // 341: openshell.v1.OpenShell.DeleteProviderProfile:input_type -> openshell.v1.DeleteProviderProfileRequest + 282, // 342: openshell.v1.OpenShell.GetSandboxConfig:input_type -> openshell.sandbox.v1.GetSandboxConfigRequest + 283, // 343: openshell.v1.OpenShell.GetGatewayConfig:input_type -> openshell.sandbox.v1.GetGatewayConfigRequest + 157, // 344: openshell.v1.OpenShell.UpdateConfig:input_type -> openshell.v1.UpdateConfigRequest + 167, // 345: openshell.v1.OpenShell.GetSandboxPolicyStatus:input_type -> openshell.v1.GetSandboxPolicyStatusRequest + 169, // 346: openshell.v1.OpenShell.ListSandboxPolicies:input_type -> openshell.v1.ListSandboxPoliciesRequest + 171, // 347: openshell.v1.OpenShell.ReportPolicyStatus:input_type -> openshell.v1.ReportPolicyStatusRequest + 242, // 348: openshell.v1.OpenShell.ReportEndpointStatus:input_type -> openshell.v1.ReportEndpointStatusRequest + 82, // 349: openshell.v1.OpenShell.ReportProviderReadiness:input_type -> openshell.v1.ReportProviderReadinessRequest + 174, // 350: openshell.v1.OpenShell.ReportSandboxConfiguration:input_type -> openshell.v1.ReportSandboxConfigurationRequest + 151, // 351: openshell.v1.OpenShell.GetSandboxProviderEnvironment:input_type -> openshell.v1.GetSandboxProviderEnvironmentRequest + 155, // 352: openshell.v1.OpenShell.ExchangeProviderSubjectToken:input_type -> openshell.v1.ExchangeProviderSubjectTokenRequest + 177, // 353: openshell.v1.OpenShell.GetSandboxLogs:input_type -> openshell.v1.GetSandboxLogsRequest + 178, // 354: openshell.v1.OpenShell.PushSandboxLogs:input_type -> openshell.v1.PushSandboxLogsRequest + 181, // 355: openshell.v1.OpenShell.ConnectSupervisor:input_type -> openshell.v1.SupervisorMessage + 188, // 356: openshell.v1.OpenShell.ReportMainProcessExit:input_type -> openshell.v1.ReportMainProcessExitRequest + 190, // 357: openshell.v1.OpenShell.FinalizeMainProcessExit:input_type -> openshell.v1.FinalizeMainProcessExitRequest + 196, // 358: openshell.v1.OpenShell.RelayStream:input_type -> openshell.v1.RelayFrame + 107, // 359: openshell.v1.OpenShell.WatchSandbox:input_type -> openshell.v1.WatchSandboxRequest + 205, // 360: openshell.v1.OpenShell.SubmitPolicyAnalysis:input_type -> openshell.v1.SubmitPolicyAnalysisRequest + 207, // 361: openshell.v1.OpenShell.GetDraftPolicy:input_type -> openshell.v1.GetDraftPolicyRequest + 209, // 362: openshell.v1.OpenShell.ApproveDraftChunk:input_type -> openshell.v1.ApproveDraftChunkRequest + 211, // 363: openshell.v1.OpenShell.RejectDraftChunk:input_type -> openshell.v1.RejectDraftChunkRequest + 214, // 364: openshell.v1.OpenShell.ApproveAllDraftChunks:input_type -> openshell.v1.ApproveAllDraftChunksRequest + 216, // 365: openshell.v1.OpenShell.EditDraftChunk:input_type -> openshell.v1.EditDraftChunkRequest + 218, // 366: openshell.v1.OpenShell.UndoDraftChunk:input_type -> openshell.v1.UndoDraftChunkRequest + 220, // 367: openshell.v1.OpenShell.ClearDraftChunks:input_type -> openshell.v1.ClearDraftChunksRequest + 222, // 368: openshell.v1.OpenShell.GetDraftHistory:input_type -> openshell.v1.GetDraftHistoryRequest + 17, // 369: openshell.v1.OpenShell.IssueSandboxToken:input_type -> openshell.v1.IssueSandboxTokenRequest + 19, // 370: openshell.v1.OpenShell.RefreshSandboxToken:input_type -> openshell.v1.RefreshSandboxTokenRequest + 225, // 371: openshell.v1.OpenShell.CreateWorkspace:input_type -> openshell.v1.CreateWorkspaceRequest + 227, // 372: openshell.v1.OpenShell.GetWorkspace:input_type -> openshell.v1.GetWorkspaceRequest + 229, // 373: openshell.v1.OpenShell.ListWorkspaces:input_type -> openshell.v1.ListWorkspacesRequest + 231, // 374: openshell.v1.OpenShell.DeleteWorkspace:input_type -> openshell.v1.DeleteWorkspaceRequest + 234, // 375: openshell.v1.OpenShell.AddWorkspaceMember:input_type -> openshell.v1.AddWorkspaceMemberRequest + 236, // 376: openshell.v1.OpenShell.RemoveWorkspaceMember:input_type -> openshell.v1.RemoveWorkspaceMemberRequest + 238, // 377: openshell.v1.OpenShell.ListWorkspaceMembers:input_type -> openshell.v1.ListWorkspaceMembersRequest + 22, // 378: openshell.v1.OpenShell.Health:output_type -> openshell.v1.HealthResponse + 24, // 379: openshell.v1.OpenShell.GetCurrentUser:output_type -> openshell.v1.GetCurrentUserResponse + 26, // 380: openshell.v1.OpenShell.GetGatewayInfo:output_type -> openshell.v1.GetGatewayInfoResponse + 68, // 381: openshell.v1.OpenShell.CreateSandbox:output_type -> openshell.v1.SandboxResponse + 59, // 382: openshell.v1.OpenShell.BeginRootfsTarStaging:output_type -> openshell.v1.BeginRootfsTarStagingResponse + 68, // 383: openshell.v1.OpenShell.GetSandbox:output_type -> openshell.v1.SandboxResponse + 69, // 384: openshell.v1.OpenShell.ListSandboxes:output_type -> openshell.v1.ListSandboxesResponse + 55, // 385: openshell.v1.OpenShell.CreateSandboxTemplate:output_type -> openshell.v1.SandboxTemplateResponse + 55, // 386: openshell.v1.OpenShell.GetSandboxTemplate:output_type -> openshell.v1.SandboxTemplateResponse + 56, // 387: openshell.v1.OpenShell.ListSandboxTemplates:output_type -> openshell.v1.ListSandboxTemplatesResponse + 57, // 388: openshell.v1.OpenShell.DeleteSandboxTemplate:output_type -> openshell.v1.DeleteSandboxTemplateResponse + 70, // 389: openshell.v1.OpenShell.ListSandboxProviders:output_type -> openshell.v1.ListSandboxProvidersResponse + 71, // 390: openshell.v1.OpenShell.AttachSandboxProvider:output_type -> openshell.v1.AttachSandboxProviderResponse + 72, // 391: openshell.v1.OpenShell.DetachSandboxProvider:output_type -> openshell.v1.DetachSandboxProviderResponse + 81, // 392: openshell.v1.OpenShell.GetSandboxProviderStatus:output_type -> openshell.v1.GetSandboxProviderStatusResponse + 84, // 393: openshell.v1.OpenShell.DeleteSandbox:output_type -> openshell.v1.DeleteSandboxResponse + 68, // 394: openshell.v1.OpenShell.StopSandbox:output_type -> openshell.v1.SandboxResponse + 68, // 395: openshell.v1.OpenShell.StartSandbox:output_type -> openshell.v1.SandboxResponse + 86, // 396: openshell.v1.OpenShell.CreateSshSession:output_type -> openshell.v1.CreateSshSessionResponse + 94, // 397: openshell.v1.OpenShell.ExposeService:output_type -> openshell.v1.ServiceEndpointResponse + 94, // 398: openshell.v1.OpenShell.GetService:output_type -> openshell.v1.ServiceEndpointResponse + 90, // 399: openshell.v1.OpenShell.ListServices:output_type -> openshell.v1.ListServicesResponse + 92, // 400: openshell.v1.OpenShell.DeleteService:output_type -> openshell.v1.DeleteServiceResponse + 96, // 401: openshell.v1.OpenShell.RevokeSshSession:output_type -> openshell.v1.RevokeSshSessionResponse + 101, // 402: openshell.v1.OpenShell.ExecSandbox:output_type -> openshell.v1.ExecSandboxEvent + 103, // 403: openshell.v1.OpenShell.ForwardTcp:output_type -> openshell.v1.TcpForwardFrame + 101, // 404: openshell.v1.OpenShell.ExecSandboxInteractive:output_type -> openshell.v1.ExecSandboxEvent + 116, // 405: openshell.v1.OpenShell.CreateProvider:output_type -> openshell.v1.ProviderResponse + 116, // 406: openshell.v1.OpenShell.GetProvider:output_type -> openshell.v1.ProviderResponse + 117, // 407: openshell.v1.OpenShell.ListProviders:output_type -> openshell.v1.ListProvidersResponse + 141, // 408: openshell.v1.OpenShell.ListProviderProfiles:output_type -> openshell.v1.ListProviderProfilesResponse + 140, // 409: openshell.v1.OpenShell.GetProviderProfile:output_type -> openshell.v1.ProviderProfileResponse + 143, // 410: openshell.v1.OpenShell.ImportProviderProfiles:output_type -> openshell.v1.ImportProviderProfilesResponse + 145, // 411: openshell.v1.OpenShell.UpdateProviderProfiles:output_type -> openshell.v1.UpdateProviderProfilesResponse + 147, // 412: openshell.v1.OpenShell.LintProviderProfiles:output_type -> openshell.v1.LintProviderProfilesResponse + 116, // 413: openshell.v1.OpenShell.UpdateProvider:output_type -> openshell.v1.ProviderResponse + 132, // 414: openshell.v1.OpenShell.GetProviderRefreshStatus:output_type -> openshell.v1.GetProviderRefreshStatusResponse + 134, // 415: openshell.v1.OpenShell.ConfigureProviderRefresh:output_type -> openshell.v1.ConfigureProviderRefreshResponse + 136, // 416: openshell.v1.OpenShell.RotateProviderCredential:output_type -> openshell.v1.RotateProviderCredentialResponse + 138, // 417: openshell.v1.OpenShell.DeleteProviderRefresh:output_type -> openshell.v1.DeleteProviderRefreshResponse + 148, // 418: openshell.v1.OpenShell.DeleteProvider:output_type -> openshell.v1.DeleteProviderResponse + 150, // 419: openshell.v1.OpenShell.DeleteProviderProfile:output_type -> openshell.v1.DeleteProviderProfileResponse + 284, // 420: openshell.v1.OpenShell.GetSandboxConfig:output_type -> openshell.sandbox.v1.GetSandboxConfigResponse + 285, // 421: openshell.v1.OpenShell.GetGatewayConfig:output_type -> openshell.sandbox.v1.GetGatewayConfigResponse + 166, // 422: openshell.v1.OpenShell.UpdateConfig:output_type -> openshell.v1.UpdateConfigResponse + 168, // 423: openshell.v1.OpenShell.GetSandboxPolicyStatus:output_type -> openshell.v1.GetSandboxPolicyStatusResponse + 170, // 424: openshell.v1.OpenShell.ListSandboxPolicies:output_type -> openshell.v1.ListSandboxPoliciesResponse + 172, // 425: openshell.v1.OpenShell.ReportPolicyStatus:output_type -> openshell.v1.ReportPolicyStatusResponse + 243, // 426: openshell.v1.OpenShell.ReportEndpointStatus:output_type -> openshell.v1.ReportEndpointStatusResponse + 83, // 427: openshell.v1.OpenShell.ReportProviderReadiness:output_type -> openshell.v1.ReportProviderReadinessResponse + 175, // 428: openshell.v1.OpenShell.ReportSandboxConfiguration:output_type -> openshell.v1.ReportSandboxConfigurationResponse + 154, // 429: openshell.v1.OpenShell.GetSandboxProviderEnvironment:output_type -> openshell.v1.GetSandboxProviderEnvironmentResponse + 156, // 430: openshell.v1.OpenShell.ExchangeProviderSubjectToken:output_type -> openshell.v1.ExchangeProviderSubjectTokenResponse + 180, // 431: openshell.v1.OpenShell.GetSandboxLogs:output_type -> openshell.v1.GetSandboxLogsResponse + 179, // 432: openshell.v1.OpenShell.PushSandboxLogs:output_type -> openshell.v1.PushSandboxLogsResponse + 182, // 433: openshell.v1.OpenShell.ConnectSupervisor:output_type -> openshell.v1.GatewayMessage + 189, // 434: openshell.v1.OpenShell.ReportMainProcessExit:output_type -> openshell.v1.ReportMainProcessExitResponse + 191, // 435: openshell.v1.OpenShell.FinalizeMainProcessExit:output_type -> openshell.v1.FinalizeMainProcessExitResponse + 196, // 436: openshell.v1.OpenShell.RelayStream:output_type -> openshell.v1.RelayFrame + 108, // 437: openshell.v1.OpenShell.WatchSandbox:output_type -> openshell.v1.SandboxStreamEvent + 206, // 438: openshell.v1.OpenShell.SubmitPolicyAnalysis:output_type -> openshell.v1.SubmitPolicyAnalysisResponse + 208, // 439: openshell.v1.OpenShell.GetDraftPolicy:output_type -> openshell.v1.GetDraftPolicyResponse + 210, // 440: openshell.v1.OpenShell.ApproveDraftChunk:output_type -> openshell.v1.ApproveDraftChunkResponse + 212, // 441: openshell.v1.OpenShell.RejectDraftChunk:output_type -> openshell.v1.RejectDraftChunkResponse + 215, // 442: openshell.v1.OpenShell.ApproveAllDraftChunks:output_type -> openshell.v1.ApproveAllDraftChunksResponse + 217, // 443: openshell.v1.OpenShell.EditDraftChunk:output_type -> openshell.v1.EditDraftChunkResponse + 219, // 444: openshell.v1.OpenShell.UndoDraftChunk:output_type -> openshell.v1.UndoDraftChunkResponse + 221, // 445: openshell.v1.OpenShell.ClearDraftChunks:output_type -> openshell.v1.ClearDraftChunksResponse + 224, // 446: openshell.v1.OpenShell.GetDraftHistory:output_type -> openshell.v1.GetDraftHistoryResponse + 18, // 447: openshell.v1.OpenShell.IssueSandboxToken:output_type -> openshell.v1.IssueSandboxTokenResponse + 20, // 448: openshell.v1.OpenShell.RefreshSandboxToken:output_type -> openshell.v1.RefreshSandboxTokenResponse + 226, // 449: openshell.v1.OpenShell.CreateWorkspace:output_type -> openshell.v1.CreateWorkspaceResponse + 228, // 450: openshell.v1.OpenShell.GetWorkspace:output_type -> openshell.v1.GetWorkspaceResponse + 230, // 451: openshell.v1.OpenShell.ListWorkspaces:output_type -> openshell.v1.ListWorkspacesResponse + 232, // 452: openshell.v1.OpenShell.DeleteWorkspace:output_type -> openshell.v1.DeleteWorkspaceResponse + 235, // 453: openshell.v1.OpenShell.AddWorkspaceMember:output_type -> openshell.v1.AddWorkspaceMemberResponse + 237, // 454: openshell.v1.OpenShell.RemoveWorkspaceMember:output_type -> openshell.v1.RemoveWorkspaceMemberResponse + 239, // 455: openshell.v1.OpenShell.ListWorkspaceMembers:output_type -> openshell.v1.ListWorkspaceMembersResponse + 378, // [378:456] is the sub-list for method output_type + 300, // [300:378] is the sub-list for method input_type + 300, // [300:300] is the sub-list for extension type_name + 300, // [300:300] is the sub-list for extension extendee + 0, // [0:300] is the sub-list for field type_name } func init() { file_openshell_proto_init() } @@ -19414,38 +19550,40 @@ func file_openshell_proto_init() { } 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[55].OneofWrappers = []any{ + file_openshell_proto_msgTypes[21].OneofWrappers = []any{} + file_openshell_proto_msgTypes[22].OneofWrappers = []any{} + file_openshell_proto_msgTypes[30].OneofWrappers = []any{} + file_openshell_proto_msgTypes[57].OneofWrappers = []any{ (*ConfigSnapshotRevision_SandboxConfig)(nil), (*ConfigSnapshotRevision_ProviderEnvironment)(nil), (*ConfigSnapshotRevision_ProviderTarget)(nil), } - file_openshell_proto_msgTypes[82].OneofWrappers = []any{ + file_openshell_proto_msgTypes[84].OneofWrappers = []any{ (*ExecSandboxEvent_Stdout)(nil), (*ExecSandboxEvent_Stderr)(nil), (*ExecSandboxEvent_Exit)(nil), } - file_openshell_proto_msgTypes[83].OneofWrappers = []any{ + file_openshell_proto_msgTypes[85].OneofWrappers = []any{ (*TcpForwardInit_Ssh)(nil), (*TcpForwardInit_Tcp)(nil), } - file_openshell_proto_msgTypes[84].OneofWrappers = []any{ + file_openshell_proto_msgTypes[86].OneofWrappers = []any{ (*TcpForwardFrame_Init)(nil), (*TcpForwardFrame_Data)(nil), } - file_openshell_proto_msgTypes[85].OneofWrappers = []any{ + file_openshell_proto_msgTypes[87].OneofWrappers = []any{ (*ExecSandboxInput_Start)(nil), (*ExecSandboxInput_Stdin)(nil), (*ExecSandboxInput_Resize)(nil), } - file_openshell_proto_msgTypes[89].OneofWrappers = []any{ + file_openshell_proto_msgTypes[91].OneofWrappers = []any{ (*SandboxStreamEvent_Sandbox)(nil), (*SandboxStreamEvent_Log)(nil), (*SandboxStreamEvent_Event)(nil), (*SandboxStreamEvent_Warning)(nil), (*SandboxStreamEvent_DraftPolicyUpdate)(nil), } - file_openshell_proto_msgTypes[139].OneofWrappers = []any{ + file_openshell_proto_msgTypes[141].OneofWrappers = []any{ (*PolicyMergeOperation_AddRule)(nil), (*PolicyMergeOperation_RemoveEndpoint)(nil), (*PolicyMergeOperation_RemoveRule)(nil), @@ -19453,25 +19591,25 @@ func file_openshell_proto_init() { (*PolicyMergeOperation_AddAllowRules)(nil), (*PolicyMergeOperation_RemoveBinary)(nil), } - file_openshell_proto_msgTypes[143].OneofWrappers = []any{} - file_openshell_proto_msgTypes[162].OneofWrappers = []any{ + file_openshell_proto_msgTypes[145].OneofWrappers = []any{} + file_openshell_proto_msgTypes[164].OneofWrappers = []any{ (*SupervisorMessage_Hello)(nil), (*SupervisorMessage_Heartbeat)(nil), (*SupervisorMessage_RelayOpenResult)(nil), (*SupervisorMessage_RelayClose)(nil), } - file_openshell_proto_msgTypes[163].OneofWrappers = []any{ + file_openshell_proto_msgTypes[165].OneofWrappers = []any{ (*GatewayMessage_SessionAccepted)(nil), (*GatewayMessage_SessionRejected)(nil), (*GatewayMessage_Heartbeat)(nil), (*GatewayMessage_RelayOpen)(nil), (*GatewayMessage_RelayClose)(nil), } - file_openshell_proto_msgTypes[173].OneofWrappers = []any{ + file_openshell_proto_msgTypes[175].OneofWrappers = []any{ (*RelayOpen_Ssh)(nil), (*RelayOpen_Tcp)(nil), } - file_openshell_proto_msgTypes[177].OneofWrappers = []any{ + file_openshell_proto_msgTypes[179].OneofWrappers = []any{ (*RelayFrame_Init)(nil), (*RelayFrame_Data)(nil), } @@ -19481,7 +19619,7 @@ func file_openshell_proto_init() { GoPackagePath: reflect.TypeOf(x{}).PkgPath(), RawDescriptor: unsafe.Slice(unsafe.StringData(file_openshell_proto_rawDesc), len(file_openshell_proto_rawDesc)), NumEnums: 17, - NumMessages: 248, + NumMessages: 250, NumExtensions: 0, NumServices: 1, }, From 8bb845ae0b21c60ef0f55e1bc0a76d3869be6f4f 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 7dbf1b9d49..520e00a5af 100644 --- a/python/openshell/sandbox.py +++ b/python/openshell/sandbox.py @@ -1736,9 +1736,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.quantity = cpu if memory is not None: - template.spec.workload.resources.memory = memory + template.spec.workload.resources.memory.quantity = 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 4b8e60e07d..4bad39f835 100644 --- a/python/openshell/sandbox_test.py +++ b/python/openshell/sandbox_test.py @@ -1960,8 +1960,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.quantity = "1" + template.spec.workload.resources.memory.quantity = "512Mi" return template @@ -2256,8 +2256,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.quantity == "1" + assert template.spec.workload.resources.memory.quantity == "512Mi" assert template.spec.workload.resources.gpu.count == 2 assert template.spec.driver_config["kubernetes"]["runtime_class_name"] == "kata" From 0f3a009b649dc6c3d051e2c675dd2e3bf38e3e99 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 45b90ea215..301b5cd6a6 100644 --- a/sdk/typescript/src/client.test.ts +++ b/sdk/typescript/src/client.test.ts @@ -300,12 +300,61 @@ describe('create', () => { expect(created.spec?.tty).toBe(true); }); + it('sends portable CPU, memory, and explicit GPU requirements', async () => { + let created: { + spec?: { + resourceRequirements?: { + cpu?: { quantity?: string }; + memory?: { quantity?: string }; + gpu?: { count?: number }; + }; + }; + } = {}; + const sandbox = client({ + createSandbox: (req) => { + created = req; + return readySandbox('sb', 'sb-id'); + }, + }); + + await sandbox.create({ + image: 'img', + resourceRequirements: { + cpu: { quantity: '2' }, + memory: { quantity: '4Gi' }, + gpu: { count: 2 }, + }, + }); + + expect(created.spec?.resourceRequirements).toMatchObject({ + cpu: { quantity: '2' }, + memory: { quantity: '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?: { quantity?: string } }; }; } = {}; const sandbox = client({ @@ -317,7 +366,12 @@ describe('create', () => { await sandbox.create({ image: 'curated-image', providers: ['claude'], - rawSpec: { logLevel: 'debug', template: { image: 'raw-image' } }, + resourceRequirements: { cpu: { quantity: '1' } }, + rawSpec: { + logLevel: 'debug', + template: { image: 'raw-image' }, + resourceRequirements: { cpu: { quantity: '4' } }, + }, }); // Ungated field only reachable via rawSpec. expect(created.spec?.logLevel).toBe('debug'); @@ -325,6 +379,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?.quantity).toBe('4'); }); it('createFromTemplate sends the workload template name with governance fields only', async () => { @@ -632,7 +688,11 @@ describe('sandbox templates', () => { workload?: { image?: string; environment?: Record; - resources?: { cpu?: string; memory?: string; gpu?: { count?: number } }; + resources?: { + cpu?: { quantity?: string }; + memory?: { quantity?: string }; + gpu?: { count?: number }; + }; }; driverConfig?: Record; }; @@ -663,7 +723,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: { quantity: '1' }, memory: { quantity: '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 b90ae6026b..c4e4508092 100644 --- a/sdk/typescript/src/client.ts +++ b/sdk/typescript/src/client.ts @@ -49,7 +49,6 @@ function timestampMillis(timestamp: { seconds: bigint; nanos: number } | undefin // 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, @@ -126,6 +125,34 @@ function deletionResult(response: { outcome: number; sandboxId?: string }): Dele }; } +/** 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 { + /** Portable CPU quantity, such as `500m`, `1`, or `2.5`. */ + quantity?: string; +} + +/** Memory resource requirements for a sandbox. */ +export interface MemoryResourceRequirements { + /** Portable memory quantity, such as `512Mi`, `4Gi`, or `8G`. */ + quantity?: string; +} + export interface SandboxSpec { name?: string; /** Workspace name. Omit for `default`; empty strings are invalid. */ @@ -134,7 +161,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. */ @@ -149,8 +177,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; } @@ -857,7 +885,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 d858cd75b6..4a35a15b80 100644 --- a/sdk/typescript/src/index.ts +++ b/sdk/typescript/src/index.ts @@ -5,6 +5,7 @@ // export type { ConnectOptions, + CPUResourceRequirements, DeleteOptions, DeletionOutcome, DeletionResult, @@ -18,20 +19,22 @@ export type { ExecStreamEvent, ForwardHandle, ForwardOptions, + GPUResourceRequirements, Health, HealthStatus, ListOptions, + MemoryResourceRequirements, Page, PolicySourceName, ProviderChange, ProviderChangeOptions, ProviderRef, + ResourceRequirements, SandboxConfig, SandboxFromTemplateSpec, SandboxPhaseName, SandboxPolicy, SandboxRef, - SandboxResources, SandboxServiceLevel, SandboxSpec, SandboxStartup, From d919c3da00a6dcd2ee96cd59c3c687149f0c9a6b 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 | 230 +++++++++++++++++- 1 file changed, 227 insertions(+), 3 deletions(-) diff --git a/crates/openshell-server/src/grpc/validation.rs b/crates/openshell-server/src/grpc/validation.rs index cb0d01b9d7..cc38349545 100644 --- a/crates/openshell-server/src/grpc/validation.rs +++ b/crates/openshell-server/src/grpc/validation.rs @@ -197,8 +197,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)?; @@ -296,7 +296,7 @@ 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(invalid_argument( "spec.resource_requirements.gpu.count", @@ -304,9 +304,47 @@ fn validate_gpu_request_fields(spec: &SandboxSpec) -> Result<(), Status> { )); } + if let Some(cpu) = spec + .resource_requirements + .as_ref() + .and_then(|requirements| requirements.cpu.as_ref()) + { + if let Some(quantity) = cpu.quantity.as_deref() { + validate_cpu_quantity(quantity, "spec.resource_requirements.cpu.quantity")?; + } else { + return Err(Status::invalid_argument( + "spec.resource_requirements.cpu must set quantity", + )); + } + } + + if let Some(memory) = spec + .resource_requirements + .as_ref() + .and_then(|requirements| requirements.memory.as_ref()) + { + if let Some(quantity) = memory.quantity.as_deref() { + validate_memory_quantity(quantity, "spec.resource_requirements.memory.quantity")?; + } else { + return Err(Status::invalid_argument( + "spec.resource_requirements.memory must set quantity", + )); + } + } + 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. @@ -360,6 +398,7 @@ fn validate_sandbox_template(tmpl: &SandboxTemplate) -> Result<(), Status> { ), )); } + reject_legacy_template_cpu_memory_resources(s)?; } if let Some(ref s) = tmpl.driver_config { let size = s.encoded_len(); @@ -401,6 +440,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}.quantity" + ))); + } + } + } Ok(()) } @@ -1188,6 +1252,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() }; @@ -1199,6 +1265,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() }; @@ -1210,6 +1278,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() }; @@ -1218,6 +1288,160 @@ 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 { + quantity: Some("500m".to_string()), + }), + memory: Some(openshell_core::proto::MemoryResourceRequirements { + quantity: Some("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 { + quantity: Some("0".to_string()), + }), + memory: Some(openshell_core::proto::MemoryResourceRequirements { + quantity: Some("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.quantity") + ); + } + + #[test] + fn validate_sandbox_spec_accepts_cpu_and_memory_quantities() { + let spec = SandboxSpec { + resource_requirements: Some(openshell_core::proto::ResourceRequirements { + gpu: None, + cpu: Some(openshell_core::proto::CpuResourceRequirements { + quantity: Some("250m".to_string()), + }), + memory: Some(openshell_core::proto::MemoryResourceRequirements { + quantity: Some("512Mi".to_string()), + }), + }), + ..Default::default() + }; + + assert!(validate_sandbox_spec("compute-sandbox", &spec).is_ok()); + } + + #[test] + fn validate_sandbox_spec_rejects_invalid_memory_quantity() { + let spec = SandboxSpec { + resource_requirements: Some(openshell_core::proto::ResourceRequirements { + gpu: None, + cpu: None, + memory: Some(openshell_core::proto::MemoryResourceRequirements { + quantity: Some("0".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.memory.quantity") + ); + } + + #[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.quantity") + ); + } + + #[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 c26ca9cc1514af46b38b75c47cef2a50c074824c 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 | 41 +++++++++++----- crates/openshell-sdk/README.md | 8 +++- docs/reference/sandbox-compute-drivers.mdx | 54 ++++++++++++++++------ docs/sandboxes/manage-sandboxes.mdx | 34 ++++++++++++-- sdk/go/docs/src/api/sandbox-templates.md | 10 ++-- sdk/go/docs/src/api/sandboxes.md | 7 +-- sdk/typescript/README.md | 22 ++++++++- skills/openshell-cli/SKILL.md | 2 +- 8 files changed, 135 insertions(+), 43 deletions(-) diff --git a/architecture/compute-runtimes.md b/architecture/compute-runtimes.md index 0077c86689..e94fd538f3 100644 --- a/architecture/compute-runtimes.md +++ b/architecture/compute-runtimes.md @@ -280,20 +280,26 @@ delete, reconciliation removes the row; otherwise it can remain `Deleting`. | VM | Experimental microVM isolation. | Per-sandbox libkrun or QEMU VM. | The NIC-less guest runs `openshell-sandbox` as PID 1; host `openshell-supervisor` owns gateway networking and reaches the guest over vsock. | | 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 quantities as runtime limits. Kubernetes applies each quantity as a +limit and mirrors it into the matching request unless driver configuration +provides that 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. The gateway retains the former +workload-resource wire field solely at the storage boundary: persisted +templates decode through that legacy shape and are normalized to current +`ResourceRequirements` before Get, List, or sandbox creation. New API writes +cannot populate the legacy field. Docker and Podman also accept per-sandbox driver-config mounts for existing runtime-managed named volumes and tmpfs mounts. Podman additionally accepts @@ -323,9 +329,20 @@ 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 requirements each carry one optional portable `quantity` +(e.g. `"500m"`, `"4Gi"`). Docker and Podman apply quantities as limits. Kubernetes +applies them as limits and uses driver configuration for an independently tuned or +request-only value, falling back from the quantity when no driver-config request is set. +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 3758338dfc..23ee5d0eb9 100644 --- a/crates/openshell-sdk/README.md +++ b/crates/openshell-sdk/README.md @@ -94,7 +94,8 @@ while let Some(page) = pages.next_page().await? { ```rust use openshell_sdk::{ - ClientConfig, OpenShellClient, SandboxTemplateCreateSpec, + ClientConfig, CpuResourceRequirements, MemoryResourceRequirements, OpenShellClient, + ResourceRequirements, SandboxTemplateCreateSpec, SandboxWorkloadConfig, SandboxWorkloadTemplate, SandboxWorkloadTemplateSpec, }; @@ -109,6 +110,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 { quantity: Some("1".to_string()) }), + memory: Some(MemoryResourceRequirements { quantity: Some("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 d24ff67ef4..d0b39b61d5 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,19 +128,48 @@ 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.quantity` and `memory.quantity` are optional portable quantities. +- `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 quantities to native container CPU and memory limits. | +| Podman | Converts typed quantities to native container CPU and memory limits. | +| Kubernetes | Applies typed quantities as limits. A quantity also becomes the request unless a Kubernetes driver-config request is set; driver config can also specify request-only resources. | +| 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 quantity. Kubernetes driver configuration may set +explicit CPU and memory requests. These configured requests replace the request +that Kubernetes would otherwise mirror from the portable quantity. The +portable quantity remains the limit. + ## Resource Capability Reporting -API clients can read each configured driver's static resource request support +API clients can read each configured driver's static portable resource support from the protected `GetGatewayInfo` response. The capability response describes -which request forms a driver implements. It does not report live resource -inventory, availability, or scheduling capacity, so a supported request can -still fail when the selected runtime cannot provide the resource. - -CPU and memory capabilities report whether the driver enforces a resource -limit. GPU capabilities report whether the driver accepts a default GPU request -and an explicit GPU count. An omitted `resource_capabilities` message, or an -omitted CPU, memory, or GPU capability, means the driver did not report that -capability. A reported `false` value means that request form is unsupported. +which portable resource inputs a driver accepts. It does not report live +resource inventory, availability, or scheduling capacity, so a supported +request can still fail when the selected runtime cannot provide the resource. + +CPU and memory capabilities report whether the driver accepts a portable +quantity. GPU capabilities report whether the driver accepts a default GPU +request and an explicit GPU count. An omitted `resource_capabilities` message, +or an omitted CPU, memory, or GPU capability, means the driver did not report +that capability. A reported `false` value means that input is unsupported. For Kubernetes, `pod.runtime_class_name` maps to PodSpec `runtimeClassName`. It overrides the gateway's configured default runtime class for that sandbox, diff --git a/docs/sandboxes/manage-sandboxes.mdx b/docs/sandboxes/manage-sandboxes.mdx index 879a90fa98..284532cb4a 100644 --- a/docs/sandboxes/manage-sandboxes.mdx +++ b/docs/sandboxes/manage-sandboxes.mdx @@ -77,7 +77,7 @@ openshell gateway select local ### CPU and Memory -Set per-sandbox CPU and memory amounts with `--cpu` and `--memory`: +Set portable CPU and memory quantities with `--cpu` and `--memory`: ```shell openshell sandbox create --cpu 2 --memory 4Gi -- claude @@ -86,10 +86,25 @@ 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 uses each quantity as its +limit and, unless its driver configuration provides a request, as its request. +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. + +API and SDK callers set `cpu.quantity` and `memory.quantity`. Workloads that +need Kubernetes requests below those portable quantities can set requests in +the Kubernetes driver configuration. A driver-config request takes precedence +over the quantity-to-request fallback. + + +CPU and memory values under `SandboxTemplate.resources.limits` or +`SandboxTemplate.resources.requests` are no longer supported. API clients must +use `SandboxSpec.resource_requirements.cpu.quantity` and +`SandboxSpec.resource_requirements.memory.quantity`. The gateway +rejects legacy requests with a migration error. + ### Driver-Specific Configuration @@ -256,6 +271,15 @@ 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.quantity`, `memory.quantity`, and `gpu` in both places. +When loading a reusable template stored with the earlier `cpu`, `memory`, and +`gpu` shape, the gateway converts it to the current typed requirements before +returning or using the template. + 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 50f337150b..18fc95e4da 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{Quantity: "2"}, + Memory: &v1.MemoryResourceRequirements{Quantity: "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 f9504227c2..c5bb03770e 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 52122ccfb6..93b35e1016 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: { quantity: '2' }, + memory: { quantity: '4Gi' }, + }, }) await client.sandbox.waitReady(sandbox.name, 120) @@ -87,6 +91,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: { quantity: '500m' }, + memory: { quantity: '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 @@ -188,7 +208,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: { quantity: '1' }, memory: { quantity: '512Mi' } }, }, driverConfig: { kubernetes: { pod: { runtime_class_name: 'kata-containers' } } }, }, diff --git a/skills/openshell-cli/SKILL.md b/skills/openshell-cli/SKILL.md index 057874fa3a..a3fe2211c1 100644 --- a/skills/openshell-cli/SKILL.md +++ b/skills/openshell-cli/SKILL.md @@ -255,7 +255,7 @@ Key flags: - `--provider`: Attach configured credential providers for API keys, tokens, and other secrets (repeatable) - `--policy`: Custom policy YAML (otherwise uses built-in default or `OPENSHELL_SANDBOX_POLICY` env var) - `--gpu [COUNT]`: Request the driver's default GPU selection or a specific GPU count -- `--cpu`, `--memory`: Set per-sandbox compute sizing. Docker/Podman apply limits; Kubernetes applies matching requests and limits. +- `--cpu`, `--memory`: Set portable per-sandbox quantities. Docker/Podman apply them as limits. Kubernetes applies them as limits and uses them as matching requests unless Kubernetes driver config sets an explicit request. - `--driver-config-json`: Pass experimental driver-specific sandbox configuration - `--template NAME`: Create from a named sandbox workload template. Conflicts with inline workload flags such as `--from`, `--gpu`, `--cpu`, `--memory`, `--env`, and `--driver-config-json`. - `--label KEY=VALUE`: Add labels for later selection (repeatable)