From 1885903172dd189ad1b851d441c8e1f5cd06e32b Mon Sep 17 00:00:00 2001 From: sjenning <493891+sjenning@users.noreply.github.com> Date: Thu, 15 Oct 2026 15:18:42 -0500 Subject: [PATCH 1/7] feat(gateway): add storage-preserving sandbox image updates Add image-only UpdateSandbox with conditional versions, durable replay, fenced pending intent, and Kubernetes storage retention. Enable non-destructive image repair after completed timeout cleanup and exercise both Kubernetes controller API lanes. Closes #4623 Signed-off-by: sjenning <493891+sjenning@users.noreply.github.com> --- .agents/skills/helm-dev-environment/SKILL.md | 4 + Cargo.lock | 1 + .../tests/ensure_providers_integration.rs | 7 + .../openshell-cli/tests/mtls_integration.rs | 7 + .../tests/provider_commands_integration.rs | 7 + .../sandbox_create_lifecycle_integration.rs | 7 + .../sandbox_exec_streaming_integration.rs | 7 + .../sandbox_name_fallback_integration.rs | 7 + .../openshell-core/src/extension_protocol.rs | 4 + crates/openshell-driver-docker/src/lib.rs | 20 + crates/openshell-driver-kubernetes/Cargo.toml | 1 + crates/openshell-driver-kubernetes/README.md | 17 + .../openshell-driver-kubernetes/src/driver.rs | 5 +- .../openshell-driver-kubernetes/src/grpc.rs | 20 + .../src/image_update.rs | 455 +++ .../src/image_update_tests.rs | 657 ++++ crates/openshell-driver-mxc/src/grpc.rs | 10 + crates/openshell-driver-podman/src/grpc.rs | 10 + crates/openshell-driver-vm/src/driver.rs | 10 + .../src/routes.rs | 1 + crates/openshell-otel/src/grpc.rs | 6 + crates/openshell-sdk/src/raw.rs | 9 +- crates/openshell-sdk/tests/client_mock.rs | 7 + .../src/compute/image_update.rs | 802 +++++ crates/openshell-server/src/compute/mod.rs | 127 +- .../src/compute/tests/error_recovery.rs | 68 +- crates/openshell-server/src/grpc/mod.rs | 7 + .../src/grpc/mutation_replay/ordinary.rs | 5 + crates/openshell-server/src/grpc/sandbox.rs | 72 + .../src/grpc/sandbox/image_update_tests.rs | 224 ++ crates/openshell-server/src/storage_proto.rs | 33 +- crates/openshell-server/src/test_support.rs | 39 + crates/openshell-server/tests/common/mod.rs | 7 + .../tests/supervisor_relay_integration.rs | 7 + docs/how-it-works/sandboxes/overview.mdx | 48 + docs/sdk/api-errors.mdx | 33 +- e2e/rust/Cargo.lock | 1113 +++++- e2e/rust/Cargo.toml | 9 +- e2e/rust/tests/kubernetes_image_update.rs | 424 +++ proto/compute_driver.proto | 28 + proto/openshell.proto | 40 + .../v1/internal/converter/coverage_test.go | 4 +- sdk/go/proto/openshellv1/openshell.pb.go | 2973 +++++++++-------- sdk/go/proto/openshellv1/openshell_grpc.pb.go | 42 + skills/openshell-cli/SKILL.md | 26 + tasks/test.toml | 5 +- 46 files changed, 5946 insertions(+), 1469 deletions(-) create mode 100644 crates/openshell-driver-kubernetes/src/image_update.rs create mode 100644 crates/openshell-driver-kubernetes/src/image_update_tests.rs create mode 100644 crates/openshell-server/src/compute/image_update.rs create mode 100644 crates/openshell-server/src/grpc/sandbox/image_update_tests.rs create mode 100644 e2e/rust/tests/kubernetes_image_update.rs diff --git a/.agents/skills/helm-dev-environment/SKILL.md b/.agents/skills/helm-dev-environment/SKILL.md index 9fdf315c3c..574bf2c1fd 100644 --- a/.agents/skills/helm-dev-environment/SKILL.md +++ b/.agents/skills/helm-dev-environment/SKILL.md @@ -271,6 +271,10 @@ above) instead of relying only on `OPENSHELL_GATEWAY_ENDPOINT`; some tests call ### Kubernetes E2E Notes Use `mise run e2e:kubernetes` for the standard Helm-backed Kubernetes suite. +Set `OPENSHELL_E2E_KUBE_TEST=kubernetes_image_update` to scope the Rust suite to +image replacement with retained sandbox, SSH, and PVC identities. This target is +included in both existing Agent Sandbox API-version lanes; unlike the Python +Docker suite, it exercises the driver that supports image updates. The kube e2e wrapper creates only one port-forward, to `svc/openshell`; it no longer forwards the unauthenticated health listener or runs a `/readyz` e2e target. `/readyz` remains covered by server unit/integration tests. diff --git a/Cargo.lock b/Cargo.lock index f9c022162b..eb1ca8273c 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -4433,6 +4433,7 @@ dependencies = [ "prost-types", "rand 0.9.4", "rcgen", + "regex", "serde", "serde_json", "temp-env", diff --git a/crates/openshell-cli/tests/ensure_providers_integration.rs b/crates/openshell-cli/tests/ensure_providers_integration.rs index ba5f60c6cc..f1339d2f88 100644 --- a/crates/openshell-cli/tests/ensure_providers_integration.rs +++ b/crates/openshell-cli/tests/ensure_providers_integration.rs @@ -80,6 +80,13 @@ impl TestOpenShell { #[tonic::async_trait] impl OpenShell for TestOpenShell { + async fn update_sandbox( + &self, + _request: tonic::Request, + ) -> Result, Status> { + Err(Status::unimplemented("not implemented by test service")) + } + async fn peer_report_provider_readiness( &self, _request: tonic::Request, diff --git a/crates/openshell-cli/tests/mtls_integration.rs b/crates/openshell-cli/tests/mtls_integration.rs index 4428666184..11cbd909c4 100644 --- a/crates/openshell-cli/tests/mtls_integration.rs +++ b/crates/openshell-cli/tests/mtls_integration.rs @@ -32,6 +32,13 @@ struct TestOpenShell; #[tonic::async_trait] impl OpenShell for TestOpenShell { + async fn update_sandbox( + &self, + _request: tonic::Request, + ) -> Result, Status> { + Err(Status::unimplemented("not implemented by test service")) + } + async fn peer_report_provider_readiness( &self, _request: tonic::Request, diff --git a/crates/openshell-cli/tests/provider_commands_integration.rs b/crates/openshell-cli/tests/provider_commands_integration.rs index 538eebf060..9905711874 100644 --- a/crates/openshell-cli/tests/provider_commands_integration.rs +++ b/crates/openshell-cli/tests/provider_commands_integration.rs @@ -233,6 +233,13 @@ impl TestOpenShell { #[tonic::async_trait] impl OpenShell for TestOpenShell { + async fn update_sandbox( + &self, + _request: tonic::Request, + ) -> Result, Status> { + Err(Status::unimplemented("not implemented by test service")) + } + async fn peer_report_provider_readiness( &self, _request: tonic::Request, diff --git a/crates/openshell-cli/tests/sandbox_create_lifecycle_integration.rs b/crates/openshell-cli/tests/sandbox_create_lifecycle_integration.rs index 31345d6e2e..55abb178fd 100644 --- a/crates/openshell-cli/tests/sandbox_create_lifecycle_integration.rs +++ b/crates/openshell-cli/tests/sandbox_create_lifecycle_integration.rs @@ -101,6 +101,13 @@ struct TestOpenShell { #[tonic::async_trait] impl OpenShell for TestOpenShell { + async fn update_sandbox( + &self, + _request: tonic::Request, + ) -> Result, Status> { + Err(Status::unimplemented("not implemented by test service")) + } + async fn peer_report_provider_readiness( &self, _request: tonic::Request, diff --git a/crates/openshell-cli/tests/sandbox_exec_streaming_integration.rs b/crates/openshell-cli/tests/sandbox_exec_streaming_integration.rs index c57e2d4ea5..1dceab0bf1 100644 --- a/crates/openshell-cli/tests/sandbox_exec_streaming_integration.rs +++ b/crates/openshell-cli/tests/sandbox_exec_streaming_integration.rs @@ -163,6 +163,13 @@ macro_rules! mock_gateway { ) => { #[tonic::async_trait] impl OpenShell for MockGateway { + async fn update_sandbox( + &self, + _request: Request, + ) -> Result, Status> { + Err(Status::unimplemented("not implemented by test service")) + } + $(async fn $method(&self, _: Request<$request>) -> Result, Status> { Err(Status::unimplemented("unused test RPC")) })* diff --git a/crates/openshell-cli/tests/sandbox_name_fallback_integration.rs b/crates/openshell-cli/tests/sandbox_name_fallback_integration.rs index 94a185567d..cfa9903605 100644 --- a/crates/openshell-cli/tests/sandbox_name_fallback_integration.rs +++ b/crates/openshell-cli/tests/sandbox_name_fallback_integration.rs @@ -47,6 +47,13 @@ struct TestOpenShell { #[tonic::async_trait] impl OpenShell for TestOpenShell { + async fn update_sandbox( + &self, + _request: tonic::Request, + ) -> Result, Status> { + Err(Status::unimplemented("not implemented by test service")) + } + async fn peer_report_provider_readiness( &self, _request: tonic::Request, diff --git a/crates/openshell-core/src/extension_protocol.rs b/crates/openshell-core/src/extension_protocol.rs index 9de0b05187..fea8126b45 100644 --- a/crates/openshell-core/src/extension_protocol.rs +++ b/crates/openshell-core/src/extension_protocol.rs @@ -22,6 +22,9 @@ pub const COMPUTE_LAUNCH_AUTHENTICATION: &str = "openshell.compute.launch-authen /// Driver stages operator-selected external isolation routes for the supervisor. pub const COMPUTE_ISOLATION_BACKEND: &str = "openshell.compute.isolation-backend"; +/// Optional stopped-state image updates retaining the resource and its storage. +pub const COMPUTE_UPDATE_SANDBOX_IMAGE: &str = "openshell.compute.update-sandbox-image"; + const MAX_IMPLEMENTATION_NAME_BYTES: usize = 128; const MAX_IMPLEMENTATION_VERSION_BYTES: usize = 128; const MAX_CAPABILITY_BYTES: usize = 128; @@ -125,6 +128,7 @@ pub fn gateway_metadata(family: ExtensionFamily) -> PeerMetadata { if family == ExtensionFamily::Compute { supported_capabilities.push(COMPUTE_LAUNCH_AUTHENTICATION.to_string()); supported_capabilities.push(COMPUTE_ISOLATION_BACKEND.to_string()); + supported_capabilities.push(COMPUTE_UPDATE_SANDBOX_IMAGE.to_string()); } PeerMetadata { protocol_version: Some(ProtocolVersion { diff --git a/crates/openshell-driver-docker/src/lib.rs b/crates/openshell-driver-docker/src/lib.rs index 059ba1535c..88e74918d5 100644 --- a/crates/openshell-driver-docker/src/lib.rs +++ b/crates/openshell-driver-docker/src/lib.rs @@ -3111,6 +3111,16 @@ fn validate_docker_outer_fence( } #[tonic::async_trait] impl ComputeDriver for ComputeDriverService { + async fn update_sandbox_image( + &self, + _request: Request, + ) -> Result, Status> + { + Err(Status::unimplemented( + "storage-preserving image updates are not supported by this driver", + )) + } + type WatchSandboxesStream = WatchStream; async fn authenticate_sandbox( @@ -3264,6 +3274,16 @@ impl ComputeDriver for ComputeDriverService { #[tonic::async_trait] impl ComputeDriver for DockerComputeDriver { + async fn update_sandbox_image( + &self, + _request: Request, + ) -> Result, Status> + { + Err(Status::unimplemented( + "storage-preserving image updates are not supported by this driver", + )) + } + async fn authenticate_sandbox( &self, _request: Request, diff --git a/crates/openshell-driver-kubernetes/Cargo.toml b/crates/openshell-driver-kubernetes/Cargo.toml index 9f28f4fcd5..e98ed37570 100644 --- a/crates/openshell-driver-kubernetes/Cargo.toml +++ b/crates/openshell-driver-kubernetes/Cargo.toml @@ -41,6 +41,7 @@ thiserror = { workspace = true } miette = { workspace = true } notify = "8" rand = { workspace = true } +regex = { workspace = true } rcgen = { workspace = true } [dev-dependencies] diff --git a/crates/openshell-driver-kubernetes/README.md b/crates/openshell-driver-kubernetes/README.md index 8c2f24a7a4..cfba32db4e 100644 --- a/crates/openshell-driver-kubernetes/README.md +++ b/crates/openshell-driver-kubernetes/README.md @@ -159,6 +159,23 @@ storage. The driver confirms the stop from both the published `Suspended` condition and deletion of the backing pod. Legacy `v1alpha1` controllers omit a usable stopped condition, so pod deletion alone confirms their stop. +The optional `openshell.compute.update-sandbox-image` capability supports +image-only updates while the sandbox is stopped. `UpdateSandboxImage` requires +the persisted Kubernetes runtime identity, current image, sandbox name, and a +stable operation ID with a monotonic image revision. The driver verifies that +the same Sandbox resource is suspended, runtime bootstrap has completed, and +no workload or supervisor Pods +remain, then revalidates stored external-resource admission. It patches only +the agent image, the workspace seed image, and dedicated operation evidence, +using the resource UID and `resourceVersion` as concurrency guards. A repeat of +the same completed operation succeeds without a second patch; a different +current image, stale revision, or reused operation ID with different parameters +fails closed. A stale operation cannot reapply an image after a later update +returns to an earlier tag. Image updates do not delete or recreate the Sandbox resource, PVCs, mounts, +trusted runtime images, or bootstrap annotations. They leave the sandbox +stopped. Existing workspace contents and the seed sentinel remain unchanged, +so an image update does not replace files already stored under `/sandbox`. + The workspace PVC size defaults to `workspace_default_storage_size`. Set `workspace_storage_class` to pin the PVC to a specific `StorageClass`; an empty value omits `storageClassName` so the cluster's default `StorageClass` applies. diff --git a/crates/openshell-driver-kubernetes/src/driver.rs b/crates/openshell-driver-kubernetes/src/driver.rs index f30b49f501..5cf8489c54 100644 --- a/crates/openshell-driver-kubernetes/src/driver.rs +++ b/crates/openshell-driver-kubernetes/src/driver.rs @@ -78,6 +78,9 @@ use tokio::sync::{OnceCell, mpsc}; use tokio_stream::wrappers::ReceiverStream; use tracing::{debug, info, warn}; +#[path = "image_update.rs"] +mod image_update; + pub type WatchStream = Pin> + Send>>; @@ -933,7 +936,7 @@ impl KubernetesComputeDriver { openshell_core::extension_protocol::ExtensionFamily::Compute, "openshell/kubernetes", openshell_core::VERSION, - [], + [openshell_core::extension_protocol::COMPUTE_UPDATE_SANDBOX_IMAGE.to_string()], )), }) } diff --git a/crates/openshell-driver-kubernetes/src/grpc.rs b/crates/openshell-driver-kubernetes/src/grpc.rs index 86b0bf4f6b..2ef25533d3 100644 --- a/crates/openshell-driver-kubernetes/src/grpc.rs +++ b/crates/openshell-driver-kubernetes/src/grpc.rs @@ -215,6 +215,26 @@ impl ComputeDriver for ComputeDriverService { .await } + async fn update_sandbox_image( + &self, + request: Request, + ) -> Result, Status> + { + self.rpc_tracer + .trace(openshell_otel::rpc::UPDATE_SANDBOX_IMAGE, async { + self.driver + .update_sandbox_image(&request.into_inner()) + .await + .map_err(|error| { + Status::from(openshell_core::ComputeDriverError::from(error)) + })?; + Ok(Response::new( + openshell_core::proto::compute::v1::UpdateSandboxImageResponse {}, + )) + }) + .await + } + async fn delete_sandbox( &self, request: Request, diff --git a/crates/openshell-driver-kubernetes/src/image_update.rs b/crates/openshell-driver-kubernetes/src/image_update.rs new file mode 100644 index 0000000000..fe7f805fc6 --- /dev/null +++ b/crates/openshell-driver-kubernetes/src/image_update.rs @@ -0,0 +1,455 @@ +// SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +// SPDX-License-Identifier: Apache-2.0 + +//! Storage-preserving, stopped-only workload image mutation. + +use super::{ + KUBE_API_TIMEOUT, KubernetesComputeDriver, KubernetesDriverError, LABEL_SANDBOX_ID, + LABEL_SANDBOX_NAME, SANDBOX_POD_NAME_ANNOTATION, SANDBOX_VERSION_V1BETA1, + WORKSPACE_INIT_CONTAINER_NAME, accepts_auth_namespace, admission_error, annotation_or_label, + is_kube_resource_version_conflict, parse_kubernetes_runtime_identity, sandbox_id_from_object, + sandbox_runtime_bootstrap_in_progress, select_expected_sandbox_runtime, +}; +use k8s_openapi::api::core::v1::Pod; +use kube::Api; +use kube::api::{DynamicObject, ListParams, Patch, PatchParams}; +use openshell_core::proto::compute::v1::UpdateSandboxImageRequest; +use serde::{Deserialize, Serialize}; +use std::collections::BTreeMap; +use std::sync::LazyLock; + +// Deliberately separate from the runtime bootstrap operation annotations. Those +// annotations drive reconciliation and only describe create/start/stop. +const IMAGE_UPDATE_ANNOTATION: &str = "openshell.ai/sandbox-image-update"; + +#[derive(Debug, Deserialize, Serialize, PartialEq, Eq)] +struct ImageUpdateRecord { + operation_id: String, + expected_image: String, + image: String, + revision: u64, +} + +impl KubernetesComputeDriver { + /// Update only a suspended Sandbox's workload and workspace seed images. + /// The resource, claim templates, existing claims, and runtime bootstrap + /// annotations are never replaced. A retry is recognized from durable + /// operation evidence on the same immutable Sandbox resource. + #[tracing::instrument( + name = "kubernetes.update_sandbox_image", + skip_all, + fields( + otel.name = "kubernetes.update_sandbox_image", + otel.status_code = tracing::field::Empty, + sandbox.id = %request.sandbox_id, + ) + )] + pub async fn update_sandbox_image( + &self, + request: &UpdateSandboxImageRequest, + ) -> Result<(), KubernetesDriverError> { + let span_status = openshell_otel::ErrorStatusGuard::current(); + validate_image_update_request(request)?; + let _guard = self + .lifecycle_gates + .gate_for(&request.sandbox_id) + .lock_owned() + .await; + // Include discovery, admission and Pod pagination in a single bound. + let result = + tokio::time::timeout(KUBE_API_TIMEOUT, self.update_sandbox_image_inner(request)) + .await + .unwrap_or_else(|_| { + Err(KubernetesDriverError::Message( + "timed out updating Kubernetes sandbox image; retry the same operation" + .into(), + )) + }); + span_status.finish(result) + } + + async fn update_sandbox_image_inner( + &self, + request: &UpdateSandboxImageRequest, + ) -> Result<(), KubernetesDriverError> { + let expected = parse_kubernetes_runtime_identity(&request.expected_runtime_identity)?; + self.wait_for_operator_allowlist() + .await + .map_err(admission_error)?; + if !accepts_auth_namespace( + &self.config, + self.operator_allowlist.as_ref(), + &expected.namespace, + ) { + return Err(KubernetesDriverError::Precondition( + "persisted runtime namespace is outside the driver's configured scope".into(), + )); + } + let lookup = self + .supported_sandbox_api_for_lookup(self.client.clone()) + .await + .map_err(KubernetesDriverError::Message)?; + let objects = lookup + .api + .list(&ListParams::default().labels(&self.sandbox_lookup_selector(&request.sandbox_id))) + .await + .map_err(KubernetesDriverError::from_kube)? + .items; + let selected = select_expected_sandbox_runtime(objects, &expected)?; + let name = selected.metadata.name.as_deref().ok_or_else(|| { + KubernetesDriverError::Precondition("Sandbox resource has no name".into()) + })?; + let api = Self::agent_sandbox_api( + self.client.clone(), + &lookup.resource.version, + &expected.namespace, + ); + // Refresh after selection, then use exactly this snapshot's version in + // the patch. Never retry a resourceVersion conflict with a stale image, + // attachment inventory or operating-state decision. + let object = api + .api + .get(name) + .await + .map_err(KubernetesDriverError::from_kube)?; + let object = select_expected_sandbox_runtime(vec![object], &expected)?; + if sandbox_id_from_object(&object).as_deref() != Ok(request.sandbox_id.as_str()) + || annotation_or_label(&object, LABEL_SANDBOX_NAME).as_deref() + != Some(request.name.as_str()) + { + return Err(KubernetesDriverError::Precondition( + "Sandbox resource does not match the requested sandbox identity".into(), + )); + } + require_stopped_for_image_update(&object, &lookup.resource.version)?; + let mut candidate = object.clone(); + let repeat = prepare_image_update(&mut candidate, request)?; + // Revalidate the saved provenance and attachment UIDs against current + // operator policy, even for retries. Do not manufacture new provenance + // or re-render driver_config from a caller's request. + self.admit_stored_resources(&candidate) + .await + .map_err(admission_error)?; + self.require_image_update_pods_absent(&object, &request.sandbox_id, &expected.namespace) + .await?; + if request.validate_only || repeat { + return Ok(()); + } + let version = object + .metadata + .resource_version + .as_deref() + .filter(|version| !version.is_empty()) + .ok_or_else(|| { + KubernetesDriverError::Precondition( + "Sandbox resource has no resourceVersion".into(), + ) + })?; + let record = candidate + .metadata + .annotations + .as_ref() + .and_then(|annotations| annotations.get(IMAGE_UPDATE_ANNOTATION)) + .expect("prepared image update has operation evidence"); + let mut patch = serde_json::json!({ + "metadata": { + "uid": expected.resource_uid, + "resourceVersion": version, + "annotations": {IMAGE_UPDATE_ANNOTATION: record} + }, + "spec": {"podTemplate": {"spec": { + "containers": candidate.data["spec"]["podTemplate"]["spec"]["containers"] + }}} + }); + if let Some(init) = candidate + .data + .pointer("/spec/podTemplate/spec/initContainers") + { + patch["spec"]["podTemplate"]["spec"]["initContainers"] = init.clone(); + } + api.api + .patch(name, &PatchParams::default(), &Patch::Merge(&patch)) + .await + .map_err(|error| { + if is_kube_resource_version_conflict(&error) { + KubernetesDriverError::Precondition( + "Sandbox changed during image update; retry the same operation".into(), + ) + } else { + KubernetesDriverError::from_kube(error) + } + })?; + Ok(()) + } + + async fn require_image_update_pods_absent( + &self, + object: &DynamicObject, + sandbox_id: &str, + namespace: &str, + ) -> Result<(), KubernetesDriverError> { + let pods = Api::::namespaced(self.client.clone(), namespace); + // The controller's workload Pod need not carry the OpenShell sandbox + // label. Inspect owner UIDs and recorded names as well as labels and + // annotations, and reject terminating Pods too. Listing the namespace + // also catches supervisors from earlier runtime generations. + let mut params = ListParams::default().limit(500); + loop { + let page = pods + .list(¶ms) + .await + .map_err(KubernetesDriverError::from_kube)?; + if page + .items + .iter() + .any(|pod| image_update_pod_matches(pod, object, sandbox_id)) + { + return Err(KubernetesDriverError::Precondition( + "cannot update image while sandbox workload or supervisor Pods still exist" + .into(), + )); + } + match page.metadata.continue_.filter(|token| !token.is_empty()) { + Some(token) => params = params.continue_token(&token), + None => return Ok(()), + } + } + } +} + +fn validate_image_update_request( + request: &UpdateSandboxImageRequest, +) -> Result<(), KubernetesDriverError> { + for (field, value) in [ + ("sandbox_id", request.sandbox_id.as_str()), + ("name", request.name.as_str()), + ("operation_id", request.operation_id.as_str()), + ] { + if value.is_empty() + || value.len() > 1024 + || value.trim() != value + || value.chars().any(char::is_control) + { + return Err(KubernetesDriverError::InvalidArgument(format!( + "{field} must be a nonempty bounded identifier" + ))); + } + } + if request.revision == 0 { + return Err(KubernetesDriverError::InvalidArgument( + "image update revision must be nonzero".into(), + )); + } + validate_workload_image(&request.image)?; + // The old reference is only a compare-and-swap precondition, not a new + // launch input. Legacy create accepted references that kubelet cannot pull; + // validating their syntax here would prevent repairing those sandboxes. + if request.expected_image.is_empty() || request.expected_image.len() > 2048 { + return Err(KubernetesDriverError::InvalidArgument( + "expected_image must be a nonempty bounded reference".into(), + )); + } + Ok(()) +} + +fn validate_workload_image(image: &str) -> Result<(), KubernetesDriverError> { + // Distribution reference grammar: registry (including a port or bracketed + // IPv6), lowercase repository path, optional tag and/or algorithm:digest. + // Validation is syntax only: resolving/pulling the image remains kubelet's + // job, using the existing operator-selected image-pull Secret inventory. + static REFERENCE: LazyLock = LazyLock::new(|| { + let host_component = r"[a-zA-Z0-9](?:[a-zA-Z0-9-]*[a-zA-Z0-9])?"; + let host = format!(r"(?:{host_component}(?:\.{host_component})*|\[[a-fA-F0-9:]+\])"); + let path = r"[a-z0-9]+(?:(?:[._]|__|-+)[a-z0-9]+)*"; + regex::Regex::new(&format!( + r"^(?:{host}(?::[0-9]+)?/)?{path}(?:/{path})*(?::[a-zA-Z0-9_][a-zA-Z0-9_.-]{{0,127}})?(?:@[a-zA-Z][a-zA-Z0-9]*(?:[-_+.][a-zA-Z][a-zA-Z0-9]*)*:[a-fA-F0-9]{{32,}})?$" + )).expect("valid distribution reference grammar") + }); + let named = image.split('@').next().unwrap_or_default(); + let repository = + named.rsplit_once(':').map_or( + named, + |(prefix, suffix)| { + if suffix.contains('/') { named } else { prefix } + }, + ); + let digest_length_valid = image.rsplit_once('@').is_none_or(|(_, digest)| { + digest + .split_once(':') + .is_some_and(|(algorithm, encoded)| match algorithm { + "sha256" => encoded.len() == 64, + "sha384" => encoded.len() == 96, + "sha512" => encoded.len() == 128, + _ => true, + }) + }); + if image.len() > 2048 + || repository.len() > 255 + || !digest_length_valid + || !REFERENCE.is_match(image) + { + return Err(KubernetesDriverError::InvalidArgument( + "image must be a valid container image reference of at most 2048 bytes".into(), + )); + } + Ok(()) +} + +fn require_stopped_for_image_update( + object: &DynamicObject, + version: &str, +) -> Result<(), KubernetesDriverError> { + let suspended = if version == SANDBOX_VERSION_V1BETA1 { + object + .data + .pointer("/spec/operatingMode") + .and_then(serde_json::Value::as_str) + == Some("Suspended") + } else { + object + .data + .pointer("/spec/replicas") + .and_then(serde_json::Value::as_i64) + == Some(0) + }; + if !suspended + || object.metadata.deletion_timestamp.is_some() + || sandbox_runtime_bootstrap_in_progress(object) + { + return Err(KubernetesDriverError::Precondition( + "image updates require a stopped, suspended sandbox with no runtime bootstrap in progress".into(), + )); + } + Ok(()) +} + +/// Apply the image-only mutation in memory; return true for an exact retry. +fn prepare_image_update( + object: &mut DynamicObject, + request: &UpdateSandboxImageRequest, +) -> Result { + let evidence = object + .metadata + .annotations + .as_ref() + .and_then(|annotations| annotations.get(IMAGE_UPDATE_ANNOTATION)) + .map(|value| serde_json::from_str::(value)) + .transpose() + .map_err(|_| { + KubernetesDriverError::Precondition("invalid stored image update evidence".into()) + })?; + let record = ImageUpdateRecord { + operation_id: request.operation_id.clone(), + expected_image: request.expected_image.clone(), + image: request.image.clone(), + revision: request.revision, + }; + if let Some(saved) = &evidence { + if request.revision < saved.revision { + return Err(KubernetesDriverError::Precondition( + "image update revision is older than the stored image revision".into(), + )); + } + if request.revision == saved.revision && saved != &record { + return Err(KubernetesDriverError::Precondition( + "image update revision was already used with different operation parameters".into(), + )); + } + if saved.operation_id == request.operation_id && saved != &record { + return Err(KubernetesDriverError::Precondition( + "image update operation_id was already used with different parameters".into(), + )); + } + } + let repeat = evidence.as_ref() == Some(&record); + let containers = object + .data + .pointer_mut("/spec/podTemplate/spec/containers") + .and_then(serde_json::Value::as_array_mut) + .ok_or_else(|| { + KubernetesDriverError::Precondition("Sandbox has no workload containers".into()) + })?; + let mut agents = containers + .iter_mut() + .filter(|container| container["name"] == "agent"); + let agent = agents.next().ok_or_else(|| { + KubernetesDriverError::Precondition("Sandbox has no agent container".into()) + })?; + if agents.next().is_some() { + return Err(KubernetesDriverError::Precondition( + "Sandbox has multiple agent containers".into(), + )); + } + let expected: &str = if repeat { + &request.image + } else { + &request.expected_image + }; + if agent["image"].as_str() != Some(expected) { + return Err(KubernetesDriverError::Precondition( + "Sandbox workload image does not match expected_image or the recorded operation target" + .into(), + )); + } + agent["image"] = serde_json::json!(request.image); + if let Some(init) = object + .data + .pointer_mut("/spec/podTemplate/spec/initContainers") + .and_then(serde_json::Value::as_array_mut) + { + for container in init + .iter_mut() + .filter(|container| container["name"] == WORKSPACE_INIT_CONTAINER_NAME) + { + if container["image"].as_str() != Some(expected) { + return Err(KubernetesDriverError::Precondition( + "Sandbox workspace seed image does not match its workload image".into(), + )); + } + container["image"] = serde_json::json!(request.image); + } + } + object + .metadata + .annotations + .get_or_insert_with(BTreeMap::new) + .insert( + IMAGE_UPDATE_ANNOTATION.into(), + serde_json::to_string(&record).expect("image update record serializes"), + ); + Ok(repeat) +} + +fn image_update_pod_matches(pod: &Pod, object: &DynamicObject, sandbox_id: &str) -> bool { + let metadata = &pod.metadata; + metadata.owner_references.as_ref().is_some_and(|owners| { + owners + .iter() + .any(|owner| Some(owner.uid.as_str()) == object.metadata.uid.as_deref()) + }) || metadata + .labels + .as_ref() + .and_then(|labels| labels.get(LABEL_SANDBOX_ID)) + .map(String::as_str) + == Some(sandbox_id) + || metadata + .annotations + .as_ref() + .and_then(|annotations| annotations.get(LABEL_SANDBOX_ID)) + .map(String::as_str) + == Some(sandbox_id) + || metadata.name.as_deref().is_some_and(|name| { + Some(name) == object.metadata.name.as_deref() + || object + .metadata + .annotations + .as_ref() + .and_then(|annotations| annotations.get(SANDBOX_POD_NAME_ANNOTATION)) + .map(String::as_str) + == Some(name) + }) +} + +#[cfg(test)] +#[path = "image_update_tests.rs"] +mod tests; diff --git a/crates/openshell-driver-kubernetes/src/image_update_tests.rs b/crates/openshell-driver-kubernetes/src/image_update_tests.rs new file mode 100644 index 0000000000..780e435e7d --- /dev/null +++ b/crates/openshell-driver-kubernetes/src/image_update_tests.rs @@ -0,0 +1,657 @@ +// SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +// SPDX-License-Identifier: Apache-2.0 + +use super::super::{ + ANNOTATION_SANDBOX_RUNTIME_BOOTSTRAP_OPERATION, ANNOTATION_SANDBOX_RUNTIME_BOOTSTRAP_PHASE, + ANNOTATION_SANDBOX_RUNTIME_BOOTSTRAPPING, ANNOTATION_SANDBOX_RUNTIME_LOG_LEVEL, + ANNOTATION_SANDBOX_RUNTIME_MAIN_PROCESS_SPEC, ANNOTATION_SANDBOX_RUNTIME_READINESS, + KubernetesComputeConfig, LABEL_SANDBOX_WORKSPACE, OperatorNamespaceAllowlist, + SANDBOX_BOOTSTRAP_CONTAINER_NAME, SANDBOX_BOOTSTRAP_VOLUME_NAME, SANDBOX_GROUP, + SANDBOX_VERSION_V1ALPHA1, WORKSPACE_INIT_MOUNT_PATH, WorkspaceMode, +}; +use super::*; +use http_body_util::BodyExt as _; +use kube::Client; +use std::sync::{Arc, Mutex}; +use std::time::Duration; +use tokio::sync::OnceCell; + +struct ApiState { + sandbox: serde_json::Value, + pvc: serde_json::Value, + pods: Vec, + calls: Vec<(http::Method, String)>, + patches: Vec, + conflict: bool, + pods_continue: bool, +} + +fn response( + status: http::StatusCode, + value: serde_json::Value, +) -> http::Response { + http::Response::builder() + .status(status) + .header(http::header::CONTENT_TYPE, "application/json") + .body(kube::client::Body::from(value.to_string().into_bytes())) + .unwrap() +} + +fn merge(target: &mut serde_json::Value, patch: &serde_json::Value) { + if let Some(patch) = patch.as_object() { + for (key, value) in patch { + if value.is_null() { + target.as_object_mut().unwrap().remove(key); + } else { + if target.get(key).is_none() { + target[key] = serde_json::Value::Null; + } + if value.is_object() && !target[key].is_object() { + target[key] = serde_json::json!({}); + } + merge(&mut target[key], value); + } + } + } else { + *target = patch.clone(); + } +} + +fn snapshot(version: &str) -> serde_json::Value { + let mut value = serde_json::json!({ + "apiVersion": format!("{SANDBOX_GROUP}/{version}"), + "kind": "Sandbox", + "metadata": { + "name": "sandbox-cr", "namespace": "openshell", "uid": "resource-uid", + "resourceVersion": "42", "generation": 7, + "labels": {LABEL_SANDBOX_ID: "sandbox-1", LABEL_SANDBOX_NAME: "sandbox-name", LABEL_SANDBOX_WORKSPACE: "team-a"}, + "annotations": { + LABEL_SANDBOX_ID: "sandbox-1", LABEL_SANDBOX_NAME: "sandbox-name", + crate::resource_admission::CONFIG_USED: "true", + crate::resource_admission::IDENTITIES: "{\"PersistentVolumeClaim/openshell/team-data\":\"data-pvc-uid\"}", + "operator.example/bootstrap-provenance": "preserve-me", + ANNOTATION_SANDBOX_RUNTIME_MAIN_PROCESS_SPEC: "stored-launch-spec", + ANNOTATION_SANDBOX_RUNTIME_LOG_LEVEL: "info", + ANNOTATION_SANDBOX_RUNTIME_READINESS: "unavailable", + ANNOTATION_SANDBOX_RUNTIME_BOOTSTRAPPING: "false", + ANNOTATION_SANDBOX_RUNTIME_BOOTSTRAP_OPERATION: "restart", + ANNOTATION_SANDBOX_RUNTIME_BOOTSTRAP_PHASE: "released", + SANDBOX_POD_NAME_ANNOTATION: "recorded-workload" + }, + "ownerReferences": [{"apiVersion":"v1", "kind":"Namespace", "name":"openshell", "uid":"namespace-uid"}] + }, + "spec": { + "volumeClaimTemplates": [{"metadata":{"name":"workspace"}, "spec":{"accessModes":["ReadWriteOnce"], "resources":{"requests":{"storage":"10Gi"}}}}], + "podTemplate": { + "metadata": {"annotations": {"operator.example/pod-injection": "preserved"}}, + "spec": { + "automountServiceAccountToken": false, + "serviceAccountName": "openshell-sandbox", + "imagePullSecrets": [{"name":"operator-registry"}], + "volumes": [ + {"name": SANDBOX_BOOTSTRAP_VOLUME_NAME, "secret":{"secretName":"old-bootstrap-secret"}}, + {"name":"data", "persistentVolumeClaim":{"claimName":"team-data", "readOnly":false}} + ], + "containers": [ + {"name":"agent", "image":"registry.example/agent:v1", "command":["/.openshell/runtime/openshell-sandbox"], "env":[{"name":"UNCHANGED","value":"yes"}], "volumeMounts":[{"name":"workspace", "mountPath":"/sandbox"}, {"name":"data", "mountPath":"/data", "subPath":"agent"}]}, + {"name":"operator-sidecar", "image":"registry.example/agent:v1"} + ], + "initContainers": [ + {"name":SANDBOX_BOOTSTRAP_CONTAINER_NAME, "image":"trusted-runtime:v3"}, + {"name":WORKSPACE_INIT_CONTAINER_NAME, "image":"registry.example/agent:v1", "command":["seed-workspace"], "volumeMounts":[{"name":"workspace", "mountPath":WORKSPACE_INIT_MOUNT_PATH}]}, + {"name":"operator-init", "image":"registry.example/agent:v1"} + ] + } + } + }, + "status":{"conditions":[{"type":"Suspended", "status":"True", "observedGeneration":7}]} + }); + if version == SANDBOX_VERSION_V1BETA1 { + value["spec"]["operatingMode"] = serde_json::json!("Suspended"); + } else { + value["spec"]["replicas"] = serde_json::json!(0); + } + value +} + +fn fixture( + version: &'static str, + operator: bool, +) -> (KubernetesComputeDriver, Arc>) { + let state = Arc::new(Mutex::new(ApiState { + sandbox: snapshot(version), + pvc: serde_json::json!({ + "apiVersion":"meta.k8s.io/v1", "kind":"PartialObjectMetadata", + "metadata": {"name":"team-data", "namespace":"openshell", "uid":"data-pvc-uid", + "labels": {"openshell.ai/sandbox-attachable":"true", "openshell.ai/sandbox-attachable-workspace":"team-a"}} + }), + pods: Vec::new(), + calls: Vec::new(), + patches: Vec::new(), + conflict: false, + pods_continue: false, + })); + let service_state = state.clone(); + let service = tower::service_fn(move |request: http::Request| { + let state = service_state.clone(); + async move { + let path = request.uri().path().to_string(); + let query = request.uri().query().unwrap_or_default().to_string(); + let method = request.method().clone(); + let body = request.into_body().collect().await.unwrap().to_bytes(); + let mut state = state.lock().unwrap(); + state.calls.push((method.clone(), path.clone())); + let value = match (method, path.as_str()) { + (http::Method::GET, path) if path.ends_with("/sandboxes") => { + serde_json::json!({"apiVersion":format!("{SANDBOX_GROUP}/{version}"), "kind":"SandboxList", "metadata":{}, "items":[state.sandbox]}) + } + (http::Method::GET, path) if path.ends_with("/sandboxes/sandbox-cr") => { + state.sandbox.clone() + } + ( + http::Method::GET, + "/api/v1/namespaces/openshell/persistentvolumeclaims/team-data", + ) => state.pvc.clone(), + (http::Method::GET, "/api/v1/namespaces/openshell/pods") => { + if state.pods_continue && !query.contains("continue=") { + serde_json::json!({"apiVersion":"v1", "kind":"PodList", "metadata":{"continue":"page-two"}, "items":[]}) + } else { + serde_json::json!({"apiVersion":"v1", "kind":"PodList", "metadata":{}, "items":state.pods}) + } + } + (http::Method::PATCH, path) if path.ends_with("/sandboxes/sandbox-cr") => { + let mutation: serde_json::Value = serde_json::from_slice(&body).unwrap(); + assert_eq!( + mutation["metadata"]["uid"], + state.sandbox["metadata"]["uid"] + ); + assert_eq!( + mutation["metadata"]["resourceVersion"], + state.sandbox["metadata"]["resourceVersion"] + ); + state.patches.push(mutation.clone()); + if state.conflict { + return Ok::<_, std::convert::Infallible>(response( + http::StatusCode::CONFLICT, + serde_json::json!({"apiVersion":"v1", "kind":"Status", "status":"Failure", "reason":"Conflict", "message":"concurrent start or edit", "code":409}), + )); + } + let next_version = state.sandbox["metadata"]["resourceVersion"] + .as_str() + .unwrap() + .parse::() + .unwrap() + + 1; + let next_generation = + state.sandbox["metadata"]["generation"].as_u64().unwrap() + 1; + merge(&mut state.sandbox, &mutation); + state.sandbox["metadata"]["resourceVersion"] = + serde_json::json!(next_version.to_string()); + state.sandbox["metadata"]["generation"] = serde_json::json!(next_generation); + state.sandbox.clone() + } + (method, path) => { + panic!("unexpected image update Kubernetes request {method} {path}") + } + }; + Ok::<_, std::convert::Infallible>(response(http::StatusCode::OK, value)) + } + }); + let client = Client::new(service, "openshell"); + let api_version = OnceCell::new(); + api_version.set(version).unwrap(); + let driver = KubernetesComputeDriver { + client: client.clone(), + watch_client: client, + sandbox_api_version: Arc::new(api_version), + lifecycle_gates: Arc::default(), + config: KubernetesComputeConfig { + allow_driver_config: true, + workspace_mode: if operator { + WorkspaceMode::Operator + } else { + WorkspaceMode::Shared + }, + ..Default::default() + }, + operator_allowlist: operator.then(|| { + OperatorNamespaceAllowlist::from_set(std::iter::once("openshell".to_string()).collect()) + }), + }; + (driver, state) +} + +fn request() -> UpdateSandboxImageRequest { + UpdateSandboxImageRequest { + sandbox_id: "sandbox-1".into(), + name: "sandbox-name".into(), + image: "registry.example/agent:v2".into(), + expected_image: "registry.example/agent:v1".into(), + expected_runtime_identity: "kubernetes://openshell/resource-uid/old-supervisor-uid".into(), + operation_id: "stable-operation-1".into(), + validate_only: false, + revision: 1, + } +} + +#[tokio::test] +async fn image_update_preflight_validates_without_writes_and_apply_rechecks() { + let (driver, state) = fixture(SANDBOX_VERSION_V1BETA1, false); + let before = state.lock().unwrap().sandbox.clone(); + let mut preflight = request(); + preflight.validate_only = true; + driver.update_sandbox_image(&preflight).await.unwrap(); + { + let state = state.lock().unwrap(); + assert!(state.patches.is_empty()); + assert_eq!(state.sandbox, before); + assert!( + state + .calls + .iter() + .any(|(_, path)| path.ends_with("/persistentvolumeclaims/team-data")) + ); + assert!(state.calls.iter().any(|(_, path)| path.ends_with("/pods"))); + } + // Operator approval can change between preflight and apply. Both requests + // independently enforce the entire stopped/admission check. + state.lock().unwrap().pvc["metadata"]["labels"] = serde_json::json!({}); + assert!(matches!( + driver.update_sandbox_image(&request()).await, + Err(KubernetesDriverError::Precondition(_)) + )); + assert!(matches!( + driver.update_sandbox_image(&preflight).await, + Err(KubernetesDriverError::Precondition(_)) + )); + assert!(state.lock().unwrap().patches.is_empty()); +} + +#[tokio::test] +async fn image_update_capability_is_optional() { + let (driver, _) = fixture(SANDBOX_VERSION_V1BETA1, false); + let metadata = driver.capabilities().unwrap().extension.unwrap(); + let capability = openshell_core::extension_protocol::COMPUTE_UPDATE_SANDBOX_IMAGE; + assert!( + metadata + .supported_capabilities + .iter() + .any(|value| value == capability) + ); + assert!( + !metadata + .required_capabilities + .iter() + .any(|value| value == capability) + ); +} + +#[tokio::test] +async fn image_update_preserves_resource_storage_and_operator_bootstrap_annotations() { + for version in [SANDBOX_VERSION_V1BETA1, SANDBOX_VERSION_V1ALPHA1] { + for operator in [false, true] { + let (driver, state) = fixture(version, operator); + if operator { + // Operator-mode identity can live in bootstrap annotations + // rather than a caller-visible workload-name label. + state.lock().unwrap().sandbox["metadata"]["labels"] + .as_object_mut() + .unwrap() + .remove(LABEL_SANDBOX_NAME); + } + let before = state.lock().unwrap().sandbox.clone(); + let pvc_before = state.lock().unwrap().pvc.clone(); + driver.update_sandbox_image(&request()).await.unwrap(); + let state = state.lock().unwrap(); + let mut expected = before; + expected["metadata"]["resourceVersion"] = serde_json::json!("43"); + expected["metadata"]["generation"] = serde_json::json!(8); + expected["metadata"]["annotations"][IMAGE_UPDATE_ANNOTATION] = serde_json::json!( + serde_json::to_string(&ImageUpdateRecord { + operation_id: request().operation_id, + expected_image: request().expected_image, + image: request().image, + revision: request().revision, + }) + .unwrap() + ); + expected["spec"]["podTemplate"]["spec"]["containers"][0]["image"] = + serde_json::json!(request().image); + expected["spec"]["podTemplate"]["spec"]["initContainers"][1]["image"] = + serde_json::json!(request().image); + // Whole-object equality proves claim templates, mounts, owner UID, + // launch state, operator annotations, and trusted/sidecar images + // were preserved. The API rejects any unexpected DELETE/POST. + assert_eq!(state.sandbox, expected); + assert_eq!(state.pvc, pvc_before); + assert_eq!(state.patches.len(), 1); + assert_eq!( + state.patches[0]["metadata"]["annotations"] + .as_object() + .unwrap() + .len(), + 1 + ); + assert!( + state.patches[0]["spec"] + .get("volumeClaimTemplates") + .is_none() + ); + assert!( + state.patches[0]["spec"]["podTemplate"]["spec"] + .get("volumes") + .is_none() + ); + } + } +} + +#[tokio::test] +async fn image_update_retry_is_durable_and_does_not_patch_twice() { + let (driver, state) = fixture(SANDBOX_VERSION_V1BETA1, false); + driver.update_sandbox_image(&request()).await.unwrap(); + // Simulate a process restart by dropping the original in-memory gate state. + let mut restarted = driver.clone(); + restarted.lifecycle_gates = Arc::default(); + restarted.update_sandbox_image(&request()).await.unwrap(); + assert_eq!(state.lock().unwrap().patches.len(), 1); + let mut other_operation = request(); + other_operation.operation_id = "other-operation".into(); + other_operation.revision += 1; + assert!(matches!( + driver.update_sandbox_image(&other_operation).await, + Err(KubernetesDriverError::Precondition(_)) + )); + let mut reused_operation = request(); + reused_operation.image = "registry.example/agent:v3".into(); + assert!(matches!( + driver.update_sandbox_image(&reused_operation).await, + Err(KubernetesDriverError::Precondition(_)) + )); + assert_eq!(state.lock().unwrap().patches.len(), 1); +} + +#[tokio::test] +async fn image_update_monotonic_revision_rejects_late_replay_after_a_tag_round_trip() { + let (driver, state) = fixture(SANDBOX_VERSION_V1BETA1, false); + let a = request(); + driver.update_sandbox_image(&a).await.unwrap(); + let mut b = a.clone(); + b.expected_image = a.image.clone(); + b.image = a.expected_image.clone(); + b.operation_id = "operation-b".into(); + b.revision = 2; + driver.update_sandbox_image(&b).await.unwrap(); + let before = state.lock().unwrap().sandbox.clone(); + // The current tag again matches A's expected image, but its revision is + // stale. The latest evidence must reject A rather than reapply it. + assert!(matches!(driver.update_sandbox_image(&a).await, + Err(KubernetesDriverError::Precondition(message)) if message.contains("older"))); + let mut conflicting = a.clone(); + conflicting.operation_id = "different-operation-at-revision-2".into(); + conflicting.revision = b.revision; + assert!(matches!(driver.update_sandbox_image(&conflicting).await, + Err(KubernetesDriverError::Precondition(message)) if message.contains("revision was already used"))); + assert_eq!(state.lock().unwrap().patches.len(), 2); + assert_eq!(state.lock().unwrap().sandbox, before); + driver.update_sandbox_image(&b).await.unwrap(); + assert_eq!(state.lock().unwrap().patches.len(), 2); + conflicting.revision = 3; + driver.update_sandbox_image(&conflicting).await.unwrap(); + assert_eq!(state.lock().unwrap().patches.len(), 3); +} + +#[tokio::test] +async fn image_update_rejects_zero_revision_before_kubernetes_io() { + let (driver, state) = fixture(SANDBOX_VERSION_V1BETA1, false); + let mut request = request(); + request.revision = 0; + assert!(matches!( + driver.update_sandbox_image(&request).await, + Err(KubernetesDriverError::InvalidArgument(_)) + )); + assert!(state.lock().unwrap().calls.is_empty()); +} + +#[tokio::test] +async fn image_update_rejects_running_bootstrapping_and_unspecified_operating_state() { + for version in [SANDBOX_VERSION_V1BETA1, SANDBOX_VERSION_V1ALPHA1] { + for scenario in ["running", "bootstrap", "missing", "deleting"] { + let (driver, state) = fixture(version, false); + { + let mut state = state.lock().unwrap(); + match scenario { + "running" if version == SANDBOX_VERSION_V1BETA1 => { + state.sandbox["spec"]["operatingMode"] = serde_json::json!("Running"); + } + "running" => state.sandbox["spec"]["replicas"] = serde_json::json!(1), + "bootstrap" => { + state.sandbox["metadata"]["annotations"] + [ANNOTATION_SANDBOX_RUNTIME_BOOTSTRAPPING] = serde_json::json!("true"); + } + "missing" => { + state.sandbox["spec"].as_object_mut().unwrap().remove( + if version == SANDBOX_VERSION_V1BETA1 { + "operatingMode" + } else { + "replicas" + }, + ); + } + "deleting" => { + state.sandbox["metadata"]["deletionTimestamp"] = + serde_json::json!("2026-10-15T18:00:00Z"); + } + _ => unreachable!(), + } + } + assert!( + matches!( + driver.update_sandbox_image(&request()).await, + Err(KubernetesDriverError::Precondition(_)) + ), + "{scenario} {version}" + ); + assert!(state.lock().unwrap().patches.is_empty()); + } + } +} + +#[tokio::test] +async fn image_update_checks_actual_workload_and_supervisor_pods_including_later_pages() { + for metadata in [ + serde_json::json!({"name":"controller-workload", "ownerReferences":[{"apiVersion":"agents.x-k8s.io/v1beta1", "kind":"Sandbox", "name":"sandbox-cr", "uid":"resource-uid"}]}), + serde_json::json!({"name":"supervisor", "labels":{LABEL_SANDBOX_ID:"sandbox-1"}}), + serde_json::json!({"name":"recorded-workload", "deletionTimestamp":"2026-10-15T18:00:00Z"}), + serde_json::json!({"name":"workload-with-annotation", "annotations":{LABEL_SANDBOX_ID:"sandbox-1"}}), + ] { + let (driver, state) = fixture(SANDBOX_VERSION_V1BETA1, false); + { + let mut state = state.lock().unwrap(); + state + .pods + .push(serde_json::json!({"apiVersion":"v1", "kind":"Pod", "metadata":metadata})); + state.pods_continue = true; + } + let result = driver.update_sandbox_image(&request()).await; + assert!( + matches!(result, Err(KubernetesDriverError::Precondition(message)) if message.contains("Pods still exist")) + ); + assert!(state.lock().unwrap().patches.is_empty()); + } +} + +#[tokio::test] +async fn image_update_rejects_image_name_and_runtime_identity_conflicts() { + for scenario in ["image", "name", "runtime", "seed", "missing-provenance"] { + let (driver, state) = fixture(SANDBOX_VERSION_V1BETA1, false); + let mut request = request(); + match scenario { + "image" => request.expected_image = "registry.example/agent:other".into(), + "name" => request.name = "different-name".into(), + "runtime" => { + request.expected_runtime_identity = + "kubernetes://openshell/replacement-uid/old-supervisor".into(); + } + "seed" => { + state.lock().unwrap().sandbox["spec"]["podTemplate"]["spec"]["initContainers"][1] + ["image"] = serde_json::json!("different-seed:v1"); + } + "missing-provenance" => { + state.lock().unwrap().sandbox["metadata"]["annotations"] + .as_object_mut() + .unwrap() + .remove(crate::resource_admission::CONFIG_USED); + } + _ => unreachable!(), + } + assert!( + matches!( + driver.update_sandbox_image(&request).await, + Err(KubernetesDriverError::Precondition(_)) + ), + "{scenario}" + ); + assert!(state.lock().unwrap().patches.is_empty()); + } +} + +#[tokio::test] +async fn image_update_revalidates_attachment_admission_and_uid_even_on_retry() { + for retry in [false, true] { + for scenario in ["labels", "uid", "config-disabled"] { + let (mut driver, state) = fixture(SANDBOX_VERSION_V1BETA1, false); + if retry { + driver.update_sandbox_image(&request()).await.unwrap(); + } + match scenario { + "labels" => state.lock().unwrap().pvc["metadata"]["labels"] = serde_json::json!({}), + "uid" => { + state.lock().unwrap().pvc["metadata"]["uid"] = + serde_json::json!("replacement-pvc-uid"); + } + "config-disabled" => driver.config.allow_driver_config = false, + _ => unreachable!(), + } + assert!( + matches!( + driver.update_sandbox_image(&request()).await, + Err(KubernetesDriverError::Precondition(_)) + ), + "{scenario} retry={retry}" + ); + assert_eq!(state.lock().unwrap().patches.len(), usize::from(retry)); + } + } +} + +#[tokio::test] +async fn image_update_conflict_does_not_blindly_retry_or_recreate() { + let (driver, state) = fixture(SANDBOX_VERSION_V1BETA1, false); + state.lock().unwrap().conflict = true; + let before = state.lock().unwrap().sandbox.clone(); + assert!( + matches!(driver.update_sandbox_image(&request()).await, Err(KubernetesDriverError::Precondition(message)) if message.contains("changed during image update")) + ); + let state = state.lock().unwrap(); + assert_eq!(state.patches.len(), 1); + assert_eq!(state.sandbox, before); +} + +#[tokio::test] +async fn image_update_grpc_maps_validation_and_precondition_errors() { + use openshell_core::proto::compute::v1::compute_driver_server::ComputeDriver; + let (driver, state) = fixture(SANDBOX_VERSION_V1BETA1, false); + let service = crate::ComputeDriverService::new(driver); + let mut invalid = request(); + invalid.image = "https://registry.example/image:v2".into(); + let error = service + .update_sandbox_image(tonic::Request::new(invalid)) + .await + .unwrap_err(); + assert_eq!(error.code(), tonic::Code::InvalidArgument); + assert!(state.lock().unwrap().calls.is_empty()); + let mut conflict = request(); + conflict.expected_image = "other:v1".into(); + let error = service + .update_sandbox_image(tonic::Request::new(conflict)) + .await + .unwrap_err(); + assert_eq!(error.code(), tonic::Code::FailedPrecondition); +} + +#[tokio::test] +async fn image_update_can_repair_a_legacy_invalid_image_reference() { + let (driver, state) = fixture(SANDBOX_VERSION_V1BETA1, false); + let invalid_image = "UpperCaseRepository"; + { + let mut state = state.lock().unwrap(); + state.sandbox["spec"]["podTemplate"]["spec"]["containers"][0]["image"] = + serde_json::json!(invalid_image); + state.sandbox["spec"]["podTemplate"]["spec"]["initContainers"][1]["image"] = + serde_json::json!(invalid_image); + } + let mut update = request(); + update.expected_image = invalid_image.into(); + driver.update_sandbox_image(&update).await.unwrap(); + let state = state.lock().unwrap(); + assert_eq!(state.patches.len(), 1); + assert_eq!( + state.sandbox["spec"]["podTemplate"]["spec"]["containers"][0]["image"], + update.image + ); + assert_eq!(state.sandbox["metadata"]["uid"], "resource-uid"); +} + +#[test] +fn image_update_validates_container_references() { + for image in [ + "agent", + "registry.example:5000/team/agent:v2", + "localhost/agent:Tag_1", + "[::1]:5000/team/agent", + "team/image__name:v2", + &format!("registry.example/agent@sha256:{}", "a".repeat(64)), + ] { + validate_workload_image(image).unwrap(); + } + for image in [ + "", + " image:v2", + "image:v2\n", + "https://host/image", + "host//image", + "UpperCaseRepository", + "agent:", + "agent@sha256:invalid", + "agent@sha256:abc", + &format!("agent@sha256:{}", "a".repeat(32)), + &format!("agent@sha256:{}", "a".repeat(65)), + &format!("{}:v1", "a".repeat(256)), + "../agent", + &"a".repeat(2049), + ] { + assert!(validate_workload_image(image).is_err(), "{image:?}"); + } +} + +#[tokio::test] +async fn image_update_serializes_with_other_lifecycle_operations() { + let (driver, state) = fixture(SANDBOX_VERSION_V1BETA1, false); + let guard = driver + .lifecycle_gates + .gate_for("sandbox-1") + .lock_owned() + .await; + let request = request(); + let pending = driver.update_sandbox_image(&request); + tokio::pin!(pending); + assert!( + tokio::time::timeout(Duration::from_millis(10), &mut pending) + .await + .is_err() + ); + assert!(state.lock().unwrap().calls.is_empty()); + drop(guard); + pending.await.unwrap(); +} diff --git a/crates/openshell-driver-mxc/src/grpc.rs b/crates/openshell-driver-mxc/src/grpc.rs index 4c21172c47..27810b435b 100644 --- a/crates/openshell-driver-mxc/src/grpc.rs +++ b/crates/openshell-driver-mxc/src/grpc.rs @@ -34,6 +34,16 @@ impl ComputeDriverService { #[tonic::async_trait] impl ComputeDriver for ComputeDriverService { + async fn update_sandbox_image( + &self, + _request: Request, + ) -> Result, Status> + { + Err(Status::unimplemented( + "storage-preserving image updates are not supported by this driver", + )) + } + async fn get_capabilities( &self, request: Request, diff --git a/crates/openshell-driver-podman/src/grpc.rs b/crates/openshell-driver-podman/src/grpc.rs index a6d208f707..c7eda30a90 100644 --- a/crates/openshell-driver-podman/src/grpc.rs +++ b/crates/openshell-driver-podman/src/grpc.rs @@ -50,6 +50,16 @@ impl ComputeDriverService { #[tonic::async_trait] impl ComputeDriver for ComputeDriverService { + async fn update_sandbox_image( + &self, + _request: Request, + ) -> Result, Status> + { + Err(Status::unimplemented( + "storage-preserving image updates are not supported by this driver", + )) + } + async fn authenticate_sandbox( &self, _request: Request, diff --git a/crates/openshell-driver-vm/src/driver.rs b/crates/openshell-driver-vm/src/driver.rs index d0309a2efd..564f2439c9 100644 --- a/crates/openshell-driver-vm/src/driver.rs +++ b/crates/openshell-driver-vm/src/driver.rs @@ -4815,6 +4815,16 @@ fn configure_main_exit_marker(command: &mut Command, state_dir: &Path) { #[tonic::async_trait] impl ComputeDriver for VmDriver { + async fn update_sandbox_image( + &self, + _request: Request, + ) -> Result, Status> + { + Err(Status::unimplemented( + "storage-preserving image updates are not supported by this driver", + )) + } + async fn authenticate_sandbox( &self, _request: Request, diff --git a/crates/openshell-gateway-interceptors/src/routes.rs b/crates/openshell-gateway-interceptors/src/routes.rs index c47f42e40d..c436563ef2 100644 --- a/crates/openshell-gateway-interceptors/src/routes.rs +++ b/crates/openshell-gateway-interceptors/src/routes.rs @@ -16,6 +16,7 @@ const SERVICE_OPEN_SHELL: &str = "openshell.v1.OpenShell"; /// here. pub const INTERCEPTABLE_METHODS: &[&str] = &[ "CreateSandbox", + "UpdateSandbox", "AttachSandboxProvider", "DetachSandboxProvider", "DeleteSandbox", diff --git a/crates/openshell-otel/src/grpc.rs b/crates/openshell-otel/src/grpc.rs index e22af83968..59f901568d 100644 --- a/crates/openshell-otel/src/grpc.rs +++ b/crates/openshell-otel/src/grpc.rs @@ -102,6 +102,10 @@ pub mod rpc { "CreateSandbox", "openshell.compute.v1.ComputeDriver/CreateSandbox", ); + pub const UPDATE_SANDBOX_IMAGE: ComputeDriverRpc = ComputeDriverRpc::new( + "UpdateSandboxImage", + "openshell.compute.v1.ComputeDriver/UpdateSandboxImage", + ); pub const GET_SANDBOX: ComputeDriverRpc = ComputeDriverRpc::new( "GetSandbox", "openshell.compute.v1.ComputeDriver/GetSandbox", @@ -190,6 +194,7 @@ pub fn compute_driver_rpc_operation(path: &str) -> Option { Some("GetCapabilities") => Some(rpc::GET_CAPABILITIES), Some("ValidateSandboxCreate") => Some(rpc::VALIDATE_SANDBOX_CREATE), Some("CreateSandbox") => Some(rpc::CREATE_SANDBOX), + Some("UpdateSandboxImage") => Some(rpc::UPDATE_SANDBOX_IMAGE), Some("GetSandbox") => Some(rpc::GET_SANDBOX), Some("ListSandboxes") => Some(rpc::LIST_SANDBOXES), Some("StopSandbox") => Some(rpc::STOP_SANDBOX), @@ -312,6 +317,7 @@ mod tests { rpc::GET_CAPABILITIES, rpc::VALIDATE_SANDBOX_CREATE, rpc::CREATE_SANDBOX, + rpc::UPDATE_SANDBOX_IMAGE, rpc::GET_SANDBOX, rpc::LIST_SANDBOXES, rpc::STOP_SANDBOX, diff --git a/crates/openshell-sdk/src/raw.rs b/crates/openshell-sdk/src/raw.rs index dd3b7b165b..7a1d9feab3 100644 --- a/crates/openshell-sdk/src/raw.rs +++ b/crates/openshell-sdk/src/raw.rs @@ -28,11 +28,12 @@ pub use openshell_core::proto::{ ListSandboxTemplatesRequest, ListSandboxesRequest, ListWorkspacesRequest, ProviderDesiredIdentity, ProviderMutationKind, ProviderMutationReceipt, ProviderReadinessObservation, ProviderReadinessReason, ProviderReadinessState, - ProviderReadinessStatus, Sandbox, SandboxPhase as ProtoSandboxPhase, SandboxResources, - SandboxServiceLevel, SandboxSpec as ProtoSandboxSpec, SandboxStartup, SandboxTemplate, - SandboxTemplateResponse, SandboxWorkloadConfig, SandboxWorkloadTemplate, + ProviderReadinessStatus, Sandbox, SandboxImageUpdate, SandboxPhase as ProtoSandboxPhase, + SandboxResources, SandboxServiceLevel, SandboxSpec as ProtoSandboxSpec, SandboxStartup, + SandboxTemplate, SandboxTemplateResponse, SandboxWorkloadConfig, SandboxWorkloadTemplate, SandboxWorkloadTemplateProvenance, SandboxWorkloadTemplateSpec, - ServiceStatus as ProtoServiceStatus, StartSandboxRequest, StopSandboxRequest, Workspace, + ServiceStatus as ProtoServiceStatus, StartSandboxRequest, StopSandboxRequest, + UpdateSandboxRequest, Workspace, }; /// Type alias for the gRPC client wrapped in the SDK's auth interceptor. diff --git a/crates/openshell-sdk/tests/client_mock.rs b/crates/openshell-sdk/tests/client_mock.rs index 9784bea474..d360f45a80 100644 --- a/crates/openshell-sdk/tests/client_mock.rs +++ b/crates/openshell-sdk/tests/client_mock.rs @@ -234,6 +234,13 @@ fn workload_template_proto(name: &str, workspace: &str) -> proto::SandboxWorkloa #[tonic::async_trait] impl OpenShell for TestOpenShell { + async fn update_sandbox( + &self, + _request: tonic::Request, + ) -> Result, Status> { + Err(Status::unimplemented("not implemented by test service")) + } + async fn peer_report_provider_readiness( &self, _request: tonic::Request, diff --git a/crates/openshell-server/src/compute/image_update.rs b/crates/openshell-server/src/compute/image_update.rs new file mode 100644 index 0000000000..5b48e93b87 --- /dev/null +++ b/crates/openshell-server/src/compute/image_update.rs @@ -0,0 +1,802 @@ +// SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +// SPDX-License-Identifier: Apache-2.0 + +//! Stopped-only image changes. Persist intent before touching the driver so a +//! lost response cannot allow Start to run a different image than the gateway. + +use super::{ + ComputeRuntime, START_PHASE_CAS_RETRY_LIMIT, provisioning_operation, + sandbox_compute_runtime_identity, +}; +use openshell_core::extension_protocol::COMPUTE_UPDATE_SANDBOX_IMAGE; +use openshell_core::proto::compute::v1::UpdateSandboxImageRequest; +use openshell_core::proto::{Sandbox, SandboxImageUpdate, SandboxPhase}; +use openshell_core::{GetResourceVersion, ObjectId, ObjectName}; +use tonic::{Request, Status}; +use tracing::info; + +impl ComputeRuntime { + pub(crate) async fn update_sandbox_image( + &self, + sandbox_id: &str, + image: String, + expected_resource_version: u64, + ) -> Result { + if !self + .driver_info + .negotiated_extension + .supported_capabilities + .iter() + .any(|capability| capability == COMPUTE_UPDATE_SANDBOX_IMAGE) + { + return Err(Status::unimplemented( + "compute driver does not support storage-preserving sandbox image updates", + )); + } + let lifecycle_guard = self.lifecycle_gates.lock_for(sandbox_id).await; + let sandbox_guard = self.lock_sandbox_for_lifecycle(&lifecycle_guard).await; + let current = self + .store + .get_message::(sandbox_id) + .await + .map_err(|error| Status::internal(format!("fetch sandbox failed: {error}")))? + .ok_or_else(|| Status::not_found("sandbox not found"))?; + ensure_image_update_stopped(¤t)?; + if current.get_resource_version() != expected_resource_version { + return Err(crate::grpc::persistence_error_to_status( + crate::persistence::PersistenceError::Conflict { + current_resource_version: Some(current.get_resource_version()), + }, + "update sandbox image", + )); + } + let old_image = current + .spec + .as_ref() + .and_then(|spec| spec.template.as_ref()) + .map(|template| template.image.clone()) + .filter(|image| !image.is_empty()) + .ok_or_else(|| Status::failed_precondition("sandbox has no workload image"))?; + let pending = current + .status + .as_ref() + .and_then(|status| status.image_update.clone()); + if pending + .as_ref() + .is_some_and(|pending| pending.image != image) + { + return Err(Status::failed_precondition( + "another image update is pending; retry that image before selecting a different image", + )); + } + if pending.is_none() && old_image == image { + return Ok(current); + } + let intent = if let Some(intent) = pending { + intent + } else { + let revision = current + .status + .as_ref() + .map_or(0, |status| status.image_revision) + .checked_add(1) + .ok_or_else(|| Status::resource_exhausted("sandbox image revision exhausted"))?; + SandboxImageUpdate { + operation_id: uuid::Uuid::new_v4().to_string(), + previous_image: old_image, + image: image.clone(), + revision, + } + }; + if current + .status + .as_ref() + .is_none_or(|status| status.image_update.is_none()) + { + let request = image_update_driver_request(¤t, &intent, true); + self.driver + .call_owned( + openshell_otel::rpc::UPDATE_SANDBOX_IMAGE, + Some(sandbox_id), + move |driver| async move { + driver.update_sandbox_image(Request::new(request)).await + }, + ) + .await?; + } + let pending = if current + .status + .as_ref() + .is_some_and(|status| status.image_update.is_some()) + { + current + } else { + let intent_for_write = intent.clone(); + self.store + .update_message_cas::( + sandbox_id, + expected_resource_version, + move |sandbox| { + sandbox + .spec + .as_mut() + .expect("validated spec") + .template + .as_mut() + .expect("validated template") + .image + .clone_from(&image); + let status = sandbox.status.get_or_insert_with(Default::default); + status.image_revision = intent_for_write.revision; + status.image_update = Some(intent_for_write.clone()); + }, + ) + .await + .map_err(|error| { + crate::grpc::persistence_error_to_status(error, "record sandbox image update") + })? + }; + self.sandbox_index.update_from_sandbox(&pending); + self.sandbox_watch_bus.notify(sandbox_id); + drop(sandbox_guard); + + // The durable intent commits ownership. Cancellation of the public RPC + // must not release the lifecycle gate while the driver can still apply. + let runtime = self.clone(); + tokio::spawn(async move { + let _lifecycle_guard = lifecycle_guard; + runtime.complete_image_update(pending, intent).await + }) + .await + .map_err(|error| Status::internal(format!("sandbox image update worker failed: {error}")))? + } + + async fn complete_image_update( + &self, + pending: Sandbox, + intent: SandboxImageUpdate, + ) -> Result { + let request = image_update_driver_request(&pending, &intent, false); + self.driver + .call_owned(openshell_otel::rpc::UPDATE_SANDBOX_IMAGE, Some(pending.object_id()), move |driver| async move { + driver.update_sandbox_image(Request::new(request)).await + }) + .await?; + + // Watchers may have advanced the resource version. Never restore an old + // record or overwrite a concurrent deletion to acknowledge the driver. + let _guard = self.lock_sandbox_local(pending.object_id()).await; + for _ in 0..START_PHASE_CAS_RETRY_LIMIT { + let current = self + .store + .get_message::(pending.object_id()) + .await + .map_err(|error| Status::internal(format!("reload image update failed: {error}")))? + .ok_or_else(|| Status::not_found("sandbox was deleted"))?; + ensure_image_update_stopped(¤t)?; + if current + .status + .as_ref() + .and_then(|status| status.image_update.as_ref()) + != Some(&intent) + { + return Err(Status::aborted("sandbox image update intent changed")); + } + match self + .store + .update_message_cas::( + pending.object_id(), + current.get_resource_version(), + |sandbox| { + sandbox + .status + .as_mut() + .expect("pending status") + .image_update = None; + }, + ) + .await + { + Ok(updated) => { + self.sandbox_index.update_from_sandbox(&updated); + self.sandbox_watch_bus.notify(updated.object_id()); + info!(sandbox_id = %updated.object_id(), operation_id = %intent.operation_id, "Sandbox workload image updated; sandbox remains stopped"); + return Ok(updated); + } + Err(crate::persistence::PersistenceError::Conflict { .. }) => {} + Err(error) => { + return Err(crate::grpc::persistence_error_to_status( + error, + "complete sandbox image update", + )); + } + } + } + Err(Status::aborted( + "sandbox changed while acknowledging image update; read and retry the pending image", + )) + } +} + +fn image_update_driver_request( + sandbox: &Sandbox, + intent: &SandboxImageUpdate, + validate_only: bool, +) -> UpdateSandboxImageRequest { + UpdateSandboxImageRequest { + sandbox_id: sandbox.object_id().to_string(), + name: sandbox.object_name().to_string(), + image: intent.image.clone(), + expected_image: intent.previous_image.clone(), + expected_runtime_identity: sandbox_compute_runtime_identity(sandbox), + operation_id: intent.operation_id.clone(), + validate_only, + revision: intent.revision, + } +} + +fn ensure_image_update_stopped(sandbox: &Sandbox) -> Result<(), Status> { + provisioning_operation::ensure_operation_settled(sandbox)?; + if sandbox.phase() != SandboxPhase::Stopped as i32 + || sandbox + .metadata + .as_ref() + .is_some_and(|metadata| metadata.deletion_time.is_some()) + { + return Err(Status::failed_precondition( + "sandbox must be Stopped before updating its image", + )); + } + Ok(()) +} + +/// Checked both before and after lifecycle locking by Start. A failed driver +/// response does not prove it had no effects, so only a successful retry clears +/// the durable intent. Ordinary stop and deletion never clear it. +pub(super) fn ensure_no_pending_image_update(sandbox: &Sandbox) -> Result<(), Status> { + if sandbox + .status + .as_ref() + .is_some_and(|status| status.image_update.is_some()) + { + return Err(Status::failed_precondition( + "sandbox image update is pending; read the current resource version and retry UpdateSandbox with the same image before starting", + )); + } + Ok(()) +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::compute::{ + COMPUTE_RUNTIME_IDENTITY_ANNOTATION, apply_driver_snapshot, provisioning_deadline, + }; + use crate::sandbox_index::SandboxIndex; + use crate::sandbox_watch::SandboxWatchBus; + use crate::supervisor_session::SupervisorSessionRegistry; + use crate::test_support::{FakeComputeDriver, FakeComputeDriverCall}; + use crate::tracing_bus::TracingLogBus; + use openshell_core::proto::compute::v1::{DriverSandbox, DriverSandboxStatus}; + use openshell_core::proto::datamodel::v1::ObjectMeta; + use openshell_core::proto::{SandboxSpec, SandboxTemplate}; + use std::collections::HashMap; + use std::sync::Arc; + use tonic::Code; + + async fn fixture(supported: bool) -> (ComputeRuntime, Arc, Sandbox) { + let store = Arc::new(crate::persistence::test_store().await); + crate::ensure_default_workspace(&store).await.unwrap(); + let driver = Arc::new(FakeComputeDriver::new()); + let mut runtime = ComputeRuntime::from_driver( + "test".into(), + driver.clone(), + None, + store.clone(), + SandboxIndex::new(), + SandboxWatchBus::new(), + TracingLogBus::new(), + Arc::new(SupervisorSessionRegistry::new()), + ) + .await + .unwrap(); + if supported { + runtime + .driver_info + .negotiated_extension + .supported_capabilities + .push(COMPUTE_UPDATE_SANDBOX_IMAGE.into()); + } + let mut sandbox = Sandbox { + metadata: Some(ObjectMeta { + id: "image-sandbox-id".into(), + name: "image-sandbox".into(), + workspace: "default".into(), + labels: HashMap::from([("app".into(), "retained".into())]), + annotations: HashMap::from([( + COMPUTE_RUNTIME_IDENTITY_ANNOTATION.into(), + "stable-runtime".into(), + )]), + ..Default::default() + }), + spec: Some(SandboxSpec { + template: Some(SandboxTemplate { + image: "example/workload:old".into(), + ..Default::default() + }), + environment: HashMap::from([("KEEP".into(), "value".into())]), + command: vec!["/bin/sh".into()], + ..Default::default() + }), + host_key_fingerprint: "SHA256:stable-key".into(), + ..Default::default() + }; + sandbox.set_phase(SandboxPhase::Stopped as i32); + store.put_message(&sandbox).await.unwrap(); + let sandbox = store + .get_message::(sandbox.object_id()) + .await + .unwrap() + .unwrap(); + (runtime, driver, sandbox) + } + + fn image_calls(driver: &FakeComputeDriver) -> Vec { + driver + .calls() + .into_iter() + .filter_map(|call| match call { + FakeComputeDriverCall::UpdateSandboxImage { request } if !request.validate_only => { + Some(request) + } + _ => None, + }) + .collect() + } + + #[tokio::test] + async fn image_update_preserves_identity_and_every_other_spec_field() { + let (runtime, driver, original) = fixture(true).await; + let updated = runtime + .update_sandbox_image( + original.object_id(), + "example/workload:new".into(), + original.get_resource_version(), + ) + .await + .unwrap(); + let mut expected = original.spec.clone().unwrap(); + expected.template.as_mut().unwrap().image = "example/workload:new".into(); + assert_eq!(updated.spec, Some(expected)); + assert_eq!(updated.object_id(), original.object_id()); + assert_eq!(updated.object_name(), original.object_name()); + assert_eq!(updated.host_key_fingerprint, original.host_key_fingerprint); + assert_eq!( + updated.metadata.as_ref().unwrap().annotations, + original.metadata.as_ref().unwrap().annotations + ); + assert_eq!( + updated.metadata.as_ref().unwrap().labels, + original.metadata.as_ref().unwrap().labels + ); + assert_eq!(updated.phase(), SandboxPhase::Stopped as i32); + assert!(updated.status.as_ref().unwrap().image_update.is_none()); + assert_eq!(updated.status.as_ref().unwrap().image_revision, 1); + let calls = image_calls(&driver); + assert_eq!(calls.len(), 1); + assert_eq!(calls[0].expected_image, "example/workload:old"); + assert_eq!(calls[0].image, "example/workload:new"); + assert_eq!(calls[0].revision, 1); + assert_eq!(calls[0].expected_runtime_identity, "stable-runtime"); + assert!(uuid::Uuid::parse_str(&calls[0].operation_id).is_ok()); + assert!(!driver.calls().iter().any(|call| matches!( + call, + FakeComputeDriverCall::CreateSandbox { .. } + | FakeComputeDriverCall::DeleteSandbox { .. } + | FakeComputeDriverCall::StartSandbox { .. } + ))); + let unchanged = runtime + .update_sandbox_image( + updated.object_id(), + "example/workload:new".into(), + updated.get_resource_version(), + ) + .await + .unwrap(); + assert_eq!( + unchanged.get_resource_version(), + updated.get_resource_version() + ); + assert_eq!(image_calls(&driver).len(), 1); + let back = runtime + .update_sandbox_image( + updated.object_id(), + "example/workload:old".into(), + updated.get_resource_version(), + ) + .await + .unwrap(); + assert_eq!(back.status.as_ref().unwrap().image_revision, 2); + assert_eq!(image_calls(&driver)[1].revision, 2); + } + + #[tokio::test] + async fn image_update_rejects_unsupported_driver_and_stale_version_without_writes() { + let (runtime, driver, original) = fixture(false).await; + assert_eq!( + runtime + .update_sandbox_image( + original.object_id(), + "example/workload:new".into(), + original.get_resource_version() + ) + .await + .unwrap_err() + .code(), + Code::Unimplemented + ); + assert!(image_calls(&driver).is_empty()); + let (runtime, driver, original) = fixture(true).await; + assert_eq!( + runtime + .update_sandbox_image( + original.object_id(), + "example/workload:new".into(), + original.get_resource_version() + 1 + ) + .await + .unwrap_err() + .code(), + Code::Aborted + ); + assert!(image_calls(&driver).is_empty()); + assert_eq!( + runtime + .store + .get_message::(original.object_id()) + .await + .unwrap() + .unwrap(), + original + ); + } + + #[tokio::test] + async fn failed_image_preflight_has_no_durable_effects() { + let (runtime, driver, original) = fixture(true).await; + driver.set_image_validation_error(Some(Code::InvalidArgument)); + assert_eq!( + runtime + .update_sandbox_image( + original.object_id(), + "invalid:image".into(), + original.get_resource_version() + ) + .await + .unwrap_err() + .code(), + Code::InvalidArgument + ); + assert!(image_calls(&driver).is_empty()); + assert_eq!( + runtime + .store + .get_message::(original.object_id()) + .await + .unwrap() + .unwrap(), + original + ); + } + + #[tokio::test] + async fn concurrent_image_updates_cannot_overwrite_each_other() { + let (runtime, driver, original) = fixture(true).await; + // Real RPCs are separate tasks. Polling both futures with join! in one + // task would share the debug task-local lock-order tracker. + let spawn_update = |image: &str| { + let runtime = runtime.clone(); + let sandbox_id = original.object_id().to_string(); + let version = original.get_resource_version(); + let image = image.to_string(); + tokio::spawn(async move { + runtime + .update_sandbox_image(&sandbox_id, image, version) + .await + }) + }; + let first = spawn_update("example/workload:first"); + let second = spawn_update("example/workload:second"); + let (first, second) = tokio::join!(first, second); + let (first, second) = (first.unwrap(), second.unwrap()); + assert_ne!(first.is_ok(), second.is_ok()); + assert_eq!( + first.err().or_else(|| second.err()).unwrap().code(), + Code::Aborted + ); + assert_eq!(image_calls(&driver).len(), 1); + } + + #[tokio::test] + async fn image_update_rejects_non_stopped_states() { + for phase in [ + SandboxPhase::Ready, + SandboxPhase::Provisioning, + SandboxPhase::Starting, + SandboxPhase::Stopping, + SandboxPhase::Completed, + SandboxPhase::Error, + SandboxPhase::Deleting, + ] { + let (runtime, driver, mut sandbox) = fixture(true).await; + sandbox.set_phase(phase as i32); + runtime.store.put_message(&sandbox).await.unwrap(); + let sandbox = runtime + .store + .get_message::(sandbox.object_id()) + .await + .unwrap() + .unwrap(); + assert_eq!( + runtime + .update_sandbox_image( + sandbox.object_id(), + "example/workload:new".into(), + sandbox.get_resource_version() + ) + .await + .unwrap_err() + .code(), + Code::FailedPrecondition, + "{phase:?}" + ); + assert!(image_calls(&driver).is_empty()); + } + } + + #[tokio::test] + async fn image_update_can_roll_back_after_start_timeout_cleanup() { + let (runtime, driver, mut original) = fixture(true).await; + crate::auth::sandbox_session::PersistedSandboxIdentity::new() + .unwrap() + .write(&mut original.metadata.as_mut().unwrap().annotations); + runtime.store.put_message(&original).await.unwrap(); + let original = runtime + .store + .get_message::(original.object_id()) + .await + .unwrap() + .unwrap(); + let upgraded = runtime + .update_sandbox_image( + original.object_id(), + "example/workload:missing".into(), + original.get_resource_version(), + ) + .await + .unwrap(); + let starting = runtime + .start_sandbox("default", original.object_name()) + .await + .unwrap(); + assert_eq!(starting.phase(), SandboxPhase::Starting as i32); + // Backdate the owned preparation clock rather than waiting for the + // production budget. Keep its attempt and settled operation identities. + let overdue = runtime + .store + .update_message_cas::( + starting.object_id(), + starting.get_resource_version(), + |sandbox| { + let record = sandbox + .status + .as_mut() + .unwrap() + .provisioning + .as_mut() + .unwrap(); + record.preparation_deadline = + openshell_core::time::timestamp_from_millis(1).ok(); + record.deadline = record.preparation_deadline; + }, + ) + .await + .unwrap(); + let expired = { + let _guard = runtime.lock_sandbox_local(overdue.object_id()).await; + runtime + .claim_provisioning_timeout(&overdue, openshell_core::time::now_ms()) + .await + .unwrap() + .unwrap() + }; + assert_eq!(expired.phase(), SandboxPhase::Error as i32); + assert!( + runtime + .stop_sandbox("default", original.object_name()) + .await + .is_err() + ); + assert!( + runtime + .update_sandbox_image( + original.object_id(), + "example/workload:old".into(), + expired.get_resource_version() + ) + .await + .is_err() + ); + { + let gate = runtime.lifecycle_gates.lock_for(expired.object_id()).await; + runtime + .reclaim_provisioning_timeout(&expired, &gate) + .await + .unwrap(); + } + let reclaimed = runtime + .store + .get_message::(original.object_id()) + .await + .unwrap() + .unwrap(); + assert!( + reclaimed + .status + .as_ref() + .unwrap() + .provisioning + .as_ref() + .unwrap() + .cleanup_completed_time + .is_some() + ); + let stopped = runtime + .stop_sandbox("default", original.object_name()) + .await + .unwrap(); + assert_eq!(stopped.phase(), SandboxPhase::Stopped as i32); + assert_eq!( + stopped.status.as_ref().unwrap().provisioning, + reclaimed.status.as_ref().unwrap().provisioning + ); + let corrected = runtime + .update_sandbox_image( + original.object_id(), + "example/workload:old".into(), + stopped.get_resource_version(), + ) + .await + .unwrap(); + assert_eq!( + corrected.status.as_ref().unwrap().image_revision, + upgraded.status.as_ref().unwrap().image_revision + 1 + ); + assert_eq!(corrected.object_id(), original.object_id()); + assert_eq!( + corrected.host_key_fingerprint, + original.host_key_fingerprint + ); + assert_eq!(corrected.spec, original.spec); + let retried = runtime + .start_sandbox("default", original.object_name()) + .await + .unwrap(); + assert_eq!(retried.phase(), SandboxPhase::Starting as i32); + assert!(!provisioning_deadline::timed_out(&retried)); + let calls = driver.calls(); + assert_eq!( + calls + .iter() + .filter(|call| matches!(call, FakeComputeDriverCall::StopSandbox { .. })) + .count(), + 1, + "only timeout reclamation stops the driver" + ); + assert_eq!( + calls + .iter() + .filter(|call| matches!(call, FakeComputeDriverCall::StartSandbox { .. })) + .count(), + 2 + ); + assert!(!calls.iter().any(|call| matches!( + call, + FakeComputeDriverCall::CreateSandbox { .. } + | FakeComputeDriverCall::DeleteSandbox { .. } + ))); + } + + #[tokio::test] + async fn interrupted_image_update_blocks_start_and_retries_the_same_operation() { + let (runtime, driver, original) = fixture(true).await; + driver.set_image_update_error(Some(Code::Unavailable)); + assert_eq!( + runtime + .update_sandbox_image( + original.object_id(), + "example/workload:new".into(), + original.get_resource_version() + ) + .await + .unwrap_err() + .code(), + Code::Unavailable + ); + let pending = runtime + .store + .get_message::(original.object_id()) + .await + .unwrap() + .unwrap(); + assert!(pending.status.as_ref().unwrap().image_update.is_some()); + assert_eq!( + runtime + .start_sandbox("default", original.object_name()) + .await + .unwrap_err() + .code(), + Code::FailedPrecondition + ); + assert_eq!( + runtime + .update_sandbox_image( + original.object_id(), + "example/workload:other".into(), + pending.get_resource_version() + ) + .await + .unwrap_err() + .code(), + Code::FailedPrecondition + ); + driver.set_image_update_error(None); + let complete = runtime + .update_sandbox_image( + original.object_id(), + "example/workload:new".into(), + pending.get_resource_version(), + ) + .await + .unwrap(); + assert!(complete.status.as_ref().unwrap().image_update.is_none()); + let calls = image_calls(&driver); + assert_eq!(calls.len(), 2); + assert_eq!(calls[0], calls[1]); + } + + #[test] + fn image_update_intent_survives_driver_status_replacement() { + let intent = SandboxImageUpdate { + operation_id: "operation".into(), + previous_image: "old".into(), + image: "new".into(), + revision: 1, + }; + let grant_failure = Box::new(openshell_core::proto::TokenGrantFailureObservation { + destination_host: "api.example.com".into(), + ..Default::default() + }); + let mut sandbox = Sandbox::default(); + sandbox.set_phase(SandboxPhase::Stopped as i32); + let status = sandbox.status.as_mut().unwrap(); + status.image_update = Some(intent.clone()); + status.image_revision = 1; + status.last_token_grant_failure = Some(grant_failure.clone()); + let incoming = DriverSandbox { + name: "test".into(), + status: Some(DriverSandboxStatus::default()), + ..Default::default() + }; + apply_driver_snapshot(&mut sandbox, &incoming, false, false); + assert_eq!( + sandbox.status.as_ref().unwrap().image_update.as_ref(), + Some(&intent) + ); + assert_eq!(sandbox.status.as_ref().unwrap().image_revision, 1); + assert_eq!( + sandbox.status.as_ref().unwrap().last_token_grant_failure, + Some(grant_failure) + ); + } +} diff --git a/crates/openshell-server/src/compute/mod.rs b/crates/openshell-server/src/compute/mod.rs index 3b9e541c65..23db3be484 100644 --- a/crates/openshell-server/src/compute/mod.rs +++ b/crates/openshell-server/src/compute/mod.rs @@ -4,6 +4,7 @@ //! Gateway-owned compute orchestration over a pluggable compute backend. pub mod driver_config; +mod image_update; pub mod lease; mod mutation_guard; pub mod provisioning_deadline; @@ -596,6 +597,17 @@ impl RemoteComputeDriver { #[tonic::async_trait] impl ComputeDriver for RemoteComputeDriver { + async fn update_sandbox_image( + &self, + request: Request, + ) -> Result< + tonic::Response, + Status, + > { + self.verify_admission_policy().await?; + self.client().update_sandbox_image(request).await + } + type WatchSandboxesStream = DriverWatchStream; async fn get_capabilities( @@ -1604,14 +1616,15 @@ impl ComputeRuntime { Some(guard) => guard, None => runtime.lock_sandbox_for_lifecycle(&lifecycle_guard).await, }; - runtime - .compensate_failed_create_inner( - &created, - lifecycle_guard, - sandbox_guard, - original, - ) - .await + // Keep compensation's future bounded as the persisted sandbox + // status grows (including image-update reconciliation state). + Box::pin(runtime.compensate_failed_create_inner( + &created, + lifecycle_guard, + sandbox_guard, + original, + )) + .await } .instrument(request_span), ) @@ -1796,12 +1809,22 @@ impl ComputeRuntime { return Ok(current); } let automatic_restart = is_automatic_restart_transition(¤t); - // Timeout cleanup owns reclamation while the record remains Error. - // Its later start may recreate missing compute; an ordinary stop must - // not replace that recovery state with Stopping or Stopped. - if phase == SandboxPhase::Error && provisioning_deadline::timed_out(¤t) { + // A timed-out attempt owns reclamation until both its driver work + // has settled (checked above) and cleanup has completed. Once those + // durable facts hold, explicit stop can expose a safe Stopped state + // for image repair without stopping/deleting retained compute again. + // Keep the timeout record: Start still needs its recovery provenance. + let reclaimed_timeout = + phase == SandboxPhase::Error && provisioning_deadline::timed_out(¤t); + if reclaimed_timeout + && current + .status + .as_ref() + .and_then(|status| status.provisioning.as_ref()) + .is_none_or(|record| record.cleanup_completed_time.is_none()) + { return Err(Status::failed_precondition( - "sandbox provisioning timed out; retry start after timeout cleanup completes", + "sandbox provisioning timed out; wait for timeout cleanup before stop or start", )); } // Error does not prove compute has stopped. Use the normal driver stop @@ -1823,18 +1846,28 @@ impl ComputeRuntime { break (current.clone(), current); } - match self - .write_lifecycle_phase( - ¤t, - SandboxPhase::Stopping, - "Stopping", - "Sandbox stop requested", + let (next_phase, reason, message) = if reclaimed_timeout { + ( + SandboxPhase::Stopped, + "StoppedAfterProvisioningTimeout", + "Timed-out compute has been reclaimed; sandbox stopped for repair", ) + } else { + (SandboxPhase::Stopping, "Stopping", "Sandbox stop requested") + }; + match self + .write_lifecycle_phase(¤t, next_phase, reason, message) .await { Ok(stopping) => { self.sandbox_index.update_from_sandbox(&stopping); self.sandbox_watch_bus.notify(&sandbox_id); + if reclaimed_timeout { + self.cleanup_stopped_sandbox_sessions(&stopping) + .await + .map_err(Status::internal)?; + return Ok(stopping); + } break (current, stopping); } Err(crate::persistence::PersistenceError::Conflict { .. }) @@ -1969,6 +2002,7 @@ impl ComputeRuntime { self.validate_launch_signer_configured(authority.is_some())?; } provisioning_operation::ensure_operation_settled(&candidate)?; + image_update::ensure_no_pending_image_update(&candidate)?; if provisioning_deadline::timed_out(&candidate) && candidate .status @@ -2006,6 +2040,7 @@ impl ComputeRuntime { let mut attempts = 0; let (previous, starting, launch_authentication) = loop { provisioning_operation::ensure_operation_settled(¤t)?; + image_update::ensure_no_pending_image_update(¤t)?; let phase = SandboxPhase::try_from(current.phase()).unwrap_or(SandboxPhase::Unknown); if phase == SandboxPhase::Ready { return Ok(current); @@ -6798,6 +6833,8 @@ fn public_status_from_driver( next_restart_time: None, main_process_started_time: None, last_token_grant_failure: None, + image_update: None, + image_revision: 0, } } @@ -6873,6 +6910,8 @@ fn apply_driver_snapshot( new_status.restart_count = old_status.restart_count; new_status.next_restart_time = old_status.next_restart_time; new_status.main_process_started_time = old_status.main_process_started_time; + new_status.image_update.clone_from(&old_status.image_update); + new_status.image_revision = old_status.image_revision; } phase = match old_phase { @@ -7470,6 +7509,18 @@ impl Default for NoopTestDriver { #[cfg(any(test, feature = "test-support"))] #[tonic::async_trait] impl ComputeDriver for NoopTestDriver { + async fn update_sandbox_image( + &self, + _request: Request, + ) -> Result< + tonic::Response, + Status, + > { + Err(Status::unimplemented( + "storage-preserving image updates are not supported by this driver", + )) + } + async fn authenticate_sandbox( &self, _request: Request, @@ -8094,6 +8145,18 @@ mod tests { #[tonic::async_trait] impl ComputeDriver for TestDriver { + async fn update_sandbox_image( + &self, + _request: Request, + ) -> Result< + tonic::Response, + Status, + > { + Err(Status::unimplemented( + "storage-preserving image updates are not supported by this driver", + )) + } + async fn authenticate_sandbox( &self, _request: Request, @@ -8512,6 +8575,18 @@ mod tests { #[tonic::async_trait] impl ComputeDriver for ControlledDriver { + async fn update_sandbox_image( + &self, + _request: Request, + ) -> Result< + tonic::Response, + Status, + > { + Err(Status::unimplemented( + "storage-preserving image updates are not supported by this driver", + )) + } + async fn authenticate_sandbox( &self, _request: Request, @@ -11776,6 +11851,18 @@ mod tests { #[tonic::async_trait] impl ComputeDriver for FailingDriver { + async fn update_sandbox_image( + &self, + _request: Request, + ) -> Result< + tonic::Response, + Status, + > { + Err(Status::unimplemented( + "storage-preserving image updates are not supported by this driver", + )) + } + async fn authenticate_sandbox( &self, _request: Request, @@ -14331,7 +14418,7 @@ mod tests { tokio::time::timeout( Duration::from_secs(1), - runtime.reconcile_store_with_backend(Duration::ZERO), + Box::pin(runtime.reconcile_store_with_backend(Duration::ZERO)), ) .await .expect("prune sweep blocked on the stuck driver delete call") diff --git a/crates/openshell-server/src/compute/tests/error_recovery.rs b/crates/openshell-server/src/compute/tests/error_recovery.rs index c6c2d45aee..48d16fcc25 100644 --- a/crates/openshell-server/src/compute/tests/error_recovery.rs +++ b/crates/openshell-server/src/compute/tests/error_recovery.rs @@ -152,6 +152,10 @@ async fn pending_driver_operation_blocks_error_recovery_without_mutation() { let runtime = test_runtime(driver.clone()).await; let mut sandbox = error_sandbox_record("pending-id", "pending", "StartFailed"); let mut operation = provisioning_deadline::new_record(openshell_core::time::now_ms()); + // Even a completion timestamp cannot override an unsettled original driver + // operation. This also fences malformed/stale timeout cleanup evidence. + operation.timeout_time = openshell_core::time::timestamp_from_millis(300_000).ok(); + operation.cleanup_completed_time = openshell_core::time::timestamp_from_millis(320_000).ok(); operation.driver_operation_pending = true; operation.driver_operation_id = "owned-operation".into(); sandbox.status.as_mut().unwrap().provisioning = Some(operation); @@ -188,14 +192,33 @@ async fn timeout_stop_preserves_cleanup_and_direct_start_recovery() { runtime.store.put_message(&sandbox).await.unwrap(); let before = stored(&runtime, sandbox.object_id()).await; - let error = runtime - .stop_sandbox("default", "timeout") - .await - .unwrap_err(); - assert_eq!(error.code(), Code::FailedPrecondition); - assert!(error.message().contains("start")); - assert_eq!(stored(&runtime, sandbox.object_id()).await, before); - assert_eq!(driver.stop_calls(), 0, "timeout cleanup owns reclamation"); + let stop = runtime.stop_sandbox("default", "timeout").await; + if cleanup_complete { + let stopped = stop.expect( + "completed timeout cleanup permits an explicit stopped state for image repair", + ); + assert_eq!(stopped.phase(), SandboxPhase::Stopped as i32); + assert_eq!(stopped.object_id(), before.object_id()); + assert_eq!(stopped.spec, before.spec); + assert_eq!( + stopped.status.as_ref().unwrap().provisioning, + before.status.as_ref().unwrap().provisioning + ); + let repeated = runtime.stop_sandbox("default", "timeout").await.unwrap(); + assert_eq!( + repeated, stopped, + "the retained stopped transition is idempotent" + ); + } else { + let error = stop.unwrap_err(); + assert_eq!(error.code(), Code::FailedPrecondition); + assert_eq!(stored(&runtime, sandbox.object_id()).await, before); + } + assert_eq!( + driver.stop_calls(), + 0, + "timeout cleanup already owns reclamation" + ); let result = runtime.start_sandbox("default", "timeout").await; if cleanup_complete { @@ -214,6 +237,35 @@ async fn timeout_stop_preserves_cleanup_and_direct_start_recovery() { } } +#[tokio::test] +async fn reclaimed_timeout_can_still_start_directly_without_stop() { + let driver = ControlledDriver::new(); + driver.set_start_outcome(ControlledLifecycleOutcome::NotFound); + driver.track_compute.store(true, Ordering::SeqCst); + let runtime = test_runtime(driver.clone()).await; + let mut sandbox = error_sandbox_record( + "direct-timeout-id", + "direct-timeout", + "ImagePreparationTimedOut", + ); + let mut operation = provisioning_deadline::new_record(0); + operation.timeout_time = openshell_core::time::timestamp_from_millis(300_000).ok(); + operation.cleanup_completed_time = openshell_core::time::timestamp_from_millis(320_000).ok(); + sandbox.status.as_mut().unwrap().provisioning = Some(operation); + runtime.store.put_message(&sandbox).await.unwrap(); + + let starting = runtime + .start_sandbox("default", "direct-timeout") + .await + .unwrap(); + assert_eq!(starting.phase(), SandboxPhase::Starting as i32); + assert_eq!(starting.object_id(), sandbox.object_id()); + assert!(driver.compute_exists.load(Ordering::SeqCst)); + assert_eq!(driver.start_calls(), 1); + assert_eq!(driver.stop_calls(), 0); + assert_eq!(driver.delete_calls(), 0); +} + #[tokio::test] async fn failed_error_stop_retains_retryable_state_without_claiming_success() { for observed_error in [false, true] { diff --git a/crates/openshell-server/src/grpc/mod.rs b/crates/openshell-server/src/grpc/mod.rs index eec85c3c5f..134b5c183a 100644 --- a/crates/openshell-server/src/grpc/mod.rs +++ b/crates/openshell-server/src/grpc/mod.rs @@ -320,6 +320,13 @@ impl OpenShell for OpenShellService { mutation_replay::run(&self.state, request).await } + async fn update_sandbox( + &self, + request: Request, + ) -> Result, Status> { + mutation_replay::run(&self.state, request).await + } + async fn begin_rootfs_tar_staging( &self, request: Request, diff --git a/crates/openshell-server/src/grpc/mutation_replay/ordinary.rs b/crates/openshell-server/src/grpc/mutation_replay/ordinary.rs index 25410043f6..c0a5887728 100644 --- a/crates/openshell-server/src/grpc/mutation_replay/ordinary.rs +++ b/crates/openshell-server/src/grpc/mutation_replay/ordinary.rs @@ -471,6 +471,11 @@ scoped_mutation!( }) } ); +sandbox_mutation!( + openshell_core::proto::UpdateSandboxRequest, + "UpdateSandbox", + sandbox::handle_update_sandbox +); sandbox_mutation!( StartSandboxRequest, "StartSandbox", diff --git a/crates/openshell-server/src/grpc/sandbox.rs b/crates/openshell-server/src/grpc/sandbox.rs index 463176fb65..a647859d50 100644 --- a/crates/openshell-server/src/grpc/sandbox.rs +++ b/crates/openshell-server/src/grpc/sandbox.rs @@ -309,6 +309,75 @@ pub(super) async fn handle_create_sandbox( result } +/// Only the workload image is mutable in the first update contract. Runtime +/// replacement is an explicit Stop/Update/Start workflow, never Delete/Create. +pub(super) async fn handle_update_sandbox( + state: &Arc, + request: Request, +) -> Result, Status> { + let principal = super::extract_principal(&request)?; + let request = request.into_inner(); + validate_image_update_request(&request)?; + let sandbox = resolve_and_authorize_sandbox_name( + state, + &principal, + &request.name, + crate::auth::workspace_authz::selected_workspace_name(request.workspace_scope.as_ref())?, + MinWorkspaceRole::User, + ) + .await?; + super::workspace::resolve_workspace(state.store.as_ref(), sandbox.object_workspace()) + .await? + .ensure_active()?; + let mut candidate = sandbox + .spec + .clone() + .ok_or_else(|| Status::failed_precondition("sandbox has no spec"))?; + candidate + .template + .get_or_insert_with(Default::default) + .image + .clone_from(&request.image); + validate_sandbox_spec(&request.name, &candidate)?; + let sandbox = state + .compute + .update_sandbox_image( + sandbox.object_id(), + request.image, + request.expected_resource_version, + ) + .await?; + Ok(Response::new(SandboxResponse { + sandbox: Some(sandbox), + service_urls: HashMap::new(), + })) +} + +fn validate_image_update_request( + request: &openshell_core::proto::UpdateSandboxRequest, +) -> Result<(), Status> { + if request.name.is_empty() { + return Err(Status::invalid_argument("name is required")); + } + if request.expected_resource_version == 0 { + return Err(Status::invalid_argument( + "expected_resource_version must be nonzero", + )); + } + if request.image.is_empty() + || request.image.len() > super::MAX_TEMPLATE_STRING_LEN + || request + .image + .chars() + .any(|character| character.is_whitespace() || character.is_control()) + { + return Err(Status::invalid_argument( + "image must be a nonempty bounded OCI reference without whitespace or control characters", + )); + } + Ok(()) +} + /// Allocate a gateway-owned staging slot for a local rootfs tar archive. /// /// The caller writes the archive to the returned path and then names the token @@ -10029,3 +10098,6 @@ mod tests { )); } } + +#[cfg(test)] +mod image_update_tests; diff --git a/crates/openshell-server/src/grpc/sandbox/image_update_tests.rs b/crates/openshell-server/src/grpc/sandbox/image_update_tests.rs new file mode 100644 index 0000000000..b45259c88b --- /dev/null +++ b/crates/openshell-server/src/grpc/sandbox/image_update_tests.rs @@ -0,0 +1,224 @@ +// SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +// SPDX-License-Identifier: Apache-2.0 + +use super::*; +use crate::grpc::test_support::{authed_request, test_server_state}; +use crate::test_support::{FakeComputeDriver, FakeComputeDriverCall}; +use openshell_core::proto::UpdateSandboxRequest; +use openshell_core::proto::compute::v1::GetCapabilitiesResponse; +use openshell_core::proto::datamodel::v1::ObjectMeta; +use tonic::Code; + +fn request() -> UpdateSandboxRequest { + UpdateSandboxRequest { + workspace_scope: Some(openshell_core::proto::workspace_selector("default")), + name: "image-update".into(), + image: "example/workload:new".into(), + expected_resource_version: 1, + request_id: String::new(), + } +} + +#[test] +fn image_only_request_requires_target_image_and_conditional_version() { + let valid = request(); + validate_image_update_request(&valid).unwrap(); + for image in ["", " ", "example/workload:tag\n", "bad image", "a\0b"] { + assert_eq!( + validate_image_update_request(&UpdateSandboxRequest { + image: image.into(), + ..valid.clone() + }) + .unwrap_err() + .code(), + Code::InvalidArgument + ); + } + assert!( + validate_image_update_request(&UpdateSandboxRequest { + image: "a".repeat(super::super::MAX_TEMPLATE_STRING_LEN + 1), + ..valid.clone() + }) + .is_err() + ); + assert!( + validate_image_update_request(&UpdateSandboxRequest { + name: String::new(), + ..valid.clone() + }) + .is_err() + ); + assert!( + validate_image_update_request(&UpdateSandboxRequest { + expected_resource_version: 0, + ..valid + }) + .is_err() + ); +} + +async fn state() -> (Arc, Arc, Sandbox) { + let mut state = test_server_state().await; + let driver = Arc::new( + FakeComputeDriver::new().with_capabilities(GetCapabilitiesResponse { + driver_name: "image-test".into(), + default_image: "example/workload:old".into(), + extension: Some(openshell_core::extension_protocol::extension_metadata( + openshell_core::extension_protocol::ExtensionFamily::Compute, + "openshell/image-test", + "test", + [openshell_core::extension_protocol::COMPUTE_UPDATE_SANDBOX_IMAGE.into()], + )), + ..Default::default() + }), + ); + let compute = crate::compute::ComputeRuntime::from_driver( + "image-test".into(), + driver.clone(), + None, + state.store.clone(), + crate::sandbox_index::SandboxIndex::new(), + crate::sandbox_watch::SandboxWatchBus::new(), + crate::tracing_bus::TracingLogBus::new(), + Arc::new(crate::supervisor_session::SupervisorSessionRegistry::new()), + ) + .await + .unwrap(); + Arc::get_mut(&mut state).unwrap().compute = compute; + let mut sandbox = Sandbox { + metadata: Some(ObjectMeta { + id: "stable-sandbox-id".into(), + name: "image-update".into(), + workspace: "default".into(), + ..Default::default() + }), + spec: Some(SandboxSpec { + template: Some(SandboxTemplate { + image: "example/workload:old".into(), + ..Default::default() + }), + ..Default::default() + }), + ..Default::default() + }; + sandbox.set_phase(SandboxPhase::Stopped as i32); + state.store.put_message(&sandbox).await.unwrap(); + let sandbox = state + .store + .get_message::(sandbox.object_id()) + .await + .unwrap() + .unwrap(); + (state, driver, sandbox) +} + +#[tokio::test] +async fn public_image_update_checks_workspace_and_missing_resource() { + let (state, driver, sandbox) = state().await; + let mut req = request(); + req.expected_resource_version = sandbox.get_resource_version(); + req.workspace_scope = None; + assert_eq!( + handle_update_sandbox(&state, authed_request(req.clone())) + .await + .unwrap_err() + .code(), + Code::InvalidArgument + ); + req.workspace_scope = Some(openshell_core::proto::workspace_selector("default")); + req.name = "missing-sandbox".into(); + assert_eq!( + handle_update_sandbox(&state, authed_request(req)) + .await + .unwrap_err() + .code(), + Code::NotFound + ); + assert!( + !driver + .calls() + .iter() + .any(|call| matches!(call, FakeComputeDriverCall::UpdateSandboxImage { .. })) + ); +} + +#[tokio::test] +async fn public_image_update_replays_without_reapplying_or_touching_same_name_replacement() { + let (mut state, driver, sandbox) = state().await; + let directory = tempfile::tempdir().unwrap(); + let key = directory.path().join("private-key"); + std::fs::write(&key, b"test-only stable private fingerprint material").unwrap(); + Arc::get_mut(&mut state).unwrap().config.gateway_jwt = + Some(openshell_core::config::GatewayJwtConfig { + signing_key_path: key, + public_key_path: directory.path().join("public"), + kid_path: directory.path().join("kid"), + gateway_id: "test".into(), + ttl_secs: None, + }); + let req = UpdateSandboxRequest { + expected_resource_version: sandbox.get_resource_version(), + request_id: uuid::Uuid::new_v4().to_string(), + ..request() + }; + let updated = super::super::mutation_replay::run(&state, authed_request(req.clone())) + .await + .unwrap() + .into_inner() + .sandbox + .unwrap(); + assert_eq!(updated.object_id(), sandbox.object_id()); + assert_eq!( + updated + .spec + .as_ref() + .unwrap() + .template + .as_ref() + .unwrap() + .image, + req.image + ); + let replay = super::super::mutation_replay::run(&state, authed_request(req.clone())) + .await + .unwrap(); + assert_eq!(replay.metadata().get("openshell-replayed").unwrap(), "true"); + assert_eq!(replay.get_ref().sandbox.as_ref().unwrap(), &updated); + assert_eq!(driver.calls().iter().filter(|call| matches!(call, FakeComputeDriverCall::UpdateSandboxImage { request } if !request.validate_only)).count(), 1); + let changed = UpdateSandboxRequest { + image: "example/workload:other".into(), + ..req.clone() + }; + assert_eq!( + super::super::mutation_replay::run(&state, authed_request(changed)) + .await + .unwrap_err() + .code(), + Code::FailedPrecondition + ); + state + .store + .delete(Sandbox::object_type(), sandbox.object_id()) + .await + .unwrap(); + let mut replacement = sandbox.clone(); + let metadata = replacement.metadata.as_mut().unwrap(); + metadata.id = "replacement-sandbox-id".into(); + metadata.resource_version = 0; + state.store.put_message(&replacement).await.unwrap(); + assert_eq!( + super::super::mutation_replay::run(&state, authed_request(req)) + .await + .unwrap_err() + .code(), + Code::FailedPrecondition + ); + let replacement = state + .store + .get_message::(replacement.object_id()) + .await + .unwrap() + .unwrap(); + assert_eq!(replacement.spec, sandbox.spec); + assert_eq!(driver.calls().iter().filter(|call| matches!(call, FakeComputeDriverCall::UpdateSandboxImage { request } if !request.validate_only)).count(), 1); +} diff --git a/crates/openshell-server/src/storage_proto.rs b/crates/openshell-server/src/storage_proto.rs index 7490513692..90ad3a443c 100644 --- a/crates/openshell-server/src/storage_proto.rs +++ b/crates/openshell-server/src/storage_proto.rs @@ -154,12 +154,16 @@ mod tests { // Sandbox-wide grant reporting adds TokenGrantFailureObservation to both // closures and TokenGrantStatus to public reports. Older rows have no grant // record; absent report extensions retain compatibility without a rewrite. + // Image updates add a public-only request and a durable optional pending + // intent plus monotonic image revision. Their new fields follow the existing + // token-grant observation without reusing its wire tag. Legacy sandboxes + // decode absent/zero; revisions fence delayed driver retries after success. const PUBLIC_RPC_SCHEMA_SHA256: &str = - "cc06b38c9ecb4c6518e0d4963f40c4f16f992483ce111c7b23cbcb729db946ea"; + "2d82067143395b08928e848832111370d56fa4c6e3691f0fa1d2dc32928832aa"; const DURABLE_SCHEMA_SHA256: &str = - "d4dc7abdb91b919db1f7be0d4652e30cbfda86f3b2ed9b59d5de1f76a2bf691d"; + "f435fc91632084aef0eb17958fc963f4a90f2f0b54f4de67042b33bb9cbfd135"; const PUBLIC_DURABLE_OVERLAP_SHA256: &str = - "ac1ffc4b5b81467de27270a4e33f6db1e31eeb2c52f79750dbaaf19515eadbb2"; + "9997e51420f29542cefd99d394e211a8e5a21967f4f0fb9ac94aaf598a821b11"; // Encoded with the schema that omitted stable_placeholder. Keep these // bytes fixed so the current encoder cannot hide a compatibility change. const LEGACY_STATIC_PROFILE: &str = "0a240a116c65676163792d70726f66696c652d6964120d6c65676163792d737461746963280712510a0d6c65676163792d73746174696312184c6567616379207374617469632063726564656e7469616c2a260a076170695f6b65791a1153594e5448455449435f4150495f4b455920012a06626561726572"; @@ -603,7 +607,7 @@ mod tests { } assert_eq!( compiled_method_count, - 103 + PROVIDER_READINESS_RPC_SIGNATURES.len() + 105 + PROVIDER_READINESS_RPC_SIGNATURES.len() + PEER_OWNER_RPC_SIGNATURES.len() + isolation_methods.len() + sandbox_protocol_methods.len(), @@ -611,7 +615,7 @@ mod tests { ); assert_eq!( methods.len(), - 78 + PROVIDER_READINESS_RPC_SIGNATURES.len() + PEER_OWNER_RPC_SIGNATURES.len(), + 79 + PROVIDER_READINESS_RPC_SIGNATURES.len() + PEER_OWNER_RPC_SIGNATURES.len(), "inventory every public gateway RPC" ); assert_eq!( @@ -619,7 +623,7 @@ mod tests { .iter() .filter(|method| method.starts_with("openshell.v1.OpenShell/")) .count(), - 78 + PROVIDER_READINESS_RPC_SIGNATURES.len() + PEER_OWNER_RPC_SIGNATURES.len() + 79 + PROVIDER_READINESS_RPC_SIGNATURES.len() + PEER_OWNER_RPC_SIGNATURES.len() ); assert!(methods.iter().all(|method| !method.contains(".storage."))); @@ -663,9 +667,9 @@ mod tests { overlap_hash.as_str(), ), ( - (314, 28), - (95, 22), - (83, 22), + (316, 28), + (96, 22), + (84, 22), PUBLIC_RPC_SCHEMA_SHA256, DURABLE_SCHEMA_SHA256, PUBLIC_DURABLE_OVERLAP_SHA256 @@ -674,6 +678,17 @@ mod tests { ); } + #[test] + fn pre_image_update_sandbox_has_no_pending_image_intent() { + let sandbox = openshell_core::proto::Sandbox::decode( + legacy_bytes(SANDBOX_WITHOUT_ENDPOINT_STATUS).as_slice(), + ) + .expect("legacy sandbox must remain decodable"); + let status = sandbox.status.unwrap(); + assert!(status.image_update.is_none()); + assert_eq!(status.image_revision, 0); + } + #[test] fn service_endpoint_without_authorization_mode_decodes_as_strip() { use openshell_core::proto::{ServiceAuthorizationMode, ServiceEndpoint}; diff --git a/crates/openshell-server/src/test_support.rs b/crates/openshell-server/src/test_support.rs index 5aa4a70f5c..94905e3956 100644 --- a/crates/openshell-server/src/test_support.rs +++ b/crates/openshell-server/src/test_support.rs @@ -105,6 +105,9 @@ pub enum FakeComputeDriverCall { CreateSandbox { sandbox: Option, }, + UpdateSandboxImage { + request: openshell_core::proto::compute::v1::UpdateSandboxImageRequest, + }, StopSandbox { sandbox_id: String, sandbox_name: String, @@ -133,6 +136,8 @@ struct FakeComputeDriverState { sandboxes: HashMap, calls: Vec, traceparents: Vec, + image_update_error: Option, + image_validation_error: Option, } impl Default for FakeComputeDriver { @@ -176,6 +181,8 @@ impl FakeComputeDriver { sandboxes: HashMap::new(), calls: Vec::new(), traceparents: Vec::new(), + image_update_error: None, + image_validation_error: None, })), } } @@ -253,6 +260,14 @@ impl FakeComputeDriver { Ok(FakeComputeDriverServerHandle { socket_path, task }) } + pub fn set_image_update_error(&self, code: Option) { + self.with_state(|state| state.image_update_error = code); + } + + pub fn set_image_validation_error(&self, code: Option) { + self.with_state(|state| state.image_validation_error = code); + } + fn with_state(&self, f: impl FnOnce(&mut FakeComputeDriverState) -> R) -> R { let mut state = self .state @@ -305,6 +320,30 @@ impl Stream for UnixIncoming { #[tonic::async_trait] impl ComputeDriver for FakeComputeDriver { + async fn update_sandbox_image( + &self, + request: Request, + ) -> Result, Status> + { + self.record_traceparent(request.metadata()); + self.with_state(|state| { + let request = request.into_inner(); + let validate_only = request.validate_only; + state + .calls + .push(FakeComputeDriverCall::UpdateSandboxImage { request }); + if let Some(code) = state.image_validation_error.filter(|_| validate_only) { + return Err(Status::new(code, "injected image validation error")); + } + if let Some(code) = state.image_update_error.filter(|_| !validate_only) { + return Err(Status::new(code, "injected image update error")); + } + Ok(Response::new( + openshell_core::proto::compute::v1::UpdateSandboxImageResponse {}, + )) + }) + } + async fn authenticate_sandbox( &self, _request: Request, diff --git a/crates/openshell-server/tests/common/mod.rs b/crates/openshell-server/tests/common/mod.rs index 146169d7ba..8de7e9c848 100644 --- a/crates/openshell-server/tests/common/mod.rs +++ b/crates/openshell-server/tests/common/mod.rs @@ -53,6 +53,13 @@ pub struct TestOpenShell; #[tonic::async_trait] impl OpenShell for TestOpenShell { + async fn update_sandbox( + &self, + _request: tonic::Request, + ) -> Result, Status> { + Err(Status::unimplemented("not implemented by test service")) + } + async fn peer_report_provider_readiness( &self, _request: tonic::Request, diff --git a/crates/openshell-server/tests/supervisor_relay_integration.rs b/crates/openshell-server/tests/supervisor_relay_integration.rs index dfb89f18c3..824b7b9595 100644 --- a/crates/openshell-server/tests/supervisor_relay_integration.rs +++ b/crates/openshell-server/tests/supervisor_relay_integration.rs @@ -50,6 +50,13 @@ struct RelayGateway { #[tonic::async_trait] impl OpenShell for RelayGateway { + async fn update_sandbox( + &self, + _request: tonic::Request, + ) -> Result, Status> { + Err(Status::unimplemented("not implemented by test service")) + } + async fn peer_report_provider_readiness( &self, _request: tonic::Request, diff --git a/docs/how-it-works/sandboxes/overview.mdx b/docs/how-it-works/sandboxes/overview.mdx index 5a84718039..8fe0518604 100644 --- a/docs/how-it-works/sandboxes/overview.mdx +++ b/docs/how-it-works/sandboxes/overview.mdx @@ -1003,6 +1003,54 @@ If an infrastructure failure leaves a sandbox in `Error`, fix the reported cause For a provisioning timeout, wait for cleanup to finish, then run `sandbox start` directly. +### Update the Image of a Stopped Sandbox + +Use the raw `UpdateSandbox` RPC to change only a stopped sandbox's workload +image. This operation initially supports the Kubernetes compute driver only; +other drivers return `UNIMPLEMENTED`. There is no `sandbox update` CLI command +or curated SDK update method. + +The update preserves the sandbox ID, Kubernetes custom resource, and persistent +volume claim. It does not delete and recreate the sandbox, reseed its existing +workspace from the new image, or change the trusted supervisor and sandbox +runtime images. Other create-time configuration remains unchanged. Submitting the +same image reference is a no-op; use a different tag or an immutable digest to +select new image content. + +Follow this sequence through the CLI and a generated/raw RPC client. + +1. Run `openshell sandbox stop my-sandbox` and wait for `Stopped`. +2. Call `GetSandbox` with the named `workspace_scope` and sandbox `name`. Read + `sandbox.metadata.resource_version` after stop completes. +3. Call `UpdateSandbox` with the same scope and name, the nonempty OCI workload + `image`, and `expected_resource_version` set to that current, nonzero + version. The response is a `SandboxResponse`; the sandbox remains stopped. +4. After the update succeeds, run `openshell sandbox start my-sandbox` to launch + the new image. + +If the new image fails to start and provisioning times out, wait until +`provisioning.cleanup_completed_time` is present and +`provisioning.driver_operation_pending` is false. Run `sandbox stop` to move the +reclaimed sandbox from `Error` to `Stopped`, then repeat the update sequence with +a working image. Stop retains the timeout record and storage; it does not stop +compute again. Cleanup that is still pending cannot be bypassed. + +An `ABORTED` version conflict requires another read before you construct a new +conditional request. An update failure or disconnected response can leave a +persistent `sandbox.status.image_update` intent, even when +`sandbox.spec.template.image` already names the target image. While that intent +exists, start is blocked. Read the current version and retry `UpdateSandbox` +with the intent's same `image`; do not select a different image or delete the +sandbox to bypass reconciliation. Only a successful retry clears the intent. + +The optional `request_id` uses [durable request admission](/sdk/api-errors#durable-request-admission). +A retry with the same ID must keep the original payload, including its expected +version. An unresolved admission returns `REQUEST_OUTCOME_UNCERTAIN` rather than +executing again. Reconcile the sandbox and pending target first, then submit a +new conditional same-image request with a fresh version and a new ID, or no ID. +Do not change the expected version under the original ID or blindly switch IDs +after a timeout. + ## Delete Sandboxes Deleting a sandbox stops all processes, releases resources, and purges injected credentials. diff --git a/docs/sdk/api-errors.mdx b/docs/sdk/api-errors.mdx index 23a34c3b96..592cebbe2f 100644 --- a/docs/sdk/api-errors.mdx +++ b/docs/sdk/api-errors.mdx @@ -56,7 +56,7 @@ guarantee. | `ABORTED` | Read fresh state before retrying a conditional operation. | | `UNAVAILABLE`, `RESOURCE_EXHAUSTED` | A transient condition may recover. Apply backoff and any minimum retry delay only to a retry-safe operation. | | `DEADLINE_EXCEEDED`, `CANCELLED` | A mutation's outcome can be unknown. Cancellation does not imply rollback. | -| `UNIMPLEMENTED` | Check gateway and SDK version compatibility. | +| `UNIMPLEMENTED` | Check gateway and SDK version compatibility and whether the compute driver supports the operation. | | `INTERNAL`, `UNKNOWN`, `DATA_LOSS` | Preserve the status and correlation metadata for diagnosis. Do not blindly retry mutations. | ## SDK access @@ -92,14 +92,14 @@ No SDK automatically retries a mutation as a result of decoding these details. ## Durable request admission -Thirty user-callable unary RPCs accept an optional `request_id` in their protobuf requests. +Thirty-one user-callable unary RPCs accept an optional `request_id` in their protobuf requests. | Resource | RPCs | |---|---| | Workspace | `CreateWorkspace`, `DeleteWorkspace` | | Workspace member | `AddWorkspaceMember`, `RemoveWorkspaceMember` | | Sandbox template | `CreateSandboxTemplate`, `DeleteSandboxTemplate` | -| Sandbox | `CreateSandbox`, `DeleteSandbox`, `StartSandbox`, `StopSandbox`, `AttachSandboxProvider`, `DetachSandboxProvider` | +| Sandbox | `CreateSandbox`, `UpdateSandbox`, `DeleteSandbox`, `StartSandbox`, `StopSandbox`, `AttachSandboxProvider`, `DetachSandboxProvider` | | Service | `ExposeService`, `DeleteService` | | Provider | `CreateProvider`, `UpdateProvider`, `DeleteProvider`, `ConfigureProviderRefresh`, `DeleteProviderRefresh`, `RotateProviderCredential` | | Provider profile | `ImportProviderProfiles`, `UpdateProviderProfiles`, `DeleteProviderProfile` | @@ -192,6 +192,33 @@ from this feature. Sandbox principals cannot opt into `UpdateConfig` admission. Check gateway compatibility before relying on IDs; older protobuf servers can silently ignore unknown fields. +### Sandbox image update recovery + +`UpdateSandbox` is an image-only conditional mutation for stopped Kubernetes +sandboxes. Other compute drivers return `UNIMPLEMENTED`. Supply a named +`workspace_scope`, sandbox `name`, nonempty OCI `image`, and a required nonzero +`expected_resource_version` read from `sandbox.metadata.resource_version`. +A stale version returns `ABORTED`; read fresh state before constructing another +conditional request. The operation does not start compute. + +A failed or interrupted update can leave durable `sandbox.status.image_update` +state. The desired spec image alone does not prove driver reconciliation +completed. Start returns `FAILED_PRECONDITION` until you successfully retry the +same pending image using the current resource version. A different target image +cannot replace a pending update. + +If the original request supplied `request_id`, an error leaves its admission +unresolved. Reusing that ID with the original payload returns +`REQUEST_OUTCOME_UNCERTAIN`; changing its expected version returns +`REQUEST_ID_PAYLOAD_MISMATCH`. Inspect and reconcile the pending image first, +then make a new conditional same-image request with the fresh version and a new +ID, or without an ID. This is explicit recovery, not permission to blindly +repeat uncertain mutations. A replay of a confirmed success returns the +sandbox's current state without applying the image again. + +See [Update the Image of a Stopped Sandbox](/how-it-works/sandboxes/overview#update-the-image-of-a-stopped-sandbox) +for the stop, update, and start workflow and storage guarantees. + ## Exec launch admission `ExecSandbox` and `ExecSandboxInteractive` accept an optional `request_id` in diff --git a/e2e/rust/Cargo.lock b/e2e/rust/Cargo.lock index b5403e2ac3..03a449da1d 100644 --- a/e2e/rust/Cargo.lock +++ b/e2e/rust/Cargo.lock @@ -2,12 +2,67 @@ # It is not intended for manual editing. version = 4 +[[package]] +name = "addr2line" +version = "0.25.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1b5d307320b3181d6d7954e663bd7c774a838b8220fe0593c86d9fb09f498b4b" +dependencies = [ + "gimli", +] + +[[package]] +name = "adler2" +version = "2.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa" + +[[package]] +name = "aho-corasick" +version = "1.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c982642fa9e8606056828ee9a8505737230110bb1099153c79efe865c59d12ba" +dependencies = [ + "memchr", +] + +[[package]] +name = "android_system_properties" +version = "0.1.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ae221649c9976a6f6c56ae1facf410f3ddb33cc661c4b7b61020a912d4237fbc" +dependencies = [ + "libc", +] + [[package]] name = "anyhow" version = "1.0.104" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "330a5ed07fa54e4702c9d6c4174f74427fc0ef6e214bbd677ae50a5099946470" +[[package]] +name = "async-stream" +version = "0.3.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0b5a71a6f37880a80d1d7f19efd781e4b5de42c88f0722cc13bcb6cc2cfe8476" +dependencies = [ + "async-stream-impl", + "futures-core", + "pin-project-lite", +] + +[[package]] +name = "async-stream-impl" +version = "0.3.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c7c24de15d275a1ecfd47a380fb4d5ec9bfe0933f309ed5e705b775596a3574d" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.119", +] + [[package]] name = "async-trait" version = "0.1.91" @@ -98,6 +153,30 @@ dependencies = [ "tower-service", ] +[[package]] +name = "backtrace" +version = "0.3.76" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bb531853791a215d7c62a30daf0dde835f381ab5de4589cfe7c649d2cbe92bd6" +dependencies = [ + "addr2line", + "cfg-if", + "libc", + "miniz_oxide", + "object", + "rustc-demangle", + "windows-link", +] + +[[package]] +name = "backtrace-ext" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "537beee3be4a18fb023b570f80e3ae28003db9167a751266b259926e25539d50" +dependencies = [ + "backtrace", +] + [[package]] name = "base64" version = "0.22.1" @@ -143,7 +222,7 @@ dependencies = [ "serde_derive", "serde_json", "serde_urlencoded", - "thiserror", + "thiserror 2.0.19", "tokio", "tokio-util", "tower-service", @@ -198,6 +277,20 @@ version = "0.2.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "f079e83a288787bcd14a6aea84cee5c87a67c5a3e660c30f557a3d24761b3527" +[[package]] +name = "chrono" +version = "0.4.45" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1aa79e62e7697b8e29b513a68abacf485adcd1fe8284a4316c5ae868e6633327" +dependencies = [ + "iana-time-zone", + "js-sys", + "num-traits", + "serde", + "wasm-bindgen", + "windows-link", +] + [[package]] name = "cmake" version = "0.1.58" @@ -207,6 +300,22 @@ dependencies = [ "cc", ] +[[package]] +name = "core-foundation" +version = "0.10.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b2a6cd9ae233e7f62ba4e9353e81a88df7fc8a5987b8d445b4d90c879bd156f6" +dependencies = [ + "core-foundation-sys", + "libc", +] + +[[package]] +name = "core-foundation-sys" +version = "0.8.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b" + [[package]] name = "cpufeatures" version = "0.2.17" @@ -226,6 +335,12 @@ dependencies = [ "typenum", ] +[[package]] +name = "data-encoding" +version = "2.11.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4583a4551df46e2792f82ceeac45e850d2e2d5debba0b91f102385cda5b11f06" + [[package]] name = "deranged" version = "0.5.8" @@ -293,12 +408,24 @@ version = "0.1.9" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "5baebc0774151f905a1a2cc41989300b1e6fbb29aff0ceffa1064fdd3088d582" +[[package]] +name = "fixedbitset" +version = "0.5.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1d674e81391d1e1ab681a28d99df07927c6d4aa5b027d7da16ba32d1d21ecd99" + [[package]] name = "fnv" version = "1.0.7" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1" +[[package]] +name = "foldhash" +version = "0.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d9c4f5dac5e15c24eb999c26181a6ca40b39fe946cbe4c263c7209467bc83af2" + [[package]] name = "form_urlencoded" version = "1.2.2" @@ -314,6 +441,21 @@ version = "1.3.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "42703706b716c37f96a77aea830392ad231f44c9e9a67872fa5548707e11b11c" +[[package]] +name = "futures" +version = "0.3.33" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a88cf1f829d945f548cf8fec32c61b1f202b6d93b45848602fc02af4b12ad218" +dependencies = [ + "futures-channel", + "futures-core", + "futures-executor", + "futures-io", + "futures-sink", + "futures-task", + "futures-util", +] + [[package]] name = "futures-channel" version = "0.3.33" @@ -321,6 +463,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "262590f4fe6afeb0bc83be1daa64e52657fe185690a958af7f3ad0e92085c5ae" dependencies = [ "futures-core", + "futures-sink", ] [[package]] @@ -340,6 +483,12 @@ dependencies = [ "futures-util", ] +[[package]] +name = "futures-io" +version = "0.3.34" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "53c0fa8157de1303bfffdaa1cc2a673bfffb60102f76b0ef4441659124373fed" + [[package]] name = "futures-macro" version = "0.3.33" @@ -369,9 +518,13 @@ version = "0.3.33" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "a77a90a256fce34da66415271e30f94ee91c57b04b8a2c042d9cf3220179deaa" dependencies = [ + "futures-channel", "futures-core", + "futures-io", "futures-macro", + "futures-sink", "futures-task", + "memchr", "pin-project-lite", "slab", ] @@ -393,8 +546,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ff2abc00be7fca6ebc474524697ae276ad847ad0a6b3faa4bcb027e9a4614ad0" dependencies = [ "cfg-if", + "js-sys", "libc", "wasi", + "wasm-bindgen", ] [[package]] @@ -420,6 +575,18 @@ dependencies = [ "r-efi 6.0.0", ] +[[package]] +name = "gimli" +version = "0.32.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e629b9b98ef3dd8afe6ca2bd0f89306cec16d43d907889945bc5d6687f2f13c7" + +[[package]] +name = "glob" +version = "0.3.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e4eba85ea1d0a966a983acd07deee566e67395d2d96b6fb39e62b5a833f1eb0b" + [[package]] name = "h2" version = "0.4.15" @@ -439,12 +606,27 @@ dependencies = [ "tracing", ] +[[package]] +name = "hashbrown" +version = "0.15.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9229cfe53dfd69f0609a49f65461bd93001ea1ef889cd5529dd176593f5338a1" +dependencies = [ + "foldhash", +] + [[package]] name = "hashbrown" version = "0.17.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ed5909b6e89a2db4456e54cd5f673791d7eca6732202bbf2a9cc504fe2f9b84a" +[[package]] +name = "heck" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea" + [[package]] name = "hex" version = "0.4.3" @@ -532,6 +714,22 @@ dependencies = [ "tower-service", ] +[[package]] +name = "hyper-rustls" +version = "0.27.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dfa8e654703247911e29c23fbeaa261834bd9bb74efba2f9acddc37bfb127f53" +dependencies = [ + "http", + "hyper", + "hyper-util", + "rustls", + "rustls-native-certs", + "tokio", + "tokio-rustls", + "tower-service", +] + [[package]] name = "hyper-timeout" version = "0.5.2" @@ -551,13 +749,16 @@ version = "0.1.20" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "96547c2556ec9d12fb1578c4eaf448b04993e7fb79cbaad930a656880a6bdfa0" dependencies = [ + "base64", "bytes", "futures-channel", "futures-util", "http", "http-body", "hyper", + "ipnet", "libc", + "percent-encoding", "pin-project-lite", "socket2", "tokio", @@ -580,11 +781,35 @@ dependencies = [ "tower-service", ] +[[package]] +name = "iana-time-zone" +version = "0.1.65" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e31bc9ad994ba00e440a8aa5c9ef0ec67d5cb5e5cb0cc7f8b744a35b389cc470" +dependencies = [ + "android_system_properties", + "core-foundation-sys", + "iana-time-zone-haiku", + "js-sys", + "log", + "wasm-bindgen", + "windows-core", +] + +[[package]] +name = "iana-time-zone-haiku" +version = "0.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f31827a206f56af32e590ba56d5d2d085f558508192593743f16b2306495269f" +dependencies = [ + "cc", +] + [[package]] name = "icu_collections" -version = "2.2.0" +version = "2.3.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2984d1cd16c883d7935b9e07e44071dca8d917fd52ecc02c04d5fa0b5a3f191c" +checksum = "fa68d21081c4a05d5a901a1c62add574c77048b6a1c67be3b50ce0b60d4ca513" dependencies = [ "displaydoc", "potential_utf", @@ -596,22 +821,43 @@ dependencies = [ [[package]] name = "icu_locale_core" -version = "2.2.0" +version = "2.3.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "92219b62b3e2b4d88ac5119f8904c10f8f61bf7e95b640d25ba3075e6cac2c29" +checksum = "d56e28588da92eee5c3201a6eff33fabdd49b62269c8938d4ff050ce4d900deb" dependencies = [ "displaydoc", "litemap", + "serde", "tinystr", "writeable", "zerovec", ] +[[package]] +name = "icu_locale_fallback" +version = "2.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "251af8e57c9400e3eb58242fe5b8b1152b2a64fdf4cf632f923c38ccee6f2fa9" +dependencies = [ + "icu_locale_core", + "icu_locale_fallback_data", + "icu_provider", + "potential_utf", + "tinystr", + "zerovec", +] + +[[package]] +name = "icu_locale_fallback_data" +version = "2.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "decf2a22ec8fa68f1a0c1129a3f8583f8f8bc24e8b9ccbe98ead99f62a4dc3a8" + [[package]] name = "icu_normalizer" -version = "2.2.0" +version = "2.3.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c56e5ee99d6e3d33bd91c5d85458b6005a22140021cc324cea84dd0e72cff3b4" +checksum = "12f9cf5f235641ed274641dd81c3f28d870e276763d0797aeeab72317b1c646f" dependencies = [ "icu_collections", "icu_normalizer_data", @@ -623,16 +869,17 @@ dependencies = [ [[package]] name = "icu_normalizer_data" -version = "2.2.0" +version = "2.3.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "da3be0ae77ea334f4da67c12f149704f19f81d1adf7c51cf482943e84a2bad38" +checksum = "1563da1ed3e0b3bf3d74c9b85917ac9c56464d2f57242270c09c9e752f8021a0" [[package]] name = "icu_properties" -version = "2.2.0" +version = "2.3.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bee3b67d0ea5c2cca5003417989af8996f8604e34fb9ddf96208a033901e70de" +checksum = "7e7ca276ad3145661a65914e6daf131ca5120cd3dcee8f8f3214b8875184a148" dependencies = [ + "displaydoc", "icu_collections", "icu_locale_core", "icu_properties_data", @@ -643,18 +890,20 @@ dependencies = [ [[package]] name = "icu_properties_data" -version = "2.2.0" +version = "2.3.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8e2bbb201e0c04f7b4b3e14382af113e17ba4f63e2c9d2ee626b720cbce54a14" +checksum = "e590f038c1464a96894fd6d10127e90a8be4509f56ff7ecef851b15cee0b7caa" [[package]] name = "icu_provider" -version = "2.2.0" +version = "2.3.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "139c4cf31c8b5f33d7e199446eff9c1e02decfc2f0eec2c8d71f65befa45b421" +checksum = "d27bbb9d3abbefac45d55f647c9de1d44aafcd1186eb91879afef17c396c3e73" dependencies = [ "displaydoc", "icu_locale_core", + "serde", + "stable_deref_trait", "writeable", "yoke", "zerofrom", @@ -662,6 +911,28 @@ dependencies = [ "zerovec", ] +[[package]] +name = "icu_segmenter" +version = "2.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "82d07aafccd67af15d02512a6adf5896fbc5ed00f2e99b471d2efa14016db3db" +dependencies = [ + "icu_collections", + "icu_locale_fallback", + "icu_provider", + "icu_segmenter_data", + "potential_utf", + "smallvec", + "utf8_iter", + "zerovec", +] + +[[package]] +name = "icu_segmenter_data" +version = "2.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ae293c039020f9ec10710af98d29ce6aa2051486638b49c9a6409f3b4a9e98ad" + [[package]] name = "idna" version = "1.1.0" @@ -690,11 +961,23 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d466e9454f08e4a911e14806c24e16fba1b4c121d1ea474396f396069cf949d9" dependencies = [ "equivalent", - "hashbrown", + "hashbrown 0.17.1", "serde", "serde_core", ] +[[package]] +name = "ipnet" +version = "2.12.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "791930b43c0d5973160d90a8f3894509f2b273430f5c5c73b668636d0287c5c0" + +[[package]] +name = "is_ci" +version = "1.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7655c9839580ee829dfacba1d1278c2b7883e50a277ff7541299489d6bdfdc45" + [[package]] name = "itertools" version = "0.14.0" @@ -800,12 +1083,51 @@ version = "2.8.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "cf8baf1c55e62ffcace7a9f06f4bd9cd3f0c4beb022d3b367256b91b87513d98" +[[package]] +name = "miette" +version = "7.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5f98efec8807c63c752b5bd61f862c165c115b0a35685bdcfd9238c7aeb592b7" +dependencies = [ + "backtrace", + "backtrace-ext", + "cfg-if", + "miette-derive", + "owo-colors", + "supports-color", + "supports-hyperlinks", + "supports-unicode", + "terminal_size", + "textwrap", + "unicode-width 0.1.14", +] + +[[package]] +name = "miette-derive" +version = "7.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "db5b29714e950dbb20d5e6f74f9dcec4edbcc1067bb7f8ed198c097b8c1a818b" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.119", +] + [[package]] name = "mime" version = "0.3.17" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "6877bb514081ee2a7ff5ef9de3281f14a4dd4bceac4c09388074a6b5df8a139a" +[[package]] +name = "miniz_oxide" +version = "0.8.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1fa76a2c86f704bdb222d66965fb3d63269ce38518b83cb0575fca855ebb6316" +dependencies = [ + "adler2", +] + [[package]] name = "mio" version = "1.2.2" @@ -817,6 +1139,12 @@ dependencies = [ "windows-sys 0.61.2", ] +[[package]] +name = "multimap" +version = "0.10.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1d87ecb2933e8aeadb3e3a02b828fed80a7528047e68b4f424523a0981a3a084" + [[package]] name = "nix" version = "0.29.0" @@ -835,7 +1163,7 @@ version = "0.0.53" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "962838abbd8dd2cd3844d2208dc502458bba6985f8bf1dc21761b30260fcbd7f" dependencies = [ - "hashbrown", + "hashbrown 0.17.1", "indexmap", "libm", "memchr", @@ -878,12 +1206,92 @@ dependencies = [ "autocfg", ] +[[package]] +name = "oauth2" +version = "5.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "51e219e79014df21a225b1860a479e2dcd7cbd9130f4defd4bd0e191ea31d67d" +dependencies = [ + "base64", + "chrono", + "getrandom 0.2.17", + "http", + "rand 0.8.8", + "reqwest", + "serde", + "serde_json", + "serde_path_to_error", + "sha2", + "thiserror 1.0.69", + "url", +] + +[[package]] +name = "object" +version = "0.37.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ff76201f031d8863c38aa7f905eca4f53abbfa15f609db4277d44cd8938f33fe" +dependencies = [ + "memchr", +] + [[package]] name = "once_cell" version = "1.21.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50" +[[package]] +name = "openshell-bootstrap" +version = "0.0.0" +dependencies = [ + "bytes", + "miette", + "openshell-core", + "rcgen", + "serde", + "serde_json", + "sha2", + "tempfile", + "tokio", + "tracing", +] + +[[package]] +name = "openshell-core" +version = "0.0.0" +dependencies = [ + "async-trait", + "base64", + "chrono", + "glob", + "ipnet", + "miette", + "nix", + "openshell-extension-core", + "openshell-policy-schema", + "prost", + "prost-types", + "protoc-bin-vendored", + "reqwest", + "rustix", + "rustls", + "rustls-pemfile", + "serde", + "serde_json", + "sha2", + "thiserror 2.0.19", + "tokio", + "tokio-stream", + "tonic", + "tonic-prost", + "tonic-prost-build", + "tonic-types", + "tracing", + "url", + "uuid", +] + [[package]] name = "openshell-e2e" version = "0.1.0" @@ -899,8 +1307,10 @@ dependencies = [ "jsonwebtoken", "nix", "noyalib", + "openshell-bootstrap", + "openshell-sdk", "prost", - "rand", + "rand 0.9.5", "rustls", "rustls-pemfile", "serde", @@ -918,6 +1328,66 @@ dependencies = [ "url", ] +[[package]] +name = "openshell-extension-core" +version = "0.0.0" +dependencies = [ + "hyper-util", + "serde", + "thiserror 2.0.19", + "tokio", + "tonic", + "tower", +] + +[[package]] +name = "openshell-policy-schema" +version = "0.0.0" +dependencies = [ + "miette", + "noyalib", + "serde", + "serde_json", + "serde_path_to_error", + "thiserror 2.0.19", +] + +[[package]] +name = "openshell-sdk" +version = "0.0.0" +dependencies = [ + "async-stream", + "async-trait", + "futures", + "hyper", + "hyper-util", + "miette", + "oauth2", + "openshell-core", + "reqwest", + "rustls", + "serde", + "thiserror 2.0.19", + "tokio", + "tokio-rustls", + "tokio-tungstenite", + "tonic", + "tower", + "tracing", +] + +[[package]] +name = "openssl-probe" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7c87def4c32ab89d880effc9e097653c8da5d6ef28e6b539d313baaacfbafcbe" + +[[package]] +name = "owo-colors" +version = "4.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "13c45bb4a6ae1280ec0803b1ef9d3455eb50f01efbbe1447ab020f1d54fba9d8" + [[package]] name = "parking_lot" version = "0.12.5" @@ -957,6 +1427,17 @@ version = "2.3.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "9b4f627cb1b25917193a259e49bdad08f671f8d9708acfd5fe0a8c1455d87220" +[[package]] +name = "petgraph" +version = "0.8.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8701b58ea97060d5e5b155d383a69952a60943f0e6dfe30b04c287beb0b27455" +dependencies = [ + "fixedbitset", + "hashbrown 0.15.5", + "indexmap", +] + [[package]] name = "pin-project" version = "1.1.13" @@ -995,6 +1476,8 @@ version = "0.1.5" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "0103b1cef7ec0cf76490e969665504990193874ea05c85ff9bab8b911d0a0564" dependencies = [ + "serde_core", + "writeable", "zerovec", ] @@ -1013,6 +1496,16 @@ dependencies = [ "zerocopy", ] +[[package]] +name = "prettyplease" +version = "0.2.37" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "479ca8adacdd7ce8f1fb39ce9ecccbfe93a3f1344b3d0d97f20bc0196208f62b" +dependencies = [ + "proc-macro2", + "syn 2.0.119", +] + [[package]] name = "proc-macro2" version = "1.0.107" @@ -1032,6 +1525,27 @@ dependencies = [ "prost-derive", ] +[[package]] +name = "prost-build" +version = "0.14.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "03da047801ff44bb6a4d407d4860c05fd70bb81714e6b2f3812603d5b145b042" +dependencies = [ + "heck", + "itertools", + "log", + "multimap", + "petgraph", + "prettyplease", + "prost", + "prost-types", + "pulldown-cmark", + "pulldown-cmark-to-cmark", + "regex", + "syn 2.0.119", + "tempfile", +] + [[package]] name = "prost-derive" version = "0.14.4" @@ -1045,6 +1559,99 @@ dependencies = [ "syn 2.0.119", ] +[[package]] +name = "prost-types" +version = "0.14.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f94967dc7688f3054c7fac87473ffae4cc4c3904800e2d9f5b857246d8963b0a" +dependencies = [ + "prost", +] + +[[package]] +name = "protoc-bin-vendored" +version = "3.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8760a25b6ff9c620324822737e468478fa092234190d2e449760344354896ed9" +dependencies = [ + "protoc-bin-vendored-linux-aarch_64", + "protoc-bin-vendored-linux-ppcle_64", + "protoc-bin-vendored-linux-s390_64", + "protoc-bin-vendored-linux-x86_32", + "protoc-bin-vendored-linux-x86_64", + "protoc-bin-vendored-macos-aarch_64", + "protoc-bin-vendored-macos-x86_64", + "protoc-bin-vendored-win32", +] + +[[package]] +name = "protoc-bin-vendored-linux-aarch_64" +version = "3.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "73fa2624782ca04cd44f51554566717377acd240e4c0016d757dd74fccc9324f" + +[[package]] +name = "protoc-bin-vendored-linux-ppcle_64" +version = "3.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e2417e9817fa237dab803ad4dda7357a111656e242959cc6b8f9a1a583367d42" + +[[package]] +name = "protoc-bin-vendored-linux-s390_64" +version = "3.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4d189c34636356a46a7ed3188233dc8a88c431278cc54d4a19b096a2d270e985" + +[[package]] +name = "protoc-bin-vendored-linux-x86_32" +version = "3.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "171e39f1e846e5f322ced1ac3b8d4cd3a3833ca24b6e5d58b3632574fe6204fa" + +[[package]] +name = "protoc-bin-vendored-linux-x86_64" +version = "3.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "873cdcc097593432086661aa432b8078f1cd87bfb02847c332e98ae2c119e966" + +[[package]] +name = "protoc-bin-vendored-macos-aarch_64" +version = "3.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "eeb72df001783b8297847fe8f5f874ee400fd742c843d60583e8c23d96977c7f" + +[[package]] +name = "protoc-bin-vendored-macos-x86_64" +version = "3.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b04652167eca899dda05f32f5481adeaf25c623a98ce2fc146a001cc59a2add7" + +[[package]] +name = "protoc-bin-vendored-win32" +version = "3.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "263a3f48f01e7309e857138bd47f785585b4a005e8e56c6d2824ce91195999c3" + +[[package]] +name = "pulldown-cmark" +version = "0.13.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e9f068eba8e7071c5f9511831b44f32c740d5adf574e990f946ddb53db2f314e" +dependencies = [ + "bitflags", + "memchr", + "unicase", +] + +[[package]] +name = "pulldown-cmark-to-cmark" +version = "22.0.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "84bbb29c624230c4bd1047bbdb2aa47e41c860e9665ce62ba9504eebe91bf867" +dependencies = [ + "pulldown-cmark", +] + [[package]] name = "quote" version = "1.0.47" @@ -1066,16 +1673,37 @@ version = "6.0.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "f8dcc9c7d52a811697d2151c701e0d08956f92b0e24136cf4cf27b57a6a0d9bf" +[[package]] +name = "rand" +version = "0.8.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e058c7de0b26af77780c769414d6257830bb240f3c38477dbc2c16e5f54d6d4c" +dependencies = [ + "libc", + "rand_chacha 0.3.1", + "rand_core 0.6.4", +] + [[package]] name = "rand" version = "0.9.5" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b9ef1d0d795eb7d84685bca4f72f3649f064e6641543d3a8c415898726a57b41" dependencies = [ - "rand_chacha", + "rand_chacha 0.9.0", "rand_core 0.9.5", ] +[[package]] +name = "rand_chacha" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88" +dependencies = [ + "ppv-lite86", + "rand_core 0.6.4", +] + [[package]] name = "rand_chacha" version = "0.9.0" @@ -1104,6 +1732,19 @@ dependencies = [ "getrandom 0.3.4", ] +[[package]] +name = "rcgen" +version = "0.13.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "75e669e5202259b5314d1ea5397316ad400819437857b90861765f24c4cf80a2" +dependencies = [ + "aws-lc-rs", + "pem", + "rustls-pki-types", + "time", + "yasna", +] + [[package]] name = "redox_syscall" version = "0.5.18" @@ -1113,6 +1754,74 @@ dependencies = [ "bitflags", ] +[[package]] +name = "regex" +version = "1.13.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f020237b6c8eed93db2e2cb53c00c60a8e1bc73da7d073199a1180401450218d" +dependencies = [ + "aho-corasick", + "memchr", + "regex-automata", + "regex-syntax", +] + +[[package]] +name = "regex-automata" +version = "0.4.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ad8553b9b26413251cbf30e620595c7a41b3887f03da04579c0e6b0d6a06b4b2" +dependencies = [ + "aho-corasick", + "memchr", + "regex-syntax", +] + +[[package]] +name = "regex-syntax" +version = "0.8.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d6f6ff9a378485b298a5286656da665ba74413d36db0979633275d2e708145d4" + +[[package]] +name = "reqwest" +version = "0.12.28" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "eddd3ca559203180a307f12d114c268abf583f59b03cb906fd0b3ff8646c1147" +dependencies = [ + "base64", + "bytes", + "futures-channel", + "futures-core", + "futures-util", + "http", + "http-body", + "http-body-util", + "hyper", + "hyper-rustls", + "hyper-util", + "js-sys", + "log", + "percent-encoding", + "pin-project-lite", + "rustls", + "rustls-native-certs", + "rustls-pki-types", + "serde", + "serde_json", + "serde_urlencoded", + "sync_wrapper", + "tokio", + "tokio-rustls", + "tower", + "tower-http", + "tower-service", + "url", + "wasm-bindgen", + "wasm-bindgen-futures", + "web-sys", +] + [[package]] name = "ring" version = "0.17.14" @@ -1127,6 +1836,12 @@ dependencies = [ "windows-sys 0.52.0", ] +[[package]] +name = "rustc-demangle" +version = "0.1.28" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b74b56ffa8bb2830709a538c2cbcae9aa062db0d2a42563bfb09bdaae44020eb" + [[package]] name = "rustc-hash" version = "2.1.3" @@ -1161,6 +1876,18 @@ dependencies = [ "zeroize", ] +[[package]] +name = "rustls-native-certs" +version = "0.8.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4a073f5dc7469f984c52ad2752b63b0807745133b6de880b7b64c1ac4c48aec4" +dependencies = [ + "openssl-probe", + "rustls-pki-types", + "schannel", + "security-framework", +] + [[package]] name = "rustls-pemfile" version = "2.2.0" @@ -1203,12 +1930,44 @@ version = "1.0.23" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "9774ba4a74de5f7b1c1451ed6cd5285a32eddb5cccb8cc655a4e50009e06477f" +[[package]] +name = "schannel" +version = "0.1.29" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "91c1b7e4904c873ef0710c1f407dde2e6287de2bebc1bbbf7d430bb7cbffd939" +dependencies = [ + "windows-sys 0.61.2", +] + [[package]] name = "scopeguard" version = "1.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49" +[[package]] +name = "security-framework" +version = "3.7.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b7f4bc775c73d9a02cde8bf7b2ec4c9d12743edf609006c7facc23998404cd1d" +dependencies = [ + "bitflags", + "core-foundation", + "core-foundation-sys", + "libc", + "security-framework-sys", +] + +[[package]] +name = "security-framework-sys" +version = "2.17.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6ce2691df843ecc5d231c0b14ece2acc3efb62c0a398c7e1d875f3983ce020e3" +dependencies = [ + "core-foundation-sys", + "libc", +] + [[package]] name = "serde" version = "1.0.229" @@ -1252,6 +2011,17 @@ dependencies = [ "zmij", ] +[[package]] +name = "serde_path_to_error" +version = "0.1.20" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "10a9ff822e371bb5403e391ecd83e182e0e77ba7f6fe0160b795797109d1b457" +dependencies = [ + "itoa", + "serde", + "serde_core", +] + [[package]] name = "serde_repr" version = "0.1.21" @@ -1355,7 +2125,7 @@ checksum = "0d585997b0ac10be3c5ee635f1bab02d512760d14b7c468801ac8a01d9ae5f1d" dependencies = [ "num-bigint", "num-traits", - "thiserror", + "thiserror 2.0.19", "time", ] @@ -1393,6 +2163,27 @@ version = "2.6.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292" +[[package]] +name = "supports-color" +version = "3.0.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c64fc7232dd8d2e4ac5ce4ef302b1d81e0b80d055b9d77c7c4f51f6aa4c867d6" +dependencies = [ + "is_ci", +] + +[[package]] +name = "supports-hyperlinks" +version = "3.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e396b6523b11ccb83120b115a0b7366de372751aa6edf19844dfb13a6af97e91" + +[[package]] +name = "supports-unicode" +version = "3.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b7401a30af6cb5818bb64852270bb722533397edcfc7344954a38f420819ece2" + [[package]] name = "syn" version = "2.0.119" @@ -1420,6 +2211,9 @@ name = "sync_wrapper" version = "1.0.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "0bf256ce5efdfa370213c1dabab5935a12e49f2c58d15e9eac2870d3b4f27263" +dependencies = [ + "futures-core", +] [[package]] name = "synstructure" @@ -1445,13 +2239,53 @@ dependencies = [ "windows-sys 0.61.2", ] +[[package]] +name = "terminal_size" +version = "0.4.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "230a1b821ccbd75b185820a1f1ff7b14d21da1e442e22c0863ea5f08771a8874" +dependencies = [ + "rustix", + "windows-sys 0.61.2", +] + +[[package]] +name = "textwrap" +version = "0.16.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6ecfad6c3abc80a577f2b91c1e412ee57e7a060d430b553c1b0c940974ebcd49" +dependencies = [ + "icu_segmenter", + "unicode-width 0.2.2", +] + +[[package]] +name = "thiserror" +version = "1.0.69" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b6aaf5339b578ea85b50e080feb250a3e8ae8cfcdff9a461c9ec2904bc923f52" +dependencies = [ + "thiserror-impl 1.0.69", +] + [[package]] name = "thiserror" version = "2.0.19" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "09a43598840e33d5b0331f38c5e30d13bb11c11210a4b58f0d9b18a5a5eefcd9" dependencies = [ - "thiserror-impl", + "thiserror-impl 2.0.19", +] + +[[package]] +name = "thiserror-impl" +version = "1.0.69" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.119", ] [[package]] @@ -1497,11 +2331,12 @@ dependencies = [ [[package]] name = "tinystr" -version = "0.8.3" +version = "0.8.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c8323304221c2a851516f22236c5722a72eaa19749016521d6dff0824447d96d" +checksum = "b1e27c91459209c2986af3dcf603a5a74a4368754ce37414f59acc971167f643" dependencies = [ "displaydoc", + "serde_core", "zerovec", ] @@ -1554,6 +2389,22 @@ dependencies = [ "tokio", ] +[[package]] +name = "tokio-tungstenite" +version = "0.26.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7a9daff607c6d2bf6c16fd681ccb7eecc83e4e2cdc1ca067ffaadfca5de7f084" +dependencies = [ + "futures-util", + "log", + "rustls", + "rustls-native-certs", + "rustls-pki-types", + "tokio", + "tokio-rustls", + "tungstenite", +] + [[package]] name = "tokio-util" version = "0.7.19" @@ -1587,9 +2438,11 @@ dependencies = [ "hyper-util", "percent-encoding", "pin-project", + "rustls-native-certs", "socket2", "sync_wrapper", "tokio", + "tokio-rustls", "tokio-stream", "tower", "tower-layer", @@ -1597,6 +2450,18 @@ dependencies = [ "tracing", ] +[[package]] +name = "tonic-build" +version = "0.14.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c68f61875ac5293cf72e6c8cf0158086428c82c37229e98c840878f1706b0322" +dependencies = [ + "prettyplease", + "proc-macro2", + "quote", + "syn 2.0.119", +] + [[package]] name = "tonic-prost" version = "0.14.6" @@ -1608,6 +2473,33 @@ dependencies = [ "tonic", ] +[[package]] +name = "tonic-prost-build" +version = "0.14.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "654e5643eff75d7f8c99197ce1440ed19a3474eada74c12bbac488b2cafdae27" +dependencies = [ + "prettyplease", + "proc-macro2", + "prost-build", + "prost-types", + "quote", + "syn 2.0.119", + "tempfile", + "tonic-build", +] + +[[package]] +name = "tonic-types" +version = "0.14.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "73ab1b02061f83d519bba3caa167f88f261ef05720ab8ebc954ade70de3348e8" +dependencies = [ + "prost", + "prost-types", + "tonic", +] + [[package]] name = "tower" version = "0.5.3" @@ -1627,6 +2519,24 @@ dependencies = [ "tracing", ] +[[package]] +name = "tower-http" +version = "0.6.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4cfcf7e2740e6fc6d4d688b4ef00650406bb94adf4731e43c096c3a19fe40840" +dependencies = [ + "bitflags", + "bytes", + "futures-util", + "http", + "http-body", + "pin-project-lite", + "tower", + "tower-layer", + "tower-service", + "url", +] + [[package]] name = "tower-layer" version = "0.3.3" @@ -1676,18 +2586,55 @@ version = "0.2.5" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e421abadd41a4225275504ea4d6566923418b7f05506fbc9c0fe86ba7396114b" +[[package]] +name = "tungstenite" +version = "0.26.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4793cb5e56680ecbb1d843515b23b6de9a75eb04b66643e256a396d43be33c13" +dependencies = [ + "bytes", + "data-encoding", + "http", + "httparse", + "log", + "rand 0.9.5", + "rustls", + "rustls-pki-types", + "sha1", + "thiserror 2.0.19", + "utf-8", +] + [[package]] name = "typenum" version = "1.20.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b6f5e870be6c3b371b77fe0ee0bafb859fa4964b4404c27de1d380043c4dda20" +[[package]] +name = "unicase" +version = "2.10.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "357cc3acc6a036009fd6c973ed009037c732d60d0b4f6c673e9041497482a28f" + [[package]] name = "unicode-ident" version = "1.0.24" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75" +[[package]] +name = "unicode-width" +version = "0.1.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7dd6e30e90baa6f72411720665d41d89b9a3d039dc45b8faea1ddd07f617f6af" + +[[package]] +name = "unicode-width" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b4ac048d71ede7ee76d585517add45da530660ef4390e49b098733c6e897f254" + [[package]] name = "untrusted" version = "0.7.1" @@ -1710,14 +2657,32 @@ dependencies = [ "idna", "percent-encoding", "serde", + "serde_derive", ] +[[package]] +name = "utf-8" +version = "0.7.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "09cc8ee72d2a9becf2f2febe0205bbed8fc6615b7cb429ad062dc7b7ddd036a9" + [[package]] name = "utf8_iter" version = "1.0.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b6c140620e7ffbb22c2dee59cafe6084a59b5ffc27a8859a5f0d494b5d52b6be" +[[package]] +name = "uuid" +version = "1.28.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7cc1186384beb7dd8eedea376413fd654937285ea6c9cfbb928dc3043ea4b606" +dependencies = [ + "getrandom 0.4.3", + "js-sys", + "wasm-bindgen", +] + [[package]] name = "version_check" version = "0.9.5" @@ -1761,6 +2726,16 @@ dependencies = [ "wasm-bindgen-shared", ] +[[package]] +name = "wasm-bindgen-futures" +version = "0.4.76" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c62df1340f32221cb9c54d6a27b030e3dba64361d4a95bed55f9aacb44da291d" +dependencies = [ + "js-sys", + "wasm-bindgen", +] + [[package]] name = "wasm-bindgen-macro" version = "0.2.126" @@ -1793,6 +2768,16 @@ dependencies = [ "unicode-ident", ] +[[package]] +name = "web-sys" +version = "0.3.103" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8622dcb61c0bcc9fffa6938bed81210af2da9a7e4a1a834b2e37a59b6dfb6141" +dependencies = [ + "js-sys", + "wasm-bindgen", +] + [[package]] name = "winapi" version = "0.3.9" @@ -1815,12 +2800,65 @@ version = "0.4.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f" +[[package]] +name = "windows-core" +version = "0.62.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b8e83a14d34d0623b51dce9581199302a221863196a1dde71a7663a4c2be9deb" +dependencies = [ + "windows-implement", + "windows-interface", + "windows-link", + "windows-result", + "windows-strings", +] + +[[package]] +name = "windows-implement" +version = "0.60.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "053e2e040ab57b9dc951b72c264860db7eb3b0200ba345b4e4c3b14f67855ddf" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.119", +] + +[[package]] +name = "windows-interface" +version = "0.59.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3f316c4a2570ba26bbec722032c4099d8c8bc095efccdc15688708623367e358" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.119", +] + [[package]] name = "windows-link" version = "0.2.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5" +[[package]] +name = "windows-result" +version = "0.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7781fa89eaf60850ac3d2da7af8e5242a5ea78d1a11c49bf2910bb5a73853eb5" +dependencies = [ + "windows-link", +] + +[[package]] +name = "windows-strings" +version = "0.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7837d08f69c77cf6b07689544538e017c1bfcf57e34b4c0ff58e6c2cd3b37091" +dependencies = [ + "windows-link", +] + [[package]] name = "windows-sys" version = "0.52.0" @@ -1911,9 +2949,18 @@ checksum = "1ebf944e87a7c253233ad6766e082e3cd714b5d03812acc24c318f549614536e" [[package]] name = "writeable" -version = "0.6.3" +version = "0.6.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3ad82d2a33cdc9674dc7465672f271e096168fcdbe0f799d9e6db8c5892679dc" + +[[package]] +name = "yasna" +version = "0.5.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1ffae5123b2d3fc086436f8834ae3ab053a283cfac8fe0a0b8eaae044768a4c4" +checksum = "e17bb3549cc1321ae1296b9cdc2698e2b6cb1992adfa19a8c72e5b7a738f44cd" +dependencies = [ + "time", +] [[package]] name = "yoke" @@ -2001,21 +3048,23 @@ dependencies = [ [[package]] name = "zerotrie" -version = "0.2.4" +version = "0.2.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0f9152d31db0792fa83f70fb2f83148effb5c1f5b8c7686c3459e361d9bc20bf" +checksum = "4ea269c3bd32f0a32c321907a2ae912ba6f4649bb0fc764a15627e99a7095a3f" dependencies = [ "displaydoc", "yoke", "zerofrom", + "zerovec", ] [[package]] name = "zerovec" -version = "0.11.6" +version = "0.11.8" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "90f911cbc359ab6af17377d242225f4d75119aec87ea711a880987b18cd7b239" +checksum = "bb0464e17806c1d976d5cba29399c7f08e516e279e2ba493f63123b5fca67dd8" dependencies = [ + "serde", "yoke", "zerofrom", "zerovec-derive", @@ -2023,13 +3072,13 @@ dependencies = [ [[package]] name = "zerovec-derive" -version = "0.11.3" +version = "0.11.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "625dc425cab0dca6dc3c3319506e6593dcb08a9f387ea3b284dbd52a92c40555" +checksum = "34df6fc39dbd26ddc9c10e6a2984476e13acce22e64e4487636ef494369225da" dependencies = [ "proc-macro2", "quote", - "syn 2.0.119", + "syn 3.0.3", ] [[package]] diff --git a/e2e/rust/Cargo.toml b/e2e/rust/Cargo.toml index 7659015625..fbdc23ca05 100644 --- a/e2e/rust/Cargo.toml +++ b/e2e/rust/Cargo.toml @@ -29,7 +29,7 @@ e2e-local-container-driver = ["e2e"] e2e-docker = ["e2e", "e2e-host-gateway", "e2e-local-container-driver"] e2e-gpu = ["e2e"] e2e-docker-gpu = ["e2e-docker", "e2e-gpu"] -e2e-kubernetes = ["e2e"] +e2e-kubernetes = ["e2e", "dep:openshell-bootstrap", "dep:openshell-sdk"] e2e-kubernetes-ha = ["e2e-kubernetes"] e2e-kubernetes-credential-drivers = ["e2e-kubernetes"] e2e-kubernetes-workspace-managed = ["e2e-kubernetes"] @@ -169,6 +169,11 @@ name = "kubernetes_runtime_reconcile" path = "tests/kubernetes_runtime_reconcile.rs" required-features = ["e2e-kubernetes"] +[[test]] +name = "kubernetes_image_update" +path = "tests/kubernetes_image_update.rs" +required-features = ["e2e-kubernetes"] + [[test]] name = "credential_drivers" path = "tests/credential_drivers.rs" @@ -240,6 +245,8 @@ path = "tests/gpu.rs" required-features = ["e2e-gpu"] [dependencies] +openshell-bootstrap = { path = "../../crates/openshell-bootstrap", optional = true } +openshell-sdk = { path = "../../crates/openshell-sdk", optional = true } base64 = "0.22" bollard = "0.20" bytes = "1" diff --git a/e2e/rust/tests/kubernetes_image_update.rs b/e2e/rust/tests/kubernetes_image_update.rs new file mode 100644 index 0000000000..9077e66761 --- /dev/null +++ b/e2e/rust/tests/kubernetes_image_update.rs @@ -0,0 +1,424 @@ +// SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +// SPDX-License-Identifier: Apache-2.0 + +#![cfg(feature = "e2e-kubernetes")] + +//! Exercise the public image-update RPC in both Agent Sandbox API-version lanes. +//! Kubernetes object checks are read-only and scoped to this test's sandbox. + +use std::collections::BTreeMap; +use std::path::PathBuf; +use std::time::Duration; + +use openshell_bootstrap::{load_active_gateway, load_gateway_metadata}; +use openshell_e2e::harness::cli::{run_cli, wait_for_sandbox_phase}; +use openshell_e2e::harness::sandbox::SandboxGuard; +use openshell_sdk::raw::{AuthedGrpcClient, proto}; +use openshell_sdk::{ClientConfig, EdgeAuthInterceptor, OpenShellClient}; +use serde_json::Value; +use tonic::transport::{Certificate, ClientTlsConfig, Endpoint, Identity}; + +// Multi-platform release manifests; no test-local tags or cluster image loads. +const ORIGINAL_IMAGE: &str = "docker.io/library/alpine:3.21@sha256:ce64758a109eb420d874a118f87920e625e12d3634e03b4a5573fd9f6e5d3507"; +const UPDATED_IMAGE: &str = "docker.io/library/alpine:3.22@sha256:5291449c3df73caf6ed85e649dec1b9e818b39a5d8c871e97afc13e9cd5e8fa8"; +const SENTINEL_PATH: &str = "/sandbox/.image-update-sentinel"; + +/// Reuse the wrapper's registered endpoint (including its isolated XDG config). +/// The SDK owns plaintext transport; the `OpenShift` wrapper registers an mTLS +/// gateway, for which we attach its existing client bundle to a tonic channel. +async fn gateway_client() -> AuthedGrpcClient { + let name = std::env::var("OPENSHELL_GATEWAY") + .ok() + .filter(|name| !name.trim().is_empty()) + .or_else(load_active_gateway) + .expect("Kubernetes E2E wrapper must register a gateway"); + let metadata = load_gateway_metadata(&name).expect("load E2E gateway metadata"); + let client = if metadata.gateway_endpoint.starts_with("http://") { + OpenShellClient::connect(ClientConfig::new(metadata.gateway_endpoint)) + .await + .expect("connect to E2E gateway") + } else { + assert!( + matches!(metadata.auth_mode.as_deref(), None | Some("mtls")), + "Kubernetes E2E wrapper must register plaintext or mTLS transport" + ); + let config = std::env::var_os("XDG_CONFIG_HOME").map_or_else( + || PathBuf::from(std::env::var_os("HOME").expect("HOME")).join(".config"), + PathBuf::from, + ); + let bundle = config.join("openshell/gateways").join(&name).join("mtls"); + let tls = ClientTlsConfig::new() + .ca_certificate(Certificate::from_pem( + std::fs::read(bundle.join("ca.crt")).expect("read E2E gateway CA"), + )) + .identity(Identity::from_pem( + std::fs::read(bundle.join("tls.crt")).expect("read E2E client certificate"), + std::fs::read(bundle.join("tls.key")).expect("read E2E client key"), + )); + let channel = Endpoint::from_shared(metadata.gateway_endpoint) + .expect("E2E gateway endpoint") + .connect_timeout(Duration::from_secs(10)) + .timeout(Duration::from_secs(60)) + .tls_config(tls) + .expect("configure E2E gateway mTLS") + .connect() + .await + .expect("connect to E2E gateway over mTLS"); + OpenShellClient::from_parts(channel, EdgeAuthInterceptor::noop()) + }; + client.raw_grpc() +} + +fn request_id() -> String { + let mut bytes = rand::random::<[u8; 16]>(); + bytes[6] = (bytes[6] & 0x0f) | 0x40; + bytes[8] = (bytes[8] & 0x3f) | 0x80; + let hex = hex::encode(bytes); + format!( + "{}-{}-{}-{}-{}", + &hex[..8], + &hex[8..12], + &hex[12..16], + &hex[16..20], + &hex[20..] + ) +} + +fn rpc(body: T) -> tonic::Request { + let mut request = tonic::Request::new(body); + request.set_timeout(Duration::from_secs(60)); + request +} + +async fn get_sandbox(client: &mut AuthedGrpcClient, name: &str) -> proto::Sandbox { + client + .get_sandbox(rpc(proto::GetSandboxRequest { + workspace_scope: Some(proto::workspace_selector("default")), + name: name.to_owned(), + })) + .await + .expect("get test sandbox") + .into_inner() + .sandbox + .expect("Sandbox response") +} + +async fn kubectl_get(resource: &str, selector: &[&str]) -> Value { + let namespace = std::env::var("OPENSHELL_E2E_SANDBOX_NAMESPACE") + .expect("Kubernetes E2E wrapper must provide the sandbox namespace"); + let context = std::env::var("OPENSHELL_E2E_KUBE_CONTEXT_ACTIVE") + .expect("Kubernetes E2E wrapper must provide its active context"); + assert!(!namespace.trim().is_empty() && !context.trim().is_empty()); + let output = tokio::process::Command::new("kubectl") + .args([ + "--context", + &context, + "--namespace", + &namespace, + "--request-timeout=30s", + "get", + resource, + ]) + .args(selector) + .args(["--output=json"]) + .kill_on_drop(true) + .output() + .await + .expect("run scoped kubectl get"); + assert!( + output.status.success(), + "kubectl get {resource} {selector:?}: {}", + String::from_utf8_lossy(&output.stderr) + ); + serde_json::from_slice(&output.stdout).expect("parse kubectl JSON") +} + +async fn sandbox_resource(id: &str) -> Value { + let selector = format!("openshell.ai/sandbox-id={id}"); + let list = kubectl_get("sandboxes.agents.x-k8s.io", &["--selector", &selector]).await; + let [resource] = list["items"].as_array().expect("Sandbox items").as_slice() else { + panic!("expected exactly one Sandbox resource for {id}: {list}"); + }; + assert_eq!( + resource["metadata"]["labels"]["openshell.ai/sandbox-id"], + id + ); + assert!( + resource["metadata"]["uid"] + .as_str() + .is_some_and(|uid| !uid.is_empty()) + ); + resource.clone() +} + +/// Read claims by their exact names from the actual workload Pod. Do not rely +/// on controller-version-dependent PVC names or labels, or inspect other PVCs. +async fn claim_uids(resource: &Value) -> BTreeMap { + let pod_name = resource["metadata"]["annotations"]["agents.x-k8s.io/pod-name"] + .as_str() + .unwrap_or_else(|| resource["metadata"]["name"].as_str().expect("Sandbox name")); + let pod = kubectl_get("pod", &[pod_name]).await; + assert!( + pod["metadata"]["ownerReferences"] + .as_array() + .expect("workload Pod owners") + .iter() + .any(|owner| owner["uid"] == resource["metadata"]["uid"]), + "workload Pod must belong to this Sandbox resource" + ); + let agent = pod["spec"]["containers"] + .as_array() + .expect("Pod containers") + .iter() + .find(|container| container["name"] == "agent") + .expect("agent container"); + let workspace_volume = agent["volumeMounts"] + .as_array() + .expect("agent volume mounts") + .iter() + .find(|mount| mount["mountPath"] == "/sandbox") + .expect("workspace volume mount"); + let volumes = pod["spec"]["volumes"].as_array().expect("Pod volumes"); + assert!( + volumes.iter().any(|volume| { + volume["name"] == workspace_volume["name"] + && volume["persistentVolumeClaim"]["claimName"] + .as_str() + .is_some() + }), + "workspace must be backed by a PVC" + ); + let mut claims = BTreeMap::new(); + for volume in volumes { + let Some(name) = volume["persistentVolumeClaim"]["claimName"].as_str() else { + continue; + }; + let claim = kubectl_get("persistentvolumeclaim", &[name]).await; + let uid = claim["metadata"]["uid"] + .as_str() + .filter(|uid| !uid.is_empty()) + .expect("PVC UID"); + assert_eq!(claim["status"]["phase"], "Bound"); + claims.insert(name.to_owned(), uid.to_owned()); + } + assert!( + !claims.is_empty(), + "test must exercise PVC-backed workspace storage" + ); + claims +} + +fn assert_resource_retained(before: &Value, after: &Value, image: &str) { + assert_eq!(after["metadata"]["name"], before["metadata"]["name"]); + assert_eq!(after["metadata"]["uid"], before["metadata"]["uid"]); + assert_eq!( + after["spec"]["volumeClaimTemplates"], + before["spec"]["volumeClaimTemplates"] + ); + let agent = after["spec"]["podTemplate"]["spec"]["containers"] + .as_array() + .expect("workload containers") + .iter() + .find(|container| container["name"] == "agent") + .expect("agent container"); + assert_eq!(agent["image"], image); +} + +fn assert_identity_retained(before: &proto::Sandbox, after: &proto::Sandbox) { + assert_eq!( + after.metadata.as_ref().expect("metadata").id, + before.metadata.as_ref().expect("metadata").id + ); + assert_eq!(after.host_key_fingerprint, before.host_key_fingerprint); +} + +async fn assert_base_release(sandbox: &SandboxGuard, release: &str) { + assert!( + sandbox + .exec(&["cat", "/etc/alpine-release"]) + .await + .expect("base image release") + .trim() + .starts_with(release) + ); +} + +fn assert_update_completed(original: &proto::Sandbox, updated: &proto::Sandbox) { + assert_identity_retained(original, updated); + let status = updated.status.as_ref().expect("updated status"); + assert_eq!(status.phase, proto::SandboxPhase::Stopped as i32); + assert!( + status.image_update.is_none(), + "successful update must clear pending intent" + ); + assert_eq!( + updated + .spec + .as_ref() + .expect("spec") + .template + .as_ref() + .expect("template") + .image, + UPDATED_IMAGE + ); +} + +async fn assert_replay( + client: &mut AuthedGrpcClient, + update: proto::UpdateSandboxRequest, + updated: &proto::Sandbox, +) { + // Replay the exact old resource-version request. Sandbox replay returns its + // current state: ordinary watch observations may have advanced metadata and + // status since the original response, without applying the image again. + let replay = client + .update_sandbox(rpc(update)) + .await + .expect("request-ID replay"); + assert_eq!( + replay + .metadata() + .get("openshell-replayed") + .expect("replay metadata"), + "true" + ); + let replayed = replay.into_inner().sandbox.expect("replayed Sandbox"); + assert_update_completed(updated, &replayed); + assert_eq!(replayed.spec, updated.spec); + assert_eq!( + replayed + .status + .as_ref() + .expect("replayed status") + .image_revision, + updated + .status + .as_ref() + .expect("updated status") + .image_revision, + "replay must not admit another image operation" + ); + assert!( + replayed + .metadata + .as_ref() + .expect("replayed metadata") + .resource_version + >= updated + .metadata + .as_ref() + .expect("updated metadata") + .resource_version + ); +} + +#[tokio::test] +async fn image_update_retains_workspace_and_identity() { + let mut client = gateway_client().await; + // This test is Kubernetes-only: missing support is a regression, not a skip. + let info = client + .get_gateway_info(rpc(proto::GetGatewayInfoRequest {})) + .await + .expect("get gateway capabilities") + .into_inner(); + assert!(info.extensions.iter().any(|extension| { + extension + .supported_capabilities + .iter() + .any(|capability| capability == "openshell.compute.update-sandbox-image") + })); + + let mut sandbox = SandboxGuard::create(&["--from", ORIGINAL_IMAGE, "--no-auto-providers"]) + .await + .expect("create original Alpine sandbox"); + let original = get_sandbox(&mut client, &sandbox.name).await; + let id = &original.metadata.as_ref().expect("sandbox metadata").id; + assert!(!id.is_empty(), "sandbox must have a canonical ID"); + assert!( + original.host_key_fingerprint.starts_with("SHA256:"), + "sandbox must have a gateway-managed SSH identity" + ); + assert_base_release(&sandbox, "3.21.").await; + let sentinel = request_id(); + sandbox + .exec(&[ + "sh", + "-c", + &format!("printf '%s' '{sentinel}' > '{SENTINEL_PATH}'"), + ]) + .await + .expect("write workspace sentinel"); + let before = sandbox_resource(id).await; + let original_claims = claim_uids(&before).await; + + let running_update = proto::UpdateSandboxRequest { + workspace_scope: Some(proto::workspace_selector("default")), + name: sandbox.name.clone(), + image: UPDATED_IMAGE.to_owned(), + expected_resource_version: original + .metadata + .as_ref() + .expect("metadata") + .resource_version, + request_id: String::new(), + }; + let error = client + .update_sandbox(rpc(running_update.clone())) + .await + .expect_err("running update must be rejected"); + assert_eq!(error.code(), tonic::Code::FailedPrecondition); + assert_resource_retained(&before, &sandbox_resource(id).await, ORIGINAL_IMAGE); + + let (output, code) = run_cli(&["sandbox", "stop", &sandbox.name]).await; + assert_eq!(code, 0, "sandbox stop: {output}"); + wait_for_sandbox_phase(&sandbox.name, "Stopped", Duration::from_secs(120)) + .await + .expect("sandbox stopped"); + let stopped = get_sandbox(&mut client, &sandbox.name).await; + let update = proto::UpdateSandboxRequest { + expected_resource_version: stopped + .metadata + .as_ref() + .expect("metadata") + .resource_version, + request_id: request_id(), + ..running_update + }; + let updated = client + .update_sandbox(rpc(update.clone())) + .await + .expect("update stopped sandbox image") + .into_inner() + .sandbox + .expect("updated Sandbox"); + assert_update_completed(&original, &updated); + assert_resource_retained(&before, &sandbox_resource(id).await, UPDATED_IMAGE); + + assert_replay(&mut client, update, &updated).await; + + let (output, code) = run_cli(&["sandbox", "start", &sandbox.name]).await; + assert_eq!(code, 0, "sandbox start: {output}"); + wait_for_sandbox_phase(&sandbox.name, "Ready", Duration::from_secs(180)) + .await + .expect("updated sandbox ready"); + assert_base_release(&sandbox, "3.22.").await; + assert_eq!( + sandbox + .exec(&["cat", SENTINEL_PATH]) + .await + .expect("retained workspace sentinel") + .trim(), + sentinel + ); + let current = get_sandbox(&mut client, &sandbox.name).await; + assert_identity_retained(&original, ¤t); + let after = sandbox_resource(id).await; + assert_resource_retained(&before, &after, UPDATED_IMAGE); + assert_eq!( + claim_uids(&after).await, + original_claims, + "all mounted PVC names and UIDs must survive image replacement" + ); + sandbox.cleanup().await; +} diff --git a/proto/compute_driver.proto b/proto/compute_driver.proto index 2d3f67b5d7..2a9aec0e06 100644 --- a/proto/compute_driver.proto +++ b/proto/compute_driver.proto @@ -45,6 +45,13 @@ service ComputeDriver { // Provision platform resources for a sandbox. rpc CreateSandbox(CreateSandboxRequest) returns (CreateSandboxResponse); + // Idempotently replace only the workload image of a stopped sandbox, retaining + // its stable resource and storage. Requires the optional capability + // openshell.compute.update-sandbox-image. Unsupported drivers return + // UNIMPLEMENTED without changing any resource. + rpc UpdateSandboxImage(UpdateSandboxImageRequest) + returns (UpdateSandboxImageResponse); + // Idempotently stop platform resources without deleting persistent state. rpc StopSandbox(StopSandboxRequest) returns (StopSandboxResponse); @@ -432,6 +439,27 @@ message CreateSandboxResponse { string runtime_identity = 1; } +message UpdateSandboxImageRequest { + string sandbox_id = 1; + string name = 2; + string image = 3; + // Pre-update image. A different current image conflicts unless durable driver + // evidence identifies this exact operation as already applied. + string expected_image = 4; + // Never adopt a same-name replacement resource. + string expected_runtime_identity = 5; + // Stable UUID across retries, recorded atomically with the image change. + string operation_id = 6; + // Perform all admission and state checks without writing any resource. The + // gateway uses this before recording durable intent; apply rechecks them. + bool validate_only = 7; + // Monotonic sandbox image revision. The driver atomically records it with + // the image and rejects earlier revisions even if expected_image matches. + uint64 revision = 8; +} + +message UpdateSandboxImageResponse {} + message StopSandboxRequest { // Stable sandbox ID stored by the gateway. string sandbox_id = 1; diff --git a/proto/openshell.proto b/proto/openshell.proto index f4186ea440..3a7dcad9bf 100644 --- a/proto/openshell.proto +++ b/proto/openshell.proto @@ -53,6 +53,16 @@ service OpenShell { }; } + // Update only the workload image of a stopped sandbox without deleting its + // identity or retained storage. Requires compute-driver image-update support. + rpc UpdateSandbox(UpdateSandboxRequest) returns (SandboxResponse) { + option (openshell.options.v1.authorization) = { + auth_mode: "bearer" + scope: "sandbox:write" + workspace_role: "user" + }; + } + // Allocate a gateway-owned staging slot for a local rootfs tar archive. // // The gateway creates a request-scoped directory inside the compute driver's @@ -1207,6 +1217,20 @@ message SandboxStatus { // failures before a configured endpoint or credential could be selected. // Matching grant success or a policy, provider, or supervisor reset clears it. TokenGrantFailureObservation last_token_grant_failure = 17; + // Durable pending image change. Start is blocked until the same image update + // is retried successfully. Absence means no image update is pending. + SandboxImageUpdate image_update = 18; + // Monotonic gateway-owned image intent revision. Never reset by restart. + uint64 image_revision = 19; +} + +// Gateway-owned intent retained across interrupted driver operations. +message SandboxImageUpdate { + string operation_id = 1; + string previous_image = 2; + string image = 3; + // Fences delayed operations, including image changes that return to an old tag. + uint64 revision = 4; } // User-facing sandbox condition derived from platform or gateway observations. @@ -1289,6 +1313,22 @@ message CreateSandboxRequest { repeated SandboxServiceExposure service_exposures = 9; } +// Image-only update. Other create-time configuration is not mutable through +// this RPC. Stop before updating; start explicitly after a successful update. +message UpdateSandboxRequest { + // Workspace scope. Only a named workspace selection is accepted. + openshell.datamodel.v1.WorkspaceSelector workspace_scope = 1; + // Canonical name of the existing sandbox; this is not a rename or upsert. + string name = 2; + // Nonempty OCI workload image reference. This does not change trusted runtime + // images or reseed an existing workspace. + string image = 3; + // Required nonzero resource version read by the caller. + uint64 expected_resource_version = 4; + // Optional nonzero UUID for durable at-most-once admission. + string request_id = 5; +} + message CreateSandboxTemplateRequest { // Workspace scope. Only a named workspace selection is accepted. openshell.datamodel.v1.WorkspaceSelector workspace_scope = 2; diff --git a/sdk/go/openshell/v1/internal/converter/coverage_test.go b/sdk/go/openshell/v1/internal/converter/coverage_test.go index 785e12c9c6..8a457d0014 100644 --- a/sdk/go/openshell/v1/internal/converter/coverage_test.go +++ b/sdk/go/openshell/v1/internal/converter/coverage_test.go @@ -135,7 +135,9 @@ func TestConverterCoversAllProtoFields_SandboxStatus(t *testing.T) { // Provisioning carries gateway-owned attempt, deadline, and cleanup state; // the curated API exposes its outcome through phase and conditions. Detailed // lifecycle bookkeeping remains available through the raw protobuf API. - skipped := fieldSet{"main_process_instance_id": true, "configuration_activated": true, "provisioning": true} + // Image updates are raw-only; their pending reconciliation intent and + // monotonic image revision bookkeeping are not part of the curated status model. + skipped := fieldSet{"main_process_instance_id": true, "configuration_activated": true, "provisioning": true, "image_update": true, "image_revision": true} assertAllFieldsCovered(t, (&pb.SandboxStatus{}).ProtoReflect().Descriptor(), handled, skipped) } diff --git a/sdk/go/proto/openshellv1/openshell.pb.go b/sdk/go/proto/openshellv1/openshell.pb.go index 68a550bdec..27e43ca541 100644 --- a/sdk/go/proto/openshellv1/openshell.pb.go +++ b/sdk/go/proto/openshellv1/openshell.pb.go @@ -3194,8 +3194,13 @@ type SandboxStatus struct { // failures before a configured endpoint or credential could be selected. // Matching grant success or a policy, provider, or supervisor reset clears it. LastTokenGrantFailure *TokenGrantFailureObservation `protobuf:"bytes,17,opt,name=last_token_grant_failure,json=lastTokenGrantFailure,proto3" json:"last_token_grant_failure,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache + // Durable pending image change. Start is blocked until the same image update + // is retried successfully. Absence means no image update is pending. + ImageUpdate *SandboxImageUpdate `protobuf:"bytes,18,opt,name=image_update,json=imageUpdate,proto3" json:"image_update,omitempty"` + // Monotonic gateway-owned image intent revision. Never reset by restart. + ImageRevision uint64 `protobuf:"varint,19,opt,name=image_revision,json=imageRevision,proto3" json:"image_revision,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *SandboxStatus) Reset() { @@ -3340,6 +3345,90 @@ func (x *SandboxStatus) GetLastTokenGrantFailure() *TokenGrantFailureObservation return nil } +func (x *SandboxStatus) GetImageUpdate() *SandboxImageUpdate { + if x != nil { + return x.ImageUpdate + } + return nil +} + +func (x *SandboxStatus) GetImageRevision() uint64 { + if x != nil { + return x.ImageRevision + } + return 0 +} + +// Gateway-owned intent retained across interrupted driver operations. +type SandboxImageUpdate struct { + state protoimpl.MessageState `protogen:"open.v1"` + OperationId string `protobuf:"bytes,1,opt,name=operation_id,json=operationId,proto3" json:"operation_id,omitempty"` + PreviousImage string `protobuf:"bytes,2,opt,name=previous_image,json=previousImage,proto3" json:"previous_image,omitempty"` + Image string `protobuf:"bytes,3,opt,name=image,proto3" json:"image,omitempty"` + // Fences delayed operations, including image changes that return to an old tag. + Revision uint64 `protobuf:"varint,4,opt,name=revision,proto3" json:"revision,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *SandboxImageUpdate) Reset() { + *x = SandboxImageUpdate{} + mi := &file_openshell_proto_msgTypes[30] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *SandboxImageUpdate) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SandboxImageUpdate) ProtoMessage() {} + +func (x *SandboxImageUpdate) ProtoReflect() protoreflect.Message { + mi := &file_openshell_proto_msgTypes[30] + 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 SandboxImageUpdate.ProtoReflect.Descriptor instead. +func (*SandboxImageUpdate) Descriptor() ([]byte, []int) { + return file_openshell_proto_rawDescGZIP(), []int{30} +} + +func (x *SandboxImageUpdate) GetOperationId() string { + if x != nil { + return x.OperationId + } + return "" +} + +func (x *SandboxImageUpdate) GetPreviousImage() string { + if x != nil { + return x.PreviousImage + } + return "" +} + +func (x *SandboxImageUpdate) GetImage() string { + if x != nil { + return x.Image + } + return "" +} + +func (x *SandboxImageUpdate) GetRevision() uint64 { + if x != nil { + return x.Revision + } + return 0 +} + // User-facing sandbox condition derived from platform or gateway observations. type SandboxCondition struct { state protoimpl.MessageState `protogen:"open.v1"` @@ -3359,7 +3448,7 @@ type SandboxCondition struct { func (x *SandboxCondition) Reset() { *x = SandboxCondition{} - mi := &file_openshell_proto_msgTypes[30] + mi := &file_openshell_proto_msgTypes[31] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3371,7 +3460,7 @@ func (x *SandboxCondition) String() string { func (*SandboxCondition) ProtoMessage() {} func (x *SandboxCondition) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[30] + mi := &file_openshell_proto_msgTypes[31] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3384,7 +3473,7 @@ func (x *SandboxCondition) ProtoReflect() protoreflect.Message { // Deprecated: Use SandboxCondition.ProtoReflect.Descriptor instead. func (*SandboxCondition) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{30} + return file_openshell_proto_rawDescGZIP(), []int{31} } func (x *SandboxCondition) GetType() string { @@ -3443,7 +3532,7 @@ type PlatformEvent struct { func (x *PlatformEvent) Reset() { *x = PlatformEvent{} - mi := &file_openshell_proto_msgTypes[31] + mi := &file_openshell_proto_msgTypes[32] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3455,7 +3544,7 @@ func (x *PlatformEvent) String() string { func (*PlatformEvent) ProtoMessage() {} func (x *PlatformEvent) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[31] + mi := &file_openshell_proto_msgTypes[32] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3468,7 +3557,7 @@ func (x *PlatformEvent) ProtoReflect() protoreflect.Message { // Deprecated: Use PlatformEvent.ProtoReflect.Descriptor instead. func (*PlatformEvent) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{31} + return file_openshell_proto_rawDescGZIP(), []int{32} } func (x *PlatformEvent) GetEventTime() *timestamppb.Timestamp { @@ -3544,7 +3633,7 @@ type CreateSandboxRequest struct { func (x *CreateSandboxRequest) Reset() { *x = CreateSandboxRequest{} - mi := &file_openshell_proto_msgTypes[32] + mi := &file_openshell_proto_msgTypes[33] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3556,7 +3645,7 @@ func (x *CreateSandboxRequest) String() string { func (*CreateSandboxRequest) ProtoMessage() {} func (x *CreateSandboxRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[32] + mi := &file_openshell_proto_msgTypes[33] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3569,7 +3658,7 @@ func (x *CreateSandboxRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use CreateSandboxRequest.ProtoReflect.Descriptor instead. func (*CreateSandboxRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{32} + return file_openshell_proto_rawDescGZIP(), []int{33} } func (x *CreateSandboxRequest) GetWorkspaceScope() *datamodelv1.WorkspaceSelector { @@ -3635,6 +3724,90 @@ func (x *CreateSandboxRequest) GetServiceExposures() []*SandboxServiceExposure { return nil } +// Image-only update. Other create-time configuration is not mutable through +// this RPC. Stop before updating; start explicitly after a successful update. +type UpdateSandboxRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + // Workspace scope. Only a named workspace selection is accepted. + WorkspaceScope *datamodelv1.WorkspaceSelector `protobuf:"bytes,1,opt,name=workspace_scope,json=workspaceScope,proto3" json:"workspace_scope,omitempty"` + // Canonical name of the existing sandbox; this is not a rename or upsert. + Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` + // Nonempty OCI workload image reference. This does not change trusted runtime + // images or reseed an existing workspace. + Image string `protobuf:"bytes,3,opt,name=image,proto3" json:"image,omitempty"` + // Required nonzero resource version read by the caller. + ExpectedResourceVersion uint64 `protobuf:"varint,4,opt,name=expected_resource_version,json=expectedResourceVersion,proto3" json:"expected_resource_version,omitempty"` + // Optional nonzero UUID for durable at-most-once admission. + RequestId string `protobuf:"bytes,5,opt,name=request_id,json=requestId,proto3" json:"request_id,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *UpdateSandboxRequest) Reset() { + *x = UpdateSandboxRequest{} + mi := &file_openshell_proto_msgTypes[34] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *UpdateSandboxRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*UpdateSandboxRequest) ProtoMessage() {} + +func (x *UpdateSandboxRequest) ProtoReflect() protoreflect.Message { + mi := &file_openshell_proto_msgTypes[34] + 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 UpdateSandboxRequest.ProtoReflect.Descriptor instead. +func (*UpdateSandboxRequest) Descriptor() ([]byte, []int) { + return file_openshell_proto_rawDescGZIP(), []int{34} +} + +func (x *UpdateSandboxRequest) GetWorkspaceScope() *datamodelv1.WorkspaceSelector { + if x != nil { + return x.WorkspaceScope + } + return nil +} + +func (x *UpdateSandboxRequest) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +func (x *UpdateSandboxRequest) GetImage() string { + if x != nil { + return x.Image + } + return "" +} + +func (x *UpdateSandboxRequest) GetExpectedResourceVersion() uint64 { + if x != nil { + return x.ExpectedResourceVersion + } + return 0 +} + +func (x *UpdateSandboxRequest) GetRequestId() string { + if x != nil { + return x.RequestId + } + return "" +} + type CreateSandboxTemplateRequest struct { state protoimpl.MessageState `protogen:"open.v1"` // Workspace scope. Only a named workspace selection is accepted. @@ -3649,7 +3822,7 @@ type CreateSandboxTemplateRequest struct { func (x *CreateSandboxTemplateRequest) Reset() { *x = CreateSandboxTemplateRequest{} - mi := &file_openshell_proto_msgTypes[33] + mi := &file_openshell_proto_msgTypes[35] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3661,7 +3834,7 @@ func (x *CreateSandboxTemplateRequest) String() string { func (*CreateSandboxTemplateRequest) ProtoMessage() {} func (x *CreateSandboxTemplateRequest) 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 { @@ -3674,7 +3847,7 @@ func (x *CreateSandboxTemplateRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use CreateSandboxTemplateRequest.ProtoReflect.Descriptor instead. func (*CreateSandboxTemplateRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{33} + return file_openshell_proto_rawDescGZIP(), []int{35} } func (x *CreateSandboxTemplateRequest) GetWorkspaceScope() *datamodelv1.WorkspaceSelector { @@ -3709,7 +3882,7 @@ type GetSandboxTemplateRequest struct { func (x *GetSandboxTemplateRequest) Reset() { *x = GetSandboxTemplateRequest{} - mi := &file_openshell_proto_msgTypes[34] + mi := &file_openshell_proto_msgTypes[36] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3721,7 +3894,7 @@ func (x *GetSandboxTemplateRequest) String() string { func (*GetSandboxTemplateRequest) ProtoMessage() {} func (x *GetSandboxTemplateRequest) 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 { @@ -3734,7 +3907,7 @@ func (x *GetSandboxTemplateRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetSandboxTemplateRequest.ProtoReflect.Descriptor instead. func (*GetSandboxTemplateRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{34} + return file_openshell_proto_rawDescGZIP(), []int{36} } func (x *GetSandboxTemplateRequest) GetWorkspaceScope() *datamodelv1.WorkspaceSelector { @@ -3769,7 +3942,7 @@ type ListSandboxTemplatesRequest struct { func (x *ListSandboxTemplatesRequest) Reset() { *x = ListSandboxTemplatesRequest{} - mi := &file_openshell_proto_msgTypes[35] + mi := &file_openshell_proto_msgTypes[37] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3781,7 +3954,7 @@ func (x *ListSandboxTemplatesRequest) String() string { func (*ListSandboxTemplatesRequest) ProtoMessage() {} func (x *ListSandboxTemplatesRequest) 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 { @@ -3794,7 +3967,7 @@ func (x *ListSandboxTemplatesRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListSandboxTemplatesRequest.ProtoReflect.Descriptor instead. func (*ListSandboxTemplatesRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{35} + return file_openshell_proto_rawDescGZIP(), []int{37} } func (x *ListSandboxTemplatesRequest) GetWorkspaceScope() *datamodelv1.WorkspaceSelector { @@ -3841,7 +4014,7 @@ type DeleteSandboxTemplateRequest struct { func (x *DeleteSandboxTemplateRequest) Reset() { *x = DeleteSandboxTemplateRequest{} - mi := &file_openshell_proto_msgTypes[36] + mi := &file_openshell_proto_msgTypes[38] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3853,7 +4026,7 @@ func (x *DeleteSandboxTemplateRequest) String() string { func (*DeleteSandboxTemplateRequest) ProtoMessage() {} func (x *DeleteSandboxTemplateRequest) 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 { @@ -3866,7 +4039,7 @@ func (x *DeleteSandboxTemplateRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteSandboxTemplateRequest.ProtoReflect.Descriptor instead. func (*DeleteSandboxTemplateRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{36} + return file_openshell_proto_rawDescGZIP(), []int{38} } func (x *DeleteSandboxTemplateRequest) GetWorkspaceScope() *datamodelv1.WorkspaceSelector { @@ -3906,7 +4079,7 @@ type SandboxTemplateResponse struct { func (x *SandboxTemplateResponse) Reset() { *x = SandboxTemplateResponse{} - mi := &file_openshell_proto_msgTypes[37] + mi := &file_openshell_proto_msgTypes[39] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3918,7 +4091,7 @@ func (x *SandboxTemplateResponse) String() string { func (*SandboxTemplateResponse) ProtoMessage() {} func (x *SandboxTemplateResponse) 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 { @@ -3931,7 +4104,7 @@ func (x *SandboxTemplateResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use SandboxTemplateResponse.ProtoReflect.Descriptor instead. func (*SandboxTemplateResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{37} + return file_openshell_proto_rawDescGZIP(), []int{39} } func (x *SandboxTemplateResponse) GetTemplate() *SandboxWorkloadTemplate { @@ -3952,7 +4125,7 @@ type ListSandboxTemplatesResponse struct { func (x *ListSandboxTemplatesResponse) Reset() { *x = ListSandboxTemplatesResponse{} - mi := &file_openshell_proto_msgTypes[38] + mi := &file_openshell_proto_msgTypes[40] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3964,7 +4137,7 @@ func (x *ListSandboxTemplatesResponse) String() string { func (*ListSandboxTemplatesResponse) ProtoMessage() {} func (x *ListSandboxTemplatesResponse) 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 { @@ -3977,7 +4150,7 @@ func (x *ListSandboxTemplatesResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListSandboxTemplatesResponse.ProtoReflect.Descriptor instead. func (*ListSandboxTemplatesResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{38} + return file_openshell_proto_rawDescGZIP(), []int{40} } func (x *ListSandboxTemplatesResponse) GetTemplates() []*SandboxWorkloadTemplate { @@ -4003,7 +4176,7 @@ type DeleteSandboxTemplateResponse struct { func (x *DeleteSandboxTemplateResponse) Reset() { *x = DeleteSandboxTemplateResponse{} - mi := &file_openshell_proto_msgTypes[39] + mi := &file_openshell_proto_msgTypes[41] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4015,7 +4188,7 @@ func (x *DeleteSandboxTemplateResponse) String() string { func (*DeleteSandboxTemplateResponse) ProtoMessage() {} func (x *DeleteSandboxTemplateResponse) 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 { @@ -4028,7 +4201,7 @@ func (x *DeleteSandboxTemplateResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteSandboxTemplateResponse.ProtoReflect.Descriptor instead. func (*DeleteSandboxTemplateResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{39} + return file_openshell_proto_rawDescGZIP(), []int{41} } func (x *DeleteSandboxTemplateResponse) GetOutcome() DeletionOutcome { @@ -4055,7 +4228,7 @@ type BeginRootfsTarStagingRequest struct { func (x *BeginRootfsTarStagingRequest) Reset() { *x = BeginRootfsTarStagingRequest{} - mi := &file_openshell_proto_msgTypes[40] + mi := &file_openshell_proto_msgTypes[42] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4067,7 +4240,7 @@ func (x *BeginRootfsTarStagingRequest) String() string { func (*BeginRootfsTarStagingRequest) ProtoMessage() {} func (x *BeginRootfsTarStagingRequest) 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 { @@ -4080,7 +4253,7 @@ func (x *BeginRootfsTarStagingRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use BeginRootfsTarStagingRequest.ProtoReflect.Descriptor instead. func (*BeginRootfsTarStagingRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{40} + return file_openshell_proto_rawDescGZIP(), []int{42} } func (x *BeginRootfsTarStagingRequest) GetWorkspaceScope() *datamodelv1.WorkspaceSelector { @@ -4123,7 +4296,7 @@ type BeginRootfsTarStagingResponse struct { func (x *BeginRootfsTarStagingResponse) Reset() { *x = BeginRootfsTarStagingResponse{} - mi := &file_openshell_proto_msgTypes[41] + mi := &file_openshell_proto_msgTypes[43] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4135,7 +4308,7 @@ func (x *BeginRootfsTarStagingResponse) String() string { func (*BeginRootfsTarStagingResponse) ProtoMessage() {} func (x *BeginRootfsTarStagingResponse) 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 { @@ -4148,7 +4321,7 @@ func (x *BeginRootfsTarStagingResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use BeginRootfsTarStagingResponse.ProtoReflect.Descriptor instead. func (*BeginRootfsTarStagingResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{41} + return file_openshell_proto_rawDescGZIP(), []int{43} } func (x *BeginRootfsTarStagingResponse) GetStagingToken() string { @@ -4191,7 +4364,7 @@ type GetSandboxRequest struct { func (x *GetSandboxRequest) Reset() { *x = GetSandboxRequest{} - mi := &file_openshell_proto_msgTypes[42] + mi := &file_openshell_proto_msgTypes[44] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4203,7 +4376,7 @@ func (x *GetSandboxRequest) String() string { func (*GetSandboxRequest) ProtoMessage() {} func (x *GetSandboxRequest) 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 { @@ -4216,7 +4389,7 @@ func (x *GetSandboxRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetSandboxRequest.ProtoReflect.Descriptor instead. func (*GetSandboxRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{42} + return file_openshell_proto_rawDescGZIP(), []int{44} } func (x *GetSandboxRequest) GetWorkspaceScope() *datamodelv1.WorkspaceSelector { @@ -4252,7 +4425,7 @@ type ListSandboxesRequest struct { func (x *ListSandboxesRequest) Reset() { *x = ListSandboxesRequest{} - mi := &file_openshell_proto_msgTypes[43] + mi := &file_openshell_proto_msgTypes[45] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4264,7 +4437,7 @@ func (x *ListSandboxesRequest) String() string { func (*ListSandboxesRequest) ProtoMessage() {} func (x *ListSandboxesRequest) 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 { @@ -4277,7 +4450,7 @@ func (x *ListSandboxesRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListSandboxesRequest.ProtoReflect.Descriptor instead. func (*ListSandboxesRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{43} + return file_openshell_proto_rawDescGZIP(), []int{45} } func (x *ListSandboxesRequest) GetWorkspaceScope() *datamodelv1.WorkspaceSelector { @@ -4326,7 +4499,7 @@ type ListSandboxProvidersRequest struct { func (x *ListSandboxProvidersRequest) Reset() { *x = ListSandboxProvidersRequest{} - mi := &file_openshell_proto_msgTypes[44] + mi := &file_openshell_proto_msgTypes[46] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4338,7 +4511,7 @@ func (x *ListSandboxProvidersRequest) String() string { func (*ListSandboxProvidersRequest) ProtoMessage() {} func (x *ListSandboxProvidersRequest) 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 { @@ -4351,7 +4524,7 @@ func (x *ListSandboxProvidersRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListSandboxProvidersRequest.ProtoReflect.Descriptor instead. func (*ListSandboxProvidersRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{44} + return file_openshell_proto_rawDescGZIP(), []int{46} } func (x *ListSandboxProvidersRequest) GetWorkspaceScope() *datamodelv1.WorkspaceSelector { @@ -4404,7 +4577,7 @@ type AttachSandboxProviderRequest struct { func (x *AttachSandboxProviderRequest) Reset() { *x = AttachSandboxProviderRequest{} - mi := &file_openshell_proto_msgTypes[45] + mi := &file_openshell_proto_msgTypes[47] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4416,7 +4589,7 @@ func (x *AttachSandboxProviderRequest) String() string { func (*AttachSandboxProviderRequest) ProtoMessage() {} func (x *AttachSandboxProviderRequest) 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 { @@ -4429,7 +4602,7 @@ func (x *AttachSandboxProviderRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use AttachSandboxProviderRequest.ProtoReflect.Descriptor instead. func (*AttachSandboxProviderRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{45} + return file_openshell_proto_rawDescGZIP(), []int{47} } func (x *AttachSandboxProviderRequest) GetWorkspaceScope() *datamodelv1.WorkspaceSelector { @@ -4489,7 +4662,7 @@ type DetachSandboxProviderRequest struct { func (x *DetachSandboxProviderRequest) Reset() { *x = DetachSandboxProviderRequest{} - mi := &file_openshell_proto_msgTypes[46] + mi := &file_openshell_proto_msgTypes[48] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4501,7 +4674,7 @@ func (x *DetachSandboxProviderRequest) String() string { func (*DetachSandboxProviderRequest) ProtoMessage() {} func (x *DetachSandboxProviderRequest) 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 { @@ -4514,7 +4687,7 @@ func (x *DetachSandboxProviderRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use DetachSandboxProviderRequest.ProtoReflect.Descriptor instead. func (*DetachSandboxProviderRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{46} + return file_openshell_proto_rawDescGZIP(), []int{48} } func (x *DetachSandboxProviderRequest) GetWorkspaceScope() *datamodelv1.WorkspaceSelector { @@ -4571,7 +4744,7 @@ type DeleteSandboxRequest struct { func (x *DeleteSandboxRequest) Reset() { *x = DeleteSandboxRequest{} - mi := &file_openshell_proto_msgTypes[47] + mi := &file_openshell_proto_msgTypes[49] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4583,7 +4756,7 @@ func (x *DeleteSandboxRequest) String() string { func (*DeleteSandboxRequest) ProtoMessage() {} func (x *DeleteSandboxRequest) 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 { @@ -4596,7 +4769,7 @@ func (x *DeleteSandboxRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteSandboxRequest.ProtoReflect.Descriptor instead. func (*DeleteSandboxRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{47} + return file_openshell_proto_rawDescGZIP(), []int{49} } func (x *DeleteSandboxRequest) GetWorkspaceScope() *datamodelv1.WorkspaceSelector { @@ -4642,7 +4815,7 @@ type StopSandboxRequest struct { func (x *StopSandboxRequest) Reset() { *x = StopSandboxRequest{} - mi := &file_openshell_proto_msgTypes[48] + mi := &file_openshell_proto_msgTypes[50] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4654,7 +4827,7 @@ func (x *StopSandboxRequest) String() string { func (*StopSandboxRequest) ProtoMessage() {} func (x *StopSandboxRequest) 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 { @@ -4667,7 +4840,7 @@ func (x *StopSandboxRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use StopSandboxRequest.ProtoReflect.Descriptor instead. func (*StopSandboxRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{48} + return file_openshell_proto_rawDescGZIP(), []int{50} } func (x *StopSandboxRequest) GetWorkspaceScope() *datamodelv1.WorkspaceSelector { @@ -4706,7 +4879,7 @@ type StartSandboxRequest struct { func (x *StartSandboxRequest) Reset() { *x = StartSandboxRequest{} - mi := &file_openshell_proto_msgTypes[49] + mi := &file_openshell_proto_msgTypes[51] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4718,7 +4891,7 @@ func (x *StartSandboxRequest) String() string { func (*StartSandboxRequest) ProtoMessage() {} func (x *StartSandboxRequest) 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 { @@ -4731,7 +4904,7 @@ func (x *StartSandboxRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use StartSandboxRequest.ProtoReflect.Descriptor instead. func (*StartSandboxRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{49} + return file_openshell_proto_rawDescGZIP(), []int{51} } func (x *StartSandboxRequest) GetWorkspaceScope() *datamodelv1.WorkspaceSelector { @@ -4768,7 +4941,7 @@ type SandboxResponse struct { func (x *SandboxResponse) Reset() { *x = SandboxResponse{} - mi := &file_openshell_proto_msgTypes[50] + mi := &file_openshell_proto_msgTypes[52] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4780,7 +4953,7 @@ func (x *SandboxResponse) String() string { func (*SandboxResponse) ProtoMessage() {} func (x *SandboxResponse) 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 { @@ -4793,7 +4966,7 @@ func (x *SandboxResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use SandboxResponse.ProtoReflect.Descriptor instead. func (*SandboxResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{50} + return file_openshell_proto_rawDescGZIP(), []int{52} } func (x *SandboxResponse) GetSandbox() *Sandbox { @@ -4822,7 +4995,7 @@ type ListSandboxesResponse struct { func (x *ListSandboxesResponse) Reset() { *x = ListSandboxesResponse{} - mi := &file_openshell_proto_msgTypes[51] + mi := &file_openshell_proto_msgTypes[53] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4834,7 +5007,7 @@ func (x *ListSandboxesResponse) String() string { func (*ListSandboxesResponse) ProtoMessage() {} func (x *ListSandboxesResponse) 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 { @@ -4847,7 +5020,7 @@ func (x *ListSandboxesResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListSandboxesResponse.ProtoReflect.Descriptor instead. func (*ListSandboxesResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{51} + return file_openshell_proto_rawDescGZIP(), []int{53} } func (x *ListSandboxesResponse) GetSandboxes() []*Sandbox { @@ -4876,7 +5049,7 @@ type ListSandboxProvidersResponse struct { func (x *ListSandboxProvidersResponse) Reset() { *x = ListSandboxProvidersResponse{} - mi := &file_openshell_proto_msgTypes[52] + mi := &file_openshell_proto_msgTypes[54] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4888,7 +5061,7 @@ func (x *ListSandboxProvidersResponse) String() string { func (*ListSandboxProvidersResponse) ProtoMessage() {} func (x *ListSandboxProvidersResponse) 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 { @@ -4901,7 +5074,7 @@ func (x *ListSandboxProvidersResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListSandboxProvidersResponse.ProtoReflect.Descriptor instead. func (*ListSandboxProvidersResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{52} + return file_openshell_proto_rawDescGZIP(), []int{54} } func (x *ListSandboxProvidersResponse) GetProviders() []*datamodelv1.Provider { @@ -4932,7 +5105,7 @@ type AttachSandboxProviderResponse struct { func (x *AttachSandboxProviderResponse) Reset() { *x = AttachSandboxProviderResponse{} - mi := &file_openshell_proto_msgTypes[53] + mi := &file_openshell_proto_msgTypes[55] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4944,7 +5117,7 @@ func (x *AttachSandboxProviderResponse) String() string { func (*AttachSandboxProviderResponse) ProtoMessage() {} func (x *AttachSandboxProviderResponse) 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 { @@ -4957,7 +5130,7 @@ func (x *AttachSandboxProviderResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use AttachSandboxProviderResponse.ProtoReflect.Descriptor instead. func (*AttachSandboxProviderResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{53} + return file_openshell_proto_rawDescGZIP(), []int{55} } func (x *AttachSandboxProviderResponse) GetSandbox() *Sandbox { @@ -4995,7 +5168,7 @@ type DetachSandboxProviderResponse struct { func (x *DetachSandboxProviderResponse) Reset() { *x = DetachSandboxProviderResponse{} - mi := &file_openshell_proto_msgTypes[54] + mi := &file_openshell_proto_msgTypes[56] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5007,7 +5180,7 @@ func (x *DetachSandboxProviderResponse) String() string { func (*DetachSandboxProviderResponse) ProtoMessage() {} func (x *DetachSandboxProviderResponse) 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 { @@ -5020,7 +5193,7 @@ func (x *DetachSandboxProviderResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use DetachSandboxProviderResponse.ProtoReflect.Descriptor instead. func (*DetachSandboxProviderResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{54} + return file_openshell_proto_rawDescGZIP(), []int{56} } func (x *DetachSandboxProviderResponse) GetSandbox() *Sandbox { @@ -5062,7 +5235,7 @@ type ProviderDesiredIdentity struct { func (x *ProviderDesiredIdentity) Reset() { *x = ProviderDesiredIdentity{} - mi := &file_openshell_proto_msgTypes[55] + mi := &file_openshell_proto_msgTypes[57] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5074,7 +5247,7 @@ func (x *ProviderDesiredIdentity) String() string { func (*ProviderDesiredIdentity) ProtoMessage() {} func (x *ProviderDesiredIdentity) 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 { @@ -5087,7 +5260,7 @@ func (x *ProviderDesiredIdentity) ProtoReflect() protoreflect.Message { // Deprecated: Use ProviderDesiredIdentity.ProtoReflect.Descriptor instead. func (*ProviderDesiredIdentity) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{55} + return file_openshell_proto_rawDescGZIP(), []int{57} } func (x *ProviderDesiredIdentity) GetSandboxId() string { @@ -5162,7 +5335,7 @@ type ConfigSnapshotRevision struct { func (x *ConfigSnapshotRevision) Reset() { *x = ConfigSnapshotRevision{} - mi := &file_openshell_proto_msgTypes[56] + mi := &file_openshell_proto_msgTypes[58] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5174,7 +5347,7 @@ func (x *ConfigSnapshotRevision) String() string { func (*ConfigSnapshotRevision) ProtoMessage() {} func (x *ConfigSnapshotRevision) 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 { @@ -5187,7 +5360,7 @@ func (x *ConfigSnapshotRevision) ProtoReflect() protoreflect.Message { // Deprecated: Use ConfigSnapshotRevision.ProtoReflect.Descriptor instead. func (*ConfigSnapshotRevision) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{56} + return file_openshell_proto_rawDescGZIP(), []int{58} } func (x *ConfigSnapshotRevision) GetComponent() isConfigSnapshotRevision_Component { @@ -5264,7 +5437,7 @@ type SandboxConfigRevision struct { func (x *SandboxConfigRevision) Reset() { *x = SandboxConfigRevision{} - mi := &file_openshell_proto_msgTypes[57] + mi := &file_openshell_proto_msgTypes[59] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5276,7 +5449,7 @@ func (x *SandboxConfigRevision) String() string { func (*SandboxConfigRevision) ProtoMessage() {} func (x *SandboxConfigRevision) 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 { @@ -5289,7 +5462,7 @@ func (x *SandboxConfigRevision) ProtoReflect() protoreflect.Message { // Deprecated: Use SandboxConfigRevision.ProtoReflect.Descriptor instead. func (*SandboxConfigRevision) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{57} + return file_openshell_proto_rawDescGZIP(), []int{59} } func (x *SandboxConfigRevision) GetConfigRevision() uint64 { @@ -5348,7 +5521,7 @@ type ConfigUpdateOperation struct { func (x *ConfigUpdateOperation) Reset() { *x = ConfigUpdateOperation{} - mi := &file_openshell_proto_msgTypes[58] + mi := &file_openshell_proto_msgTypes[60] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5360,7 +5533,7 @@ func (x *ConfigUpdateOperation) String() string { func (*ConfigUpdateOperation) ProtoMessage() {} func (x *ConfigUpdateOperation) 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 { @@ -5373,7 +5546,7 @@ func (x *ConfigUpdateOperation) ProtoReflect() protoreflect.Message { // Deprecated: Use ConfigUpdateOperation.ProtoReflect.Descriptor instead. func (*ConfigUpdateOperation) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{58} + return file_openshell_proto_rawDescGZIP(), []int{60} } func (x *ConfigUpdateOperation) GetOperationId() string { @@ -5463,7 +5636,7 @@ type ProviderMutationReceipt struct { func (x *ProviderMutationReceipt) Reset() { *x = ProviderMutationReceipt{} - mi := &file_openshell_proto_msgTypes[59] + mi := &file_openshell_proto_msgTypes[61] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5475,7 +5648,7 @@ func (x *ProviderMutationReceipt) String() string { func (*ProviderMutationReceipt) ProtoMessage() {} func (x *ProviderMutationReceipt) 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 { @@ -5488,7 +5661,7 @@ func (x *ProviderMutationReceipt) ProtoReflect() protoreflect.Message { // Deprecated: Use ProviderMutationReceipt.ProtoReflect.Descriptor instead. func (*ProviderMutationReceipt) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{59} + return file_openshell_proto_rawDescGZIP(), []int{61} } func (x *ProviderMutationReceipt) GetReceiptId() string { @@ -5564,7 +5737,7 @@ type ProviderReadinessObservation struct { func (x *ProviderReadinessObservation) Reset() { *x = ProviderReadinessObservation{} - mi := &file_openshell_proto_msgTypes[60] + mi := &file_openshell_proto_msgTypes[62] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5576,7 +5749,7 @@ func (x *ProviderReadinessObservation) String() string { func (*ProviderReadinessObservation) ProtoMessage() {} func (x *ProviderReadinessObservation) 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 { @@ -5589,7 +5762,7 @@ func (x *ProviderReadinessObservation) ProtoReflect() protoreflect.Message { // Deprecated: Use ProviderReadinessObservation.ProtoReflect.Descriptor instead. func (*ProviderReadinessObservation) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{60} + return file_openshell_proto_rawDescGZIP(), []int{62} } func (x *ProviderReadinessObservation) GetSessionId() string { @@ -5688,7 +5861,7 @@ type ProviderReadinessStatus struct { func (x *ProviderReadinessStatus) Reset() { *x = ProviderReadinessStatus{} - mi := &file_openshell_proto_msgTypes[61] + mi := &file_openshell_proto_msgTypes[63] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5700,7 +5873,7 @@ func (x *ProviderReadinessStatus) String() string { func (*ProviderReadinessStatus) ProtoMessage() {} func (x *ProviderReadinessStatus) 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 { @@ -5713,7 +5886,7 @@ func (x *ProviderReadinessStatus) ProtoReflect() protoreflect.Message { // Deprecated: Use ProviderReadinessStatus.ProtoReflect.Descriptor instead. func (*ProviderReadinessStatus) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{61} + return file_openshell_proto_rawDescGZIP(), []int{63} } func (x *ProviderReadinessStatus) GetReceipt() *ProviderMutationReceipt { @@ -5787,7 +5960,7 @@ type GetSandboxProviderStatusRequest struct { func (x *GetSandboxProviderStatusRequest) Reset() { *x = GetSandboxProviderStatusRequest{} - mi := &file_openshell_proto_msgTypes[62] + mi := &file_openshell_proto_msgTypes[64] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5799,7 +5972,7 @@ func (x *GetSandboxProviderStatusRequest) String() string { func (*GetSandboxProviderStatusRequest) ProtoMessage() {} func (x *GetSandboxProviderStatusRequest) 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 { @@ -5812,7 +5985,7 @@ func (x *GetSandboxProviderStatusRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetSandboxProviderStatusRequest.ProtoReflect.Descriptor instead. func (*GetSandboxProviderStatusRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{62} + return file_openshell_proto_rawDescGZIP(), []int{64} } func (x *GetSandboxProviderStatusRequest) GetWorkspaceScope() *datamodelv1.WorkspaceSelector { @@ -5852,7 +6025,7 @@ type GetSandboxProviderStatusResponse struct { func (x *GetSandboxProviderStatusResponse) Reset() { *x = GetSandboxProviderStatusResponse{} - mi := &file_openshell_proto_msgTypes[63] + mi := &file_openshell_proto_msgTypes[65] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5864,7 +6037,7 @@ func (x *GetSandboxProviderStatusResponse) String() string { func (*GetSandboxProviderStatusResponse) ProtoMessage() {} func (x *GetSandboxProviderStatusResponse) 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 { @@ -5877,7 +6050,7 @@ func (x *GetSandboxProviderStatusResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use GetSandboxProviderStatusResponse.ProtoReflect.Descriptor instead. func (*GetSandboxProviderStatusResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{63} + return file_openshell_proto_rawDescGZIP(), []int{65} } func (x *GetSandboxProviderStatusResponse) GetStatus() *ProviderReadinessStatus { @@ -5899,7 +6072,7 @@ type ReportProviderReadinessRequest struct { func (x *ReportProviderReadinessRequest) Reset() { *x = ReportProviderReadinessRequest{} - mi := &file_openshell_proto_msgTypes[64] + mi := &file_openshell_proto_msgTypes[66] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5911,7 +6084,7 @@ func (x *ReportProviderReadinessRequest) String() string { func (*ReportProviderReadinessRequest) ProtoMessage() {} func (x *ReportProviderReadinessRequest) 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 { @@ -5924,7 +6097,7 @@ func (x *ReportProviderReadinessRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ReportProviderReadinessRequest.ProtoReflect.Descriptor instead. func (*ReportProviderReadinessRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{64} + return file_openshell_proto_rawDescGZIP(), []int{66} } func (x *ReportProviderReadinessRequest) GetSandboxId() string { @@ -5954,7 +6127,7 @@ type ReportProviderReadinessResponse struct { func (x *ReportProviderReadinessResponse) Reset() { *x = ReportProviderReadinessResponse{} - mi := &file_openshell_proto_msgTypes[65] + mi := &file_openshell_proto_msgTypes[67] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5966,7 +6139,7 @@ func (x *ReportProviderReadinessResponse) String() string { func (*ReportProviderReadinessResponse) ProtoMessage() {} func (x *ReportProviderReadinessResponse) 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 { @@ -5979,7 +6152,7 @@ func (x *ReportProviderReadinessResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ReportProviderReadinessResponse.ProtoReflect.Descriptor instead. func (*ReportProviderReadinessResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{65} + return file_openshell_proto_rawDescGZIP(), []int{67} } func (x *ReportProviderReadinessResponse) GetAcceptedSequence() uint64 { @@ -6016,7 +6189,7 @@ type DeleteSandboxResponse struct { func (x *DeleteSandboxResponse) Reset() { *x = DeleteSandboxResponse{} - mi := &file_openshell_proto_msgTypes[66] + mi := &file_openshell_proto_msgTypes[68] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6028,7 +6201,7 @@ func (x *DeleteSandboxResponse) String() string { func (*DeleteSandboxResponse) ProtoMessage() {} func (x *DeleteSandboxResponse) 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 { @@ -6041,7 +6214,7 @@ func (x *DeleteSandboxResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteSandboxResponse.ProtoReflect.Descriptor instead. func (*DeleteSandboxResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{66} + return file_openshell_proto_rawDescGZIP(), []int{68} } func (x *DeleteSandboxResponse) GetOutcome() DeletionOutcome { @@ -6070,7 +6243,7 @@ type CreateSshSessionRequest struct { func (x *CreateSshSessionRequest) Reset() { *x = CreateSshSessionRequest{} - mi := &file_openshell_proto_msgTypes[67] + mi := &file_openshell_proto_msgTypes[69] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6082,7 +6255,7 @@ func (x *CreateSshSessionRequest) String() string { func (*CreateSshSessionRequest) ProtoMessage() {} func (x *CreateSshSessionRequest) 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 { @@ -6095,7 +6268,7 @@ func (x *CreateSshSessionRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use CreateSshSessionRequest.ProtoReflect.Descriptor instead. func (*CreateSshSessionRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{67} + return file_openshell_proto_rawDescGZIP(), []int{69} } func (x *CreateSshSessionRequest) GetWorkspaceScope() *datamodelv1.WorkspaceSelector { @@ -6146,7 +6319,7 @@ type CreateSshSessionResponse struct { func (x *CreateSshSessionResponse) Reset() { *x = CreateSshSessionResponse{} - mi := &file_openshell_proto_msgTypes[68] + mi := &file_openshell_proto_msgTypes[70] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6158,7 +6331,7 @@ func (x *CreateSshSessionResponse) String() string { func (*CreateSshSessionResponse) ProtoMessage() {} func (x *CreateSshSessionResponse) 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 { @@ -6171,7 +6344,7 @@ func (x *CreateSshSessionResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use CreateSshSessionResponse.ProtoReflect.Descriptor instead. func (*CreateSshSessionResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{68} + return file_openshell_proto_rawDescGZIP(), []int{70} } func (x *CreateSshSessionResponse) GetSandboxId() string { @@ -6246,7 +6419,7 @@ type ExposeServiceRequest struct { func (x *ExposeServiceRequest) Reset() { *x = ExposeServiceRequest{} - mi := &file_openshell_proto_msgTypes[69] + mi := &file_openshell_proto_msgTypes[71] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6258,7 +6431,7 @@ func (x *ExposeServiceRequest) String() string { func (*ExposeServiceRequest) ProtoMessage() {} func (x *ExposeServiceRequest) 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 { @@ -6271,7 +6444,7 @@ func (x *ExposeServiceRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ExposeServiceRequest.ProtoReflect.Descriptor instead. func (*ExposeServiceRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{69} + return file_openshell_proto_rawDescGZIP(), []int{71} } func (x *ExposeServiceRequest) GetWorkspaceScope() *datamodelv1.WorkspaceSelector { @@ -6337,7 +6510,7 @@ type GetServiceRequest struct { func (x *GetServiceRequest) Reset() { *x = GetServiceRequest{} - mi := &file_openshell_proto_msgTypes[70] + mi := &file_openshell_proto_msgTypes[72] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6349,7 +6522,7 @@ func (x *GetServiceRequest) String() string { func (*GetServiceRequest) ProtoMessage() {} func (x *GetServiceRequest) 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 { @@ -6362,7 +6535,7 @@ func (x *GetServiceRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetServiceRequest.ProtoReflect.Descriptor instead. func (*GetServiceRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{70} + return file_openshell_proto_rawDescGZIP(), []int{72} } func (x *GetServiceRequest) GetWorkspaceScope() *datamodelv1.WorkspaceSelector { @@ -6405,7 +6578,7 @@ type ListServicesRequest struct { func (x *ListServicesRequest) Reset() { *x = ListServicesRequest{} - mi := &file_openshell_proto_msgTypes[71] + mi := &file_openshell_proto_msgTypes[73] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6417,7 +6590,7 @@ func (x *ListServicesRequest) String() string { func (*ListServicesRequest) ProtoMessage() {} func (x *ListServicesRequest) 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 { @@ -6430,7 +6603,7 @@ func (x *ListServicesRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListServicesRequest.ProtoReflect.Descriptor instead. func (*ListServicesRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{71} + return file_openshell_proto_rawDescGZIP(), []int{73} } func (x *ListServicesRequest) GetWorkspaceScope() *datamodelv1.WorkspaceSelector { @@ -6473,7 +6646,7 @@ type ListServicesResponse struct { func (x *ListServicesResponse) Reset() { *x = ListServicesResponse{} - mi := &file_openshell_proto_msgTypes[72] + mi := &file_openshell_proto_msgTypes[74] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6485,7 +6658,7 @@ func (x *ListServicesResponse) String() string { func (*ListServicesResponse) ProtoMessage() {} func (x *ListServicesResponse) 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 { @@ -6498,7 +6671,7 @@ func (x *ListServicesResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListServicesResponse.ProtoReflect.Descriptor instead. func (*ListServicesResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{72} + return file_openshell_proto_rawDescGZIP(), []int{74} } func (x *ListServicesResponse) GetServices() []*ServiceEndpointResponse { @@ -6533,7 +6706,7 @@ type DeleteServiceRequest struct { func (x *DeleteServiceRequest) Reset() { *x = DeleteServiceRequest{} - mi := &file_openshell_proto_msgTypes[73] + mi := &file_openshell_proto_msgTypes[75] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6545,7 +6718,7 @@ func (x *DeleteServiceRequest) String() string { func (*DeleteServiceRequest) ProtoMessage() {} func (x *DeleteServiceRequest) 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 { @@ -6558,7 +6731,7 @@ func (x *DeleteServiceRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteServiceRequest.ProtoReflect.Descriptor instead. func (*DeleteServiceRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{73} + return file_openshell_proto_rawDescGZIP(), []int{75} } func (x *DeleteServiceRequest) GetWorkspaceScope() *datamodelv1.WorkspaceSelector { @@ -6606,7 +6779,7 @@ type DeleteServiceResponse struct { func (x *DeleteServiceResponse) Reset() { *x = DeleteServiceResponse{} - mi := &file_openshell_proto_msgTypes[74] + mi := &file_openshell_proto_msgTypes[76] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6618,7 +6791,7 @@ func (x *DeleteServiceResponse) String() string { func (*DeleteServiceResponse) ProtoMessage() {} func (x *DeleteServiceResponse) 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 { @@ -6631,7 +6804,7 @@ func (x *DeleteServiceResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteServiceResponse.ProtoReflect.Descriptor instead. func (*DeleteServiceResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{74} + return file_openshell_proto_rawDescGZIP(), []int{76} } func (x *DeleteServiceResponse) GetOutcome() DeletionOutcome { @@ -6664,7 +6837,7 @@ type ServiceEndpoint struct { func (x *ServiceEndpoint) Reset() { *x = ServiceEndpoint{} - mi := &file_openshell_proto_msgTypes[75] + mi := &file_openshell_proto_msgTypes[77] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6676,7 +6849,7 @@ func (x *ServiceEndpoint) String() string { func (*ServiceEndpoint) ProtoMessage() {} func (x *ServiceEndpoint) 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 { @@ -6689,7 +6862,7 @@ func (x *ServiceEndpoint) ProtoReflect() protoreflect.Message { // Deprecated: Use ServiceEndpoint.ProtoReflect.Descriptor instead. func (*ServiceEndpoint) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{75} + return file_openshell_proto_rawDescGZIP(), []int{77} } func (x *ServiceEndpoint) GetMetadata() *datamodelv1.ObjectMeta { @@ -6752,7 +6925,7 @@ type ServiceEndpointResponse struct { func (x *ServiceEndpointResponse) Reset() { *x = ServiceEndpointResponse{} - mi := &file_openshell_proto_msgTypes[76] + mi := &file_openshell_proto_msgTypes[78] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6764,7 +6937,7 @@ func (x *ServiceEndpointResponse) String() string { func (*ServiceEndpointResponse) ProtoMessage() {} func (x *ServiceEndpointResponse) 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 { @@ -6777,7 +6950,7 @@ func (x *ServiceEndpointResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ServiceEndpointResponse.ProtoReflect.Descriptor instead. func (*ServiceEndpointResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{76} + return file_openshell_proto_rawDescGZIP(), []int{78} } func (x *ServiceEndpointResponse) GetEndpoint() *ServiceEndpoint { @@ -6808,7 +6981,7 @@ type RevokeSshSessionRequest struct { func (x *RevokeSshSessionRequest) Reset() { *x = RevokeSshSessionRequest{} - mi := &file_openshell_proto_msgTypes[77] + mi := &file_openshell_proto_msgTypes[79] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6820,7 +6993,7 @@ func (x *RevokeSshSessionRequest) String() string { func (*RevokeSshSessionRequest) ProtoMessage() {} func (x *RevokeSshSessionRequest) 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 { @@ -6833,7 +7006,7 @@ func (x *RevokeSshSessionRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use RevokeSshSessionRequest.ProtoReflect.Descriptor instead. func (*RevokeSshSessionRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{77} + return file_openshell_proto_rawDescGZIP(), []int{79} } func (x *RevokeSshSessionRequest) GetToken() string { @@ -6860,7 +7033,7 @@ type RevokeSshSessionResponse struct { func (x *RevokeSshSessionResponse) Reset() { *x = RevokeSshSessionResponse{} - mi := &file_openshell_proto_msgTypes[78] + mi := &file_openshell_proto_msgTypes[80] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6872,7 +7045,7 @@ func (x *RevokeSshSessionResponse) String() string { func (*RevokeSshSessionResponse) ProtoMessage() {} func (x *RevokeSshSessionResponse) 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 { @@ -6885,7 +7058,7 @@ func (x *RevokeSshSessionResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use RevokeSshSessionResponse.ProtoReflect.Descriptor instead. func (*RevokeSshSessionResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{78} + return file_openshell_proto_rawDescGZIP(), []int{80} } func (x *RevokeSshSessionResponse) GetOutcome() DeletionOutcome { @@ -6935,7 +7108,7 @@ type ExecSandboxRequest struct { func (x *ExecSandboxRequest) Reset() { *x = ExecSandboxRequest{} - mi := &file_openshell_proto_msgTypes[79] + mi := &file_openshell_proto_msgTypes[81] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6947,7 +7120,7 @@ func (x *ExecSandboxRequest) String() string { func (*ExecSandboxRequest) ProtoMessage() {} func (x *ExecSandboxRequest) 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 { @@ -6960,7 +7133,7 @@ func (x *ExecSandboxRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ExecSandboxRequest.ProtoReflect.Descriptor instead. func (*ExecSandboxRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{79} + return file_openshell_proto_rawDescGZIP(), []int{81} } func (x *ExecSandboxRequest) GetWorkspaceScope() *datamodelv1.WorkspaceSelector { @@ -7057,7 +7230,7 @@ type ExecSandboxStdout struct { func (x *ExecSandboxStdout) Reset() { *x = ExecSandboxStdout{} - mi := &file_openshell_proto_msgTypes[80] + mi := &file_openshell_proto_msgTypes[82] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7069,7 +7242,7 @@ func (x *ExecSandboxStdout) String() string { func (*ExecSandboxStdout) ProtoMessage() {} func (x *ExecSandboxStdout) 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 { @@ -7082,7 +7255,7 @@ func (x *ExecSandboxStdout) ProtoReflect() protoreflect.Message { // Deprecated: Use ExecSandboxStdout.ProtoReflect.Descriptor instead. func (*ExecSandboxStdout) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{80} + return file_openshell_proto_rawDescGZIP(), []int{82} } func (x *ExecSandboxStdout) GetData() []byte { @@ -7102,7 +7275,7 @@ type ExecSandboxStderr struct { func (x *ExecSandboxStderr) Reset() { *x = ExecSandboxStderr{} - mi := &file_openshell_proto_msgTypes[81] + mi := &file_openshell_proto_msgTypes[83] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7114,7 +7287,7 @@ func (x *ExecSandboxStderr) String() string { func (*ExecSandboxStderr) ProtoMessage() {} func (x *ExecSandboxStderr) 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 { @@ -7127,7 +7300,7 @@ func (x *ExecSandboxStderr) ProtoReflect() protoreflect.Message { // Deprecated: Use ExecSandboxStderr.ProtoReflect.Descriptor instead. func (*ExecSandboxStderr) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{81} + return file_openshell_proto_rawDescGZIP(), []int{83} } func (x *ExecSandboxStderr) GetData() []byte { @@ -7147,7 +7320,7 @@ type ExecSandboxExit struct { func (x *ExecSandboxExit) Reset() { *x = ExecSandboxExit{} - mi := &file_openshell_proto_msgTypes[82] + mi := &file_openshell_proto_msgTypes[84] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7159,7 +7332,7 @@ func (x *ExecSandboxExit) String() string { func (*ExecSandboxExit) ProtoMessage() {} func (x *ExecSandboxExit) 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 { @@ -7172,7 +7345,7 @@ func (x *ExecSandboxExit) ProtoReflect() protoreflect.Message { // Deprecated: Use ExecSandboxExit.ProtoReflect.Descriptor instead. func (*ExecSandboxExit) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{82} + return file_openshell_proto_rawDescGZIP(), []int{84} } func (x *ExecSandboxExit) GetExitCode() int32 { @@ -7197,7 +7370,7 @@ type ExecSandboxEvent struct { func (x *ExecSandboxEvent) Reset() { *x = ExecSandboxEvent{} - mi := &file_openshell_proto_msgTypes[83] + mi := &file_openshell_proto_msgTypes[85] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7209,7 +7382,7 @@ func (x *ExecSandboxEvent) String() string { func (*ExecSandboxEvent) ProtoMessage() {} func (x *ExecSandboxEvent) 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 { @@ -7222,7 +7395,7 @@ func (x *ExecSandboxEvent) ProtoReflect() protoreflect.Message { // Deprecated: Use ExecSandboxEvent.ProtoReflect.Descriptor instead. func (*ExecSandboxEvent) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{83} + return file_openshell_proto_rawDescGZIP(), []int{85} } func (x *ExecSandboxEvent) GetPayload() isExecSandboxEvent_Payload { @@ -7304,7 +7477,7 @@ type TcpForwardInit struct { func (x *TcpForwardInit) Reset() { *x = TcpForwardInit{} - mi := &file_openshell_proto_msgTypes[84] + mi := &file_openshell_proto_msgTypes[86] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7316,7 +7489,7 @@ func (x *TcpForwardInit) String() string { func (*TcpForwardInit) ProtoMessage() {} func (x *TcpForwardInit) 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 { @@ -7329,7 +7502,7 @@ func (x *TcpForwardInit) ProtoReflect() protoreflect.Message { // Deprecated: Use TcpForwardInit.ProtoReflect.Descriptor instead. func (*TcpForwardInit) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{84} + return file_openshell_proto_rawDescGZIP(), []int{86} } func (x *TcpForwardInit) GetSandbox() string { @@ -7415,7 +7588,7 @@ type TcpForwardFrame struct { func (x *TcpForwardFrame) Reset() { *x = TcpForwardFrame{} - mi := &file_openshell_proto_msgTypes[85] + mi := &file_openshell_proto_msgTypes[87] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7427,7 +7600,7 @@ func (x *TcpForwardFrame) String() string { func (*TcpForwardFrame) ProtoMessage() {} func (x *TcpForwardFrame) 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 { @@ -7440,7 +7613,7 @@ func (x *TcpForwardFrame) ProtoReflect() protoreflect.Message { // Deprecated: Use TcpForwardFrame.ProtoReflect.Descriptor instead. func (*TcpForwardFrame) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{85} + return file_openshell_proto_rawDescGZIP(), []int{87} } func (x *TcpForwardFrame) GetPayload() isTcpForwardFrame_Payload { @@ -7499,7 +7672,7 @@ type ExecSandboxInput struct { func (x *ExecSandboxInput) Reset() { *x = ExecSandboxInput{} - mi := &file_openshell_proto_msgTypes[86] + mi := &file_openshell_proto_msgTypes[88] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7511,7 +7684,7 @@ func (x *ExecSandboxInput) String() string { func (*ExecSandboxInput) ProtoMessage() {} func (x *ExecSandboxInput) 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 { @@ -7524,7 +7697,7 @@ func (x *ExecSandboxInput) ProtoReflect() protoreflect.Message { // Deprecated: Use ExecSandboxInput.ProtoReflect.Descriptor instead. func (*ExecSandboxInput) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{86} + return file_openshell_proto_rawDescGZIP(), []int{88} } func (x *ExecSandboxInput) GetPayload() isExecSandboxInput_Payload { @@ -7597,7 +7770,7 @@ type ExecSandboxWindowResize struct { func (x *ExecSandboxWindowResize) Reset() { *x = ExecSandboxWindowResize{} - mi := &file_openshell_proto_msgTypes[87] + mi := &file_openshell_proto_msgTypes[89] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7609,7 +7782,7 @@ func (x *ExecSandboxWindowResize) String() string { func (*ExecSandboxWindowResize) ProtoMessage() {} func (x *ExecSandboxWindowResize) 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 { @@ -7622,7 +7795,7 @@ func (x *ExecSandboxWindowResize) ProtoReflect() protoreflect.Message { // Deprecated: Use ExecSandboxWindowResize.ProtoReflect.Descriptor instead. func (*ExecSandboxWindowResize) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{87} + return file_openshell_proto_rawDescGZIP(), []int{89} } func (x *ExecSandboxWindowResize) GetCols() uint32 { @@ -7658,7 +7831,7 @@ type SshSession struct { func (x *SshSession) Reset() { *x = SshSession{} - mi := &file_openshell_proto_msgTypes[88] + mi := &file_openshell_proto_msgTypes[90] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7670,7 +7843,7 @@ func (x *SshSession) String() string { func (*SshSession) ProtoMessage() {} func (x *SshSession) 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 { @@ -7683,7 +7856,7 @@ func (x *SshSession) ProtoReflect() protoreflect.Message { // Deprecated: Use SshSession.ProtoReflect.Descriptor instead. func (*SshSession) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{88} + return file_openshell_proto_rawDescGZIP(), []int{90} } func (x *SshSession) GetMetadata() *datamodelv1.ObjectMeta { @@ -7772,7 +7945,7 @@ type WatchSandboxRequest struct { func (x *WatchSandboxRequest) Reset() { *x = WatchSandboxRequest{} - mi := &file_openshell_proto_msgTypes[89] + mi := &file_openshell_proto_msgTypes[91] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7784,7 +7957,7 @@ func (x *WatchSandboxRequest) String() string { func (*WatchSandboxRequest) ProtoMessage() {} func (x *WatchSandboxRequest) 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 { @@ -7797,7 +7970,7 @@ func (x *WatchSandboxRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use WatchSandboxRequest.ProtoReflect.Descriptor instead. func (*WatchSandboxRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{89} + return file_openshell_proto_rawDescGZIP(), []int{91} } func (x *WatchSandboxRequest) GetWorkspaceScope() *datamodelv1.WorkspaceSelector { @@ -7913,7 +8086,7 @@ type SandboxStreamEvent struct { func (x *SandboxStreamEvent) Reset() { *x = SandboxStreamEvent{} - mi := &file_openshell_proto_msgTypes[90] + mi := &file_openshell_proto_msgTypes[92] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7925,7 +8098,7 @@ func (x *SandboxStreamEvent) String() string { func (*SandboxStreamEvent) ProtoMessage() {} func (x *SandboxStreamEvent) 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 { @@ -7938,7 +8111,7 @@ func (x *SandboxStreamEvent) ProtoReflect() protoreflect.Message { // Deprecated: Use SandboxStreamEvent.ProtoReflect.Descriptor instead. func (*SandboxStreamEvent) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{90} + return file_openshell_proto_rawDescGZIP(), []int{92} } func (x *SandboxStreamEvent) GetPayload() isSandboxStreamEvent_Payload { @@ -8060,7 +8233,7 @@ type SandboxLogLine struct { func (x *SandboxLogLine) Reset() { *x = SandboxLogLine{} - mi := &file_openshell_proto_msgTypes[91] + mi := &file_openshell_proto_msgTypes[93] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8072,7 +8245,7 @@ func (x *SandboxLogLine) String() string { func (*SandboxLogLine) ProtoMessage() {} func (x *SandboxLogLine) 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 { @@ -8085,7 +8258,7 @@ func (x *SandboxLogLine) ProtoReflect() protoreflect.Message { // Deprecated: Use SandboxLogLine.ProtoReflect.Descriptor instead. func (*SandboxLogLine) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{91} + return file_openshell_proto_rawDescGZIP(), []int{93} } func (x *SandboxLogLine) GetSandboxId() string { @@ -8151,7 +8324,7 @@ type SandboxStreamWarning struct { func (x *SandboxStreamWarning) Reset() { *x = SandboxStreamWarning{} - mi := &file_openshell_proto_msgTypes[92] + mi := &file_openshell_proto_msgTypes[94] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8163,7 +8336,7 @@ func (x *SandboxStreamWarning) String() string { func (*SandboxStreamWarning) ProtoMessage() {} func (x *SandboxStreamWarning) 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 { @@ -8176,7 +8349,7 @@ func (x *SandboxStreamWarning) ProtoReflect() protoreflect.Message { // Deprecated: Use SandboxStreamWarning.ProtoReflect.Descriptor instead. func (*SandboxStreamWarning) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{92} + return file_openshell_proto_rawDescGZIP(), []int{94} } func (x *SandboxStreamWarning) GetMessage() string { @@ -8201,7 +8374,7 @@ type CreateProviderRequest struct { func (x *CreateProviderRequest) Reset() { *x = CreateProviderRequest{} - mi := &file_openshell_proto_msgTypes[93] + mi := &file_openshell_proto_msgTypes[95] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8213,7 +8386,7 @@ func (x *CreateProviderRequest) String() string { func (*CreateProviderRequest) ProtoMessage() {} func (x *CreateProviderRequest) 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 { @@ -8226,7 +8399,7 @@ func (x *CreateProviderRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use CreateProviderRequest.ProtoReflect.Descriptor instead. func (*CreateProviderRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{93} + return file_openshell_proto_rawDescGZIP(), []int{95} } func (x *CreateProviderRequest) GetWorkspaceScope() *datamodelv1.WorkspaceSelector { @@ -8262,7 +8435,7 @@ type GetProviderRequest struct { func (x *GetProviderRequest) Reset() { *x = GetProviderRequest{} - mi := &file_openshell_proto_msgTypes[94] + mi := &file_openshell_proto_msgTypes[96] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8274,7 +8447,7 @@ func (x *GetProviderRequest) String() string { func (*GetProviderRequest) ProtoMessage() {} func (x *GetProviderRequest) 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 { @@ -8287,7 +8460,7 @@ func (x *GetProviderRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetProviderRequest.ProtoReflect.Descriptor instead. func (*GetProviderRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{94} + return file_openshell_proto_rawDescGZIP(), []int{96} } func (x *GetProviderRequest) GetWorkspaceScope() *datamodelv1.WorkspaceSelector { @@ -8322,7 +8495,7 @@ type GetProviderCredentialsRequest struct { func (x *GetProviderCredentialsRequest) Reset() { *x = GetProviderCredentialsRequest{} - mi := &file_openshell_proto_msgTypes[95] + mi := &file_openshell_proto_msgTypes[97] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8334,7 +8507,7 @@ func (x *GetProviderCredentialsRequest) String() string { func (*GetProviderCredentialsRequest) ProtoMessage() {} func (x *GetProviderCredentialsRequest) 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 { @@ -8347,7 +8520,7 @@ func (x *GetProviderCredentialsRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetProviderCredentialsRequest.ProtoReflect.Descriptor instead. func (*GetProviderCredentialsRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{95} + return file_openshell_proto_rawDescGZIP(), []int{97} } func (x *GetProviderCredentialsRequest) GetWorkspaceScope() *datamodelv1.WorkspaceSelector { @@ -8390,7 +8563,7 @@ type ProviderCredentialValue struct { func (x *ProviderCredentialValue) Reset() { *x = ProviderCredentialValue{} - mi := &file_openshell_proto_msgTypes[96] + mi := &file_openshell_proto_msgTypes[98] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8402,7 +8575,7 @@ func (x *ProviderCredentialValue) String() string { func (*ProviderCredentialValue) ProtoMessage() {} func (x *ProviderCredentialValue) 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 { @@ -8415,7 +8588,7 @@ func (x *ProviderCredentialValue) ProtoReflect() protoreflect.Message { // Deprecated: Use ProviderCredentialValue.ProtoReflect.Descriptor instead. func (*ProviderCredentialValue) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{96} + return file_openshell_proto_rawDescGZIP(), []int{98} } func (x *ProviderCredentialValue) GetValue() string { @@ -8442,7 +8615,7 @@ type GetProviderCredentialsResponse struct { func (x *GetProviderCredentialsResponse) Reset() { *x = GetProviderCredentialsResponse{} - mi := &file_openshell_proto_msgTypes[97] + mi := &file_openshell_proto_msgTypes[99] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8454,7 +8627,7 @@ func (x *GetProviderCredentialsResponse) String() string { func (*GetProviderCredentialsResponse) ProtoMessage() {} func (x *GetProviderCredentialsResponse) 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 { @@ -8467,7 +8640,7 @@ func (x *GetProviderCredentialsResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use GetProviderCredentialsResponse.ProtoReflect.Descriptor instead. func (*GetProviderCredentialsResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{97} + return file_openshell_proto_rawDescGZIP(), []int{99} } func (x *GetProviderCredentialsResponse) GetCredentials() map[string]*ProviderCredentialValue { @@ -8496,7 +8669,7 @@ type ListProvidersRequest struct { func (x *ListProvidersRequest) Reset() { *x = ListProvidersRequest{} - mi := &file_openshell_proto_msgTypes[98] + mi := &file_openshell_proto_msgTypes[100] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8508,7 +8681,7 @@ func (x *ListProvidersRequest) String() string { func (*ListProvidersRequest) ProtoMessage() {} func (x *ListProvidersRequest) 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 { @@ -8521,7 +8694,7 @@ func (x *ListProvidersRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListProvidersRequest.ProtoReflect.Descriptor instead. func (*ListProvidersRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{98} + return file_openshell_proto_rawDescGZIP(), []int{100} } func (x *ListProvidersRequest) GetWorkspaceScope() *datamodelv1.WorkspaceSelector { @@ -8573,7 +8746,7 @@ type UpdateProviderRequest struct { func (x *UpdateProviderRequest) Reset() { *x = UpdateProviderRequest{} - mi := &file_openshell_proto_msgTypes[99] + mi := &file_openshell_proto_msgTypes[101] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8585,7 +8758,7 @@ func (x *UpdateProviderRequest) String() string { func (*UpdateProviderRequest) ProtoMessage() {} func (x *UpdateProviderRequest) 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 { @@ -8598,7 +8771,7 @@ func (x *UpdateProviderRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use UpdateProviderRequest.ProtoReflect.Descriptor instead. func (*UpdateProviderRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{99} + return file_openshell_proto_rawDescGZIP(), []int{101} } func (x *UpdateProviderRequest) GetWorkspaceScope() *datamodelv1.WorkspaceSelector { @@ -8652,7 +8825,7 @@ type DeleteProviderRequest struct { func (x *DeleteProviderRequest) Reset() { *x = DeleteProviderRequest{} - mi := &file_openshell_proto_msgTypes[100] + mi := &file_openshell_proto_msgTypes[102] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8664,7 +8837,7 @@ func (x *DeleteProviderRequest) String() string { func (*DeleteProviderRequest) ProtoMessage() {} func (x *DeleteProviderRequest) 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 { @@ -8677,7 +8850,7 @@ func (x *DeleteProviderRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteProviderRequest.ProtoReflect.Descriptor instead. func (*DeleteProviderRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{100} + return file_openshell_proto_rawDescGZIP(), []int{102} } func (x *DeleteProviderRequest) GetWorkspaceScope() *datamodelv1.WorkspaceSelector { @@ -8723,7 +8896,7 @@ type ProviderResponse struct { func (x *ProviderResponse) Reset() { *x = ProviderResponse{} - mi := &file_openshell_proto_msgTypes[101] + mi := &file_openshell_proto_msgTypes[103] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8735,7 +8908,7 @@ func (x *ProviderResponse) String() string { func (*ProviderResponse) ProtoMessage() {} func (x *ProviderResponse) 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 { @@ -8748,7 +8921,7 @@ func (x *ProviderResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ProviderResponse.ProtoReflect.Descriptor instead. func (*ProviderResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{101} + return file_openshell_proto_rawDescGZIP(), []int{103} } func (x *ProviderResponse) GetProvider() *datamodelv1.Provider { @@ -8784,7 +8957,7 @@ type ListProvidersResponse struct { func (x *ListProvidersResponse) Reset() { *x = ListProvidersResponse{} - mi := &file_openshell_proto_msgTypes[102] + mi := &file_openshell_proto_msgTypes[104] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8796,7 +8969,7 @@ func (x *ListProvidersResponse) String() string { func (*ListProvidersResponse) ProtoMessage() {} func (x *ListProvidersResponse) 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 { @@ -8809,7 +8982,7 @@ func (x *ListProvidersResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListProvidersResponse.ProtoReflect.Descriptor instead. func (*ListProvidersResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{102} + return file_openshell_proto_rawDescGZIP(), []int{104} } func (x *ListProvidersResponse) GetProviders() []*datamodelv1.Provider { @@ -8843,7 +9016,7 @@ type ListProviderProfilesRequest struct { func (x *ListProviderProfilesRequest) Reset() { *x = ListProviderProfilesRequest{} - mi := &file_openshell_proto_msgTypes[103] + mi := &file_openshell_proto_msgTypes[105] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8855,7 +9028,7 @@ func (x *ListProviderProfilesRequest) String() string { func (*ListProviderProfilesRequest) ProtoMessage() {} func (x *ListProviderProfilesRequest) 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 { @@ -8868,7 +9041,7 @@ func (x *ListProviderProfilesRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListProviderProfilesRequest.ProtoReflect.Descriptor instead. func (*ListProviderProfilesRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{103} + return file_openshell_proto_rawDescGZIP(), []int{105} } func (x *ListProviderProfilesRequest) GetWorkspaceScope() *datamodelv1.WorkspaceSelector { @@ -8904,7 +9077,7 @@ type GetProviderProfileRequest struct { func (x *GetProviderProfileRequest) Reset() { *x = GetProviderProfileRequest{} - mi := &file_openshell_proto_msgTypes[104] + mi := &file_openshell_proto_msgTypes[106] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8916,7 +9089,7 @@ func (x *GetProviderProfileRequest) String() string { func (*GetProviderProfileRequest) ProtoMessage() {} func (x *GetProviderProfileRequest) 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 { @@ -8929,7 +9102,7 @@ func (x *GetProviderProfileRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetProviderProfileRequest.ProtoReflect.Descriptor instead. func (*GetProviderProfileRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{104} + return file_openshell_proto_rawDescGZIP(), []int{106} } func (x *GetProviderProfileRequest) GetWorkspaceScope() *datamodelv1.WorkspaceSelector { @@ -8957,7 +9130,7 @@ type ProviderProfileImportItem struct { func (x *ProviderProfileImportItem) Reset() { *x = ProviderProfileImportItem{} - mi := &file_openshell_proto_msgTypes[105] + mi := &file_openshell_proto_msgTypes[107] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8969,7 +9142,7 @@ func (x *ProviderProfileImportItem) String() string { func (*ProviderProfileImportItem) ProtoMessage() {} func (x *ProviderProfileImportItem) 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 { @@ -8982,7 +9155,7 @@ func (x *ProviderProfileImportItem) ProtoReflect() protoreflect.Message { // Deprecated: Use ProviderProfileImportItem.ProtoReflect.Descriptor instead. func (*ProviderProfileImportItem) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{105} + return file_openshell_proto_rawDescGZIP(), []int{107} } func (x *ProviderProfileImportItem) GetProfile() *ProviderProfile { @@ -9013,7 +9186,7 @@ type ProviderProfileDiagnostic struct { func (x *ProviderProfileDiagnostic) Reset() { *x = ProviderProfileDiagnostic{} - mi := &file_openshell_proto_msgTypes[106] + mi := &file_openshell_proto_msgTypes[108] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9025,7 +9198,7 @@ func (x *ProviderProfileDiagnostic) String() string { func (*ProviderProfileDiagnostic) ProtoMessage() {} func (x *ProviderProfileDiagnostic) 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 { @@ -9038,7 +9211,7 @@ func (x *ProviderProfileDiagnostic) ProtoReflect() protoreflect.Message { // Deprecated: Use ProviderProfileDiagnostic.ProtoReflect.Descriptor instead. func (*ProviderProfileDiagnostic) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{106} + return file_openshell_proto_rawDescGZIP(), []int{108} } func (x *ProviderProfileDiagnostic) GetSource() string { @@ -9095,7 +9268,7 @@ type ProviderCredentialTokenGrantAudienceOverride struct { func (x *ProviderCredentialTokenGrantAudienceOverride) Reset() { *x = ProviderCredentialTokenGrantAudienceOverride{} - mi := &file_openshell_proto_msgTypes[107] + mi := &file_openshell_proto_msgTypes[109] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9107,7 +9280,7 @@ func (x *ProviderCredentialTokenGrantAudienceOverride) String() string { func (*ProviderCredentialTokenGrantAudienceOverride) ProtoMessage() {} func (x *ProviderCredentialTokenGrantAudienceOverride) 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 { @@ -9120,7 +9293,7 @@ func (x *ProviderCredentialTokenGrantAudienceOverride) ProtoReflect() protorefle // Deprecated: Use ProviderCredentialTokenGrantAudienceOverride.ProtoReflect.Descriptor instead. func (*ProviderCredentialTokenGrantAudienceOverride) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{107} + return file_openshell_proto_rawDescGZIP(), []int{109} } func (x *ProviderCredentialTokenGrantAudienceOverride) GetHost() string { @@ -9174,7 +9347,7 @@ type ProviderCredentialTokenGrantSubjectToken struct { func (x *ProviderCredentialTokenGrantSubjectToken) Reset() { *x = ProviderCredentialTokenGrantSubjectToken{} - mi := &file_openshell_proto_msgTypes[108] + mi := &file_openshell_proto_msgTypes[110] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9186,7 +9359,7 @@ func (x *ProviderCredentialTokenGrantSubjectToken) String() string { func (*ProviderCredentialTokenGrantSubjectToken) ProtoMessage() {} func (x *ProviderCredentialTokenGrantSubjectToken) 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 { @@ -9199,7 +9372,7 @@ func (x *ProviderCredentialTokenGrantSubjectToken) ProtoReflect() protoreflect.M // Deprecated: Use ProviderCredentialTokenGrantSubjectToken.ProtoReflect.Descriptor instead. func (*ProviderCredentialTokenGrantSubjectToken) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{108} + return file_openshell_proto_rawDescGZIP(), []int{110} } func (x *ProviderCredentialTokenGrantSubjectToken) GetSource() string { @@ -9255,7 +9428,7 @@ type ProviderCredentialTokenGrant struct { func (x *ProviderCredentialTokenGrant) Reset() { *x = ProviderCredentialTokenGrant{} - mi := &file_openshell_proto_msgTypes[109] + mi := &file_openshell_proto_msgTypes[111] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9267,7 +9440,7 @@ func (x *ProviderCredentialTokenGrant) String() string { func (*ProviderCredentialTokenGrant) ProtoMessage() {} func (x *ProviderCredentialTokenGrant) 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 { @@ -9280,7 +9453,7 @@ func (x *ProviderCredentialTokenGrant) ProtoReflect() protoreflect.Message { // Deprecated: Use ProviderCredentialTokenGrant.ProtoReflect.Descriptor instead. func (*ProviderCredentialTokenGrant) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{109} + return file_openshell_proto_rawDescGZIP(), []int{111} } func (x *ProviderCredentialTokenGrant) GetTokenEndpoint() string { @@ -9384,7 +9557,7 @@ type ProviderProfileCredential struct { func (x *ProviderProfileCredential) Reset() { *x = ProviderProfileCredential{} - mi := &file_openshell_proto_msgTypes[110] + mi := &file_openshell_proto_msgTypes[112] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9396,7 +9569,7 @@ func (x *ProviderProfileCredential) String() string { func (*ProviderProfileCredential) ProtoMessage() {} func (x *ProviderProfileCredential) 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 { @@ -9409,7 +9582,7 @@ func (x *ProviderProfileCredential) ProtoReflect() protoreflect.Message { // Deprecated: Use ProviderProfileCredential.ProtoReflect.Descriptor instead. func (*ProviderProfileCredential) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{110} + return file_openshell_proto_rawDescGZIP(), []int{112} } func (x *ProviderProfileCredential) GetName() string { @@ -9508,7 +9681,7 @@ type ProviderCredentialRefreshMaterial struct { func (x *ProviderCredentialRefreshMaterial) Reset() { *x = ProviderCredentialRefreshMaterial{} - mi := &file_openshell_proto_msgTypes[111] + mi := &file_openshell_proto_msgTypes[113] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9520,7 +9693,7 @@ func (x *ProviderCredentialRefreshMaterial) String() string { func (*ProviderCredentialRefreshMaterial) ProtoMessage() {} func (x *ProviderCredentialRefreshMaterial) 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 { @@ -9533,7 +9706,7 @@ func (x *ProviderCredentialRefreshMaterial) ProtoReflect() protoreflect.Message // Deprecated: Use ProviderCredentialRefreshMaterial.ProtoReflect.Descriptor instead. func (*ProviderCredentialRefreshMaterial) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{111} + return file_openshell_proto_rawDescGZIP(), []int{113} } func (x *ProviderCredentialRefreshMaterial) GetName() string { @@ -9578,7 +9751,7 @@ type ProviderCredentialRefreshOutput struct { func (x *ProviderCredentialRefreshOutput) Reset() { *x = ProviderCredentialRefreshOutput{} - mi := &file_openshell_proto_msgTypes[112] + mi := &file_openshell_proto_msgTypes[114] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9590,7 +9763,7 @@ func (x *ProviderCredentialRefreshOutput) String() string { func (*ProviderCredentialRefreshOutput) ProtoMessage() {} func (x *ProviderCredentialRefreshOutput) 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 { @@ -9603,7 +9776,7 @@ func (x *ProviderCredentialRefreshOutput) ProtoReflect() protoreflect.Message { // Deprecated: Use ProviderCredentialRefreshOutput.ProtoReflect.Descriptor instead. func (*ProviderCredentialRefreshOutput) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{112} + return file_openshell_proto_rawDescGZIP(), []int{114} } func (x *ProviderCredentialRefreshOutput) GetOutput() string { @@ -9635,7 +9808,7 @@ type ProviderCredentialRefresh struct { func (x *ProviderCredentialRefresh) Reset() { *x = ProviderCredentialRefresh{} - mi := &file_openshell_proto_msgTypes[113] + mi := &file_openshell_proto_msgTypes[115] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9647,7 +9820,7 @@ func (x *ProviderCredentialRefresh) String() string { func (*ProviderCredentialRefresh) ProtoMessage() {} func (x *ProviderCredentialRefresh) 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 { @@ -9660,7 +9833,7 @@ func (x *ProviderCredentialRefresh) ProtoReflect() protoreflect.Message { // Deprecated: Use ProviderCredentialRefresh.ProtoReflect.Descriptor instead. func (*ProviderCredentialRefresh) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{113} + return file_openshell_proto_rawDescGZIP(), []int{115} } func (x *ProviderCredentialRefresh) GetStrategy() ProviderCredentialRefreshStrategy { @@ -9741,7 +9914,7 @@ type ProviderCredentialRefreshStatus struct { func (x *ProviderCredentialRefreshStatus) Reset() { *x = ProviderCredentialRefreshStatus{} - mi := &file_openshell_proto_msgTypes[114] + mi := &file_openshell_proto_msgTypes[116] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9753,7 +9926,7 @@ func (x *ProviderCredentialRefreshStatus) String() string { func (*ProviderCredentialRefreshStatus) ProtoMessage() {} func (x *ProviderCredentialRefreshStatus) 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 { @@ -9766,7 +9939,7 @@ func (x *ProviderCredentialRefreshStatus) ProtoReflect() protoreflect.Message { // Deprecated: Use ProviderCredentialRefreshStatus.ProtoReflect.Descriptor instead. func (*ProviderCredentialRefreshStatus) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{114} + return file_openshell_proto_rawDescGZIP(), []int{116} } func (x *ProviderCredentialRefreshStatus) GetProvider() string { @@ -9871,7 +10044,7 @@ type ProviderProfileDiscovery struct { func (x *ProviderProfileDiscovery) Reset() { *x = ProviderProfileDiscovery{} - mi := &file_openshell_proto_msgTypes[115] + mi := &file_openshell_proto_msgTypes[117] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9883,7 +10056,7 @@ func (x *ProviderProfileDiscovery) String() string { func (*ProviderProfileDiscovery) ProtoMessage() {} func (x *ProviderProfileDiscovery) 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 { @@ -9896,7 +10069,7 @@ func (x *ProviderProfileDiscovery) ProtoReflect() protoreflect.Message { // Deprecated: Use ProviderProfileDiscovery.ProtoReflect.Descriptor instead. func (*ProviderProfileDiscovery) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{115} + return file_openshell_proto_rawDescGZIP(), []int{117} } func (x *ProviderProfileDiscovery) GetCredentials() []string { @@ -9918,7 +10091,7 @@ type GetProviderRefreshStatusRequest struct { func (x *GetProviderRefreshStatusRequest) Reset() { *x = GetProviderRefreshStatusRequest{} - mi := &file_openshell_proto_msgTypes[116] + mi := &file_openshell_proto_msgTypes[118] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9930,7 +10103,7 @@ func (x *GetProviderRefreshStatusRequest) String() string { func (*GetProviderRefreshStatusRequest) ProtoMessage() {} func (x *GetProviderRefreshStatusRequest) 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 { @@ -9943,7 +10116,7 @@ func (x *GetProviderRefreshStatusRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetProviderRefreshStatusRequest.ProtoReflect.Descriptor instead. func (*GetProviderRefreshStatusRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{116} + return file_openshell_proto_rawDescGZIP(), []int{118} } func (x *GetProviderRefreshStatusRequest) GetWorkspaceScope() *datamodelv1.WorkspaceSelector { @@ -9976,7 +10149,7 @@ type GetProviderRefreshStatusResponse struct { func (x *GetProviderRefreshStatusResponse) Reset() { *x = GetProviderRefreshStatusResponse{} - mi := &file_openshell_proto_msgTypes[117] + mi := &file_openshell_proto_msgTypes[119] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9988,7 +10161,7 @@ func (x *GetProviderRefreshStatusResponse) String() string { func (*GetProviderRefreshStatusResponse) ProtoMessage() {} func (x *GetProviderRefreshStatusResponse) 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 { @@ -10001,7 +10174,7 @@ func (x *GetProviderRefreshStatusResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use GetProviderRefreshStatusResponse.ProtoReflect.Descriptor instead. func (*GetProviderRefreshStatusResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{117} + return file_openshell_proto_rawDescGZIP(), []int{119} } func (x *GetProviderRefreshStatusResponse) GetCredentials() []*ProviderCredentialRefreshStatus { @@ -10033,7 +10206,7 @@ type ConfigureProviderRefreshRequest struct { func (x *ConfigureProviderRefreshRequest) Reset() { *x = ConfigureProviderRefreshRequest{} - mi := &file_openshell_proto_msgTypes[118] + mi := &file_openshell_proto_msgTypes[120] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10045,7 +10218,7 @@ func (x *ConfigureProviderRefreshRequest) String() string { func (*ConfigureProviderRefreshRequest) ProtoMessage() {} func (x *ConfigureProviderRefreshRequest) 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 { @@ -10058,7 +10231,7 @@ func (x *ConfigureProviderRefreshRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ConfigureProviderRefreshRequest.ProtoReflect.Descriptor instead. func (*ConfigureProviderRefreshRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{118} + return file_openshell_proto_rawDescGZIP(), []int{120} } func (x *ConfigureProviderRefreshRequest) GetWorkspaceScope() *datamodelv1.WorkspaceSelector { @@ -10126,7 +10299,7 @@ type ConfigureProviderRefreshResponse struct { func (x *ConfigureProviderRefreshResponse) Reset() { *x = ConfigureProviderRefreshResponse{} - mi := &file_openshell_proto_msgTypes[119] + mi := &file_openshell_proto_msgTypes[121] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10138,7 +10311,7 @@ func (x *ConfigureProviderRefreshResponse) String() string { func (*ConfigureProviderRefreshResponse) ProtoMessage() {} func (x *ConfigureProviderRefreshResponse) 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 { @@ -10151,7 +10324,7 @@ func (x *ConfigureProviderRefreshResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ConfigureProviderRefreshResponse.ProtoReflect.Descriptor instead. func (*ConfigureProviderRefreshResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{119} + return file_openshell_proto_rawDescGZIP(), []int{121} } func (x *ConfigureProviderRefreshResponse) GetStatus() *ProviderCredentialRefreshStatus { @@ -10176,7 +10349,7 @@ type RotateProviderCredentialRequest struct { func (x *RotateProviderCredentialRequest) Reset() { *x = RotateProviderCredentialRequest{} - mi := &file_openshell_proto_msgTypes[120] + mi := &file_openshell_proto_msgTypes[122] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10188,7 +10361,7 @@ func (x *RotateProviderCredentialRequest) String() string { func (*RotateProviderCredentialRequest) ProtoMessage() {} func (x *RotateProviderCredentialRequest) 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 { @@ -10201,7 +10374,7 @@ func (x *RotateProviderCredentialRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use RotateProviderCredentialRequest.ProtoReflect.Descriptor instead. func (*RotateProviderCredentialRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{120} + return file_openshell_proto_rawDescGZIP(), []int{122} } func (x *RotateProviderCredentialRequest) GetWorkspaceScope() *datamodelv1.WorkspaceSelector { @@ -10241,7 +10414,7 @@ type RotateProviderCredentialResponse struct { func (x *RotateProviderCredentialResponse) Reset() { *x = RotateProviderCredentialResponse{} - mi := &file_openshell_proto_msgTypes[121] + mi := &file_openshell_proto_msgTypes[123] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10253,7 +10426,7 @@ func (x *RotateProviderCredentialResponse) String() string { func (*RotateProviderCredentialResponse) ProtoMessage() {} func (x *RotateProviderCredentialResponse) 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 { @@ -10266,7 +10439,7 @@ func (x *RotateProviderCredentialResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use RotateProviderCredentialResponse.ProtoReflect.Descriptor instead. func (*RotateProviderCredentialResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{121} + return file_openshell_proto_rawDescGZIP(), []int{123} } func (x *RotateProviderCredentialResponse) GetStatus() *ProviderCredentialRefreshStatus { @@ -10292,7 +10465,7 @@ type DeleteProviderRefreshRequest struct { func (x *DeleteProviderRefreshRequest) Reset() { *x = DeleteProviderRefreshRequest{} - mi := &file_openshell_proto_msgTypes[122] + mi := &file_openshell_proto_msgTypes[124] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10304,7 +10477,7 @@ func (x *DeleteProviderRefreshRequest) String() string { func (*DeleteProviderRefreshRequest) ProtoMessage() {} func (x *DeleteProviderRefreshRequest) 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 { @@ -10317,7 +10490,7 @@ func (x *DeleteProviderRefreshRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteProviderRefreshRequest.ProtoReflect.Descriptor instead. func (*DeleteProviderRefreshRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{122} + return file_openshell_proto_rawDescGZIP(), []int{124} } func (x *DeleteProviderRefreshRequest) GetWorkspaceScope() *datamodelv1.WorkspaceSelector { @@ -10364,7 +10537,7 @@ type DeleteProviderRefreshResponse struct { func (x *DeleteProviderRefreshResponse) Reset() { *x = DeleteProviderRefreshResponse{} - mi := &file_openshell_proto_msgTypes[123] + mi := &file_openshell_proto_msgTypes[125] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10376,7 +10549,7 @@ func (x *DeleteProviderRefreshResponse) String() string { func (*DeleteProviderRefreshResponse) ProtoMessage() {} func (x *DeleteProviderRefreshResponse) 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 { @@ -10389,7 +10562,7 @@ func (x *DeleteProviderRefreshResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteProviderRefreshResponse.ProtoReflect.Descriptor instead. func (*DeleteProviderRefreshResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{123} + return file_openshell_proto_rawDescGZIP(), []int{125} } func (x *DeleteProviderRefreshResponse) GetOutcome() DeletionOutcome { @@ -10432,7 +10605,7 @@ type ProviderProfile struct { func (x *ProviderProfile) Reset() { *x = ProviderProfile{} - mi := &file_openshell_proto_msgTypes[124] + mi := &file_openshell_proto_msgTypes[126] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10444,7 +10617,7 @@ func (x *ProviderProfile) String() string { func (*ProviderProfile) ProtoMessage() {} func (x *ProviderProfile) 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 { @@ -10457,7 +10630,7 @@ func (x *ProviderProfile) ProtoReflect() protoreflect.Message { // Deprecated: Use ProviderProfile.ProtoReflect.Descriptor instead. func (*ProviderProfile) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{124} + return file_openshell_proto_rawDescGZIP(), []int{126} } func (x *ProviderProfile) GetId() string { @@ -10573,7 +10746,7 @@ type ProviderProfileFile struct { func (x *ProviderProfileFile) Reset() { *x = ProviderProfileFile{} - mi := &file_openshell_proto_msgTypes[125] + mi := &file_openshell_proto_msgTypes[127] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10585,7 +10758,7 @@ func (x *ProviderProfileFile) String() string { func (*ProviderProfileFile) ProtoMessage() {} func (x *ProviderProfileFile) 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 { @@ -10598,7 +10771,7 @@ func (x *ProviderProfileFile) ProtoReflect() protoreflect.Message { // Deprecated: Use ProviderProfileFile.ProtoReflect.Descriptor instead. func (*ProviderProfileFile) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{125} + return file_openshell_proto_rawDescGZIP(), []int{127} } func (x *ProviderProfileFile) GetPath() string { @@ -10632,7 +10805,7 @@ type ProviderProfileResponse struct { func (x *ProviderProfileResponse) Reset() { *x = ProviderProfileResponse{} - mi := &file_openshell_proto_msgTypes[126] + mi := &file_openshell_proto_msgTypes[128] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10644,7 +10817,7 @@ func (x *ProviderProfileResponse) String() string { func (*ProviderProfileResponse) ProtoMessage() {} func (x *ProviderProfileResponse) 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 { @@ -10657,7 +10830,7 @@ func (x *ProviderProfileResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ProviderProfileResponse.ProtoReflect.Descriptor instead. func (*ProviderProfileResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{126} + return file_openshell_proto_rawDescGZIP(), []int{128} } func (x *ProviderProfileResponse) GetProfile() *ProviderProfile { @@ -10679,7 +10852,7 @@ type ListProviderProfilesResponse struct { func (x *ListProviderProfilesResponse) Reset() { *x = ListProviderProfilesResponse{} - mi := &file_openshell_proto_msgTypes[127] + mi := &file_openshell_proto_msgTypes[129] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10691,7 +10864,7 @@ func (x *ListProviderProfilesResponse) String() string { func (*ListProviderProfilesResponse) ProtoMessage() {} func (x *ListProviderProfilesResponse) 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 { @@ -10704,7 +10877,7 @@ func (x *ListProviderProfilesResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListProviderProfilesResponse.ProtoReflect.Descriptor instead. func (*ListProviderProfilesResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{127} + return file_openshell_proto_rawDescGZIP(), []int{129} } func (x *ListProviderProfilesResponse) GetProfiles() []*ProviderProfile { @@ -10736,7 +10909,7 @@ type ImportProviderProfilesRequest struct { func (x *ImportProviderProfilesRequest) Reset() { *x = ImportProviderProfilesRequest{} - mi := &file_openshell_proto_msgTypes[128] + mi := &file_openshell_proto_msgTypes[130] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10748,7 +10921,7 @@ func (x *ImportProviderProfilesRequest) String() string { func (*ImportProviderProfilesRequest) ProtoMessage() {} func (x *ImportProviderProfilesRequest) 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 { @@ -10761,7 +10934,7 @@ func (x *ImportProviderProfilesRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ImportProviderProfilesRequest.ProtoReflect.Descriptor instead. func (*ImportProviderProfilesRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{128} + return file_openshell_proto_rawDescGZIP(), []int{130} } func (x *ImportProviderProfilesRequest) GetWorkspaceScope() *datamodelv1.WorkspaceSelector { @@ -10797,7 +10970,7 @@ type ImportProviderProfilesResponse struct { func (x *ImportProviderProfilesResponse) Reset() { *x = ImportProviderProfilesResponse{} - mi := &file_openshell_proto_msgTypes[129] + mi := &file_openshell_proto_msgTypes[131] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10809,7 +10982,7 @@ func (x *ImportProviderProfilesResponse) String() string { func (*ImportProviderProfilesResponse) ProtoMessage() {} func (x *ImportProviderProfilesResponse) 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 { @@ -10822,7 +10995,7 @@ func (x *ImportProviderProfilesResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ImportProviderProfilesResponse.ProtoReflect.Descriptor instead. func (*ImportProviderProfilesResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{129} + return file_openshell_proto_rawDescGZIP(), []int{131} } func (x *ImportProviderProfilesResponse) GetDiagnostics() []*ProviderProfileDiagnostic { @@ -10868,7 +11041,7 @@ type UpdateProviderProfilesRequest struct { func (x *UpdateProviderProfilesRequest) Reset() { *x = UpdateProviderProfilesRequest{} - mi := &file_openshell_proto_msgTypes[130] + mi := &file_openshell_proto_msgTypes[132] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10880,7 +11053,7 @@ func (x *UpdateProviderProfilesRequest) String() string { func (*UpdateProviderProfilesRequest) ProtoMessage() {} func (x *UpdateProviderProfilesRequest) 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 { @@ -10893,7 +11066,7 @@ func (x *UpdateProviderProfilesRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use UpdateProviderProfilesRequest.ProtoReflect.Descriptor instead. func (*UpdateProviderProfilesRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{130} + return file_openshell_proto_rawDescGZIP(), []int{132} } func (x *UpdateProviderProfilesRequest) GetWorkspaceScope() *datamodelv1.WorkspaceSelector { @@ -10943,7 +11116,7 @@ type UpdateProviderProfilesResponse struct { func (x *UpdateProviderProfilesResponse) Reset() { *x = UpdateProviderProfilesResponse{} - mi := &file_openshell_proto_msgTypes[131] + mi := &file_openshell_proto_msgTypes[133] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10955,7 +11128,7 @@ func (x *UpdateProviderProfilesResponse) String() string { func (*UpdateProviderProfilesResponse) ProtoMessage() {} func (x *UpdateProviderProfilesResponse) 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 { @@ -10968,7 +11141,7 @@ func (x *UpdateProviderProfilesResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use UpdateProviderProfilesResponse.ProtoReflect.Descriptor instead. func (*UpdateProviderProfilesResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{131} + return file_openshell_proto_rawDescGZIP(), []int{133} } func (x *UpdateProviderProfilesResponse) GetDiagnostics() []*ProviderProfileDiagnostic { @@ -11004,7 +11177,7 @@ type LintProviderProfilesRequest struct { func (x *LintProviderProfilesRequest) Reset() { *x = LintProviderProfilesRequest{} - mi := &file_openshell_proto_msgTypes[132] + mi := &file_openshell_proto_msgTypes[134] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11016,7 +11189,7 @@ func (x *LintProviderProfilesRequest) String() string { func (*LintProviderProfilesRequest) ProtoMessage() {} func (x *LintProviderProfilesRequest) 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 { @@ -11029,7 +11202,7 @@ func (x *LintProviderProfilesRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use LintProviderProfilesRequest.ProtoReflect.Descriptor instead. func (*LintProviderProfilesRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{132} + return file_openshell_proto_rawDescGZIP(), []int{134} } func (x *LintProviderProfilesRequest) GetWorkspaceScope() *datamodelv1.WorkspaceSelector { @@ -11060,7 +11233,7 @@ type LintProviderProfilesResponse struct { func (x *LintProviderProfilesResponse) Reset() { *x = LintProviderProfilesResponse{} - mi := &file_openshell_proto_msgTypes[133] + mi := &file_openshell_proto_msgTypes[135] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11072,7 +11245,7 @@ func (x *LintProviderProfilesResponse) String() string { func (*LintProviderProfilesResponse) ProtoMessage() {} func (x *LintProviderProfilesResponse) 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 { @@ -11085,7 +11258,7 @@ func (x *LintProviderProfilesResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use LintProviderProfilesResponse.ProtoReflect.Descriptor instead. func (*LintProviderProfilesResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{133} + return file_openshell_proto_rawDescGZIP(), []int{135} } func (x *LintProviderProfilesResponse) GetDiagnostics() []*ProviderProfileDiagnostic { @@ -11119,7 +11292,7 @@ type DeleteProviderResponse struct { func (x *DeleteProviderResponse) Reset() { *x = DeleteProviderResponse{} - mi := &file_openshell_proto_msgTypes[134] + mi := &file_openshell_proto_msgTypes[136] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11131,7 +11304,7 @@ func (x *DeleteProviderResponse) String() string { func (*DeleteProviderResponse) ProtoMessage() {} func (x *DeleteProviderResponse) 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 { @@ -11144,7 +11317,7 @@ func (x *DeleteProviderResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteProviderResponse.ProtoReflect.Descriptor instead. func (*DeleteProviderResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{134} + return file_openshell_proto_rawDescGZIP(), []int{136} } func (x *DeleteProviderResponse) GetOutcome() DeletionOutcome { @@ -11170,7 +11343,7 @@ type DeleteProviderProfileRequest struct { func (x *DeleteProviderProfileRequest) Reset() { *x = DeleteProviderProfileRequest{} - mi := &file_openshell_proto_msgTypes[135] + mi := &file_openshell_proto_msgTypes[137] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11182,7 +11355,7 @@ func (x *DeleteProviderProfileRequest) String() string { func (*DeleteProviderProfileRequest) ProtoMessage() {} func (x *DeleteProviderProfileRequest) 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 { @@ -11195,7 +11368,7 @@ func (x *DeleteProviderProfileRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteProviderProfileRequest.ProtoReflect.Descriptor instead. func (*DeleteProviderProfileRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{135} + return file_openshell_proto_rawDescGZIP(), []int{137} } func (x *DeleteProviderProfileRequest) GetWorkspaceScope() *datamodelv1.WorkspaceSelector { @@ -11236,7 +11409,7 @@ type DeleteProviderProfileResponse struct { func (x *DeleteProviderProfileResponse) Reset() { *x = DeleteProviderProfileResponse{} - mi := &file_openshell_proto_msgTypes[136] + mi := &file_openshell_proto_msgTypes[138] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11248,7 +11421,7 @@ func (x *DeleteProviderProfileResponse) String() string { func (*DeleteProviderProfileResponse) ProtoMessage() {} func (x *DeleteProviderProfileResponse) 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 { @@ -11261,7 +11434,7 @@ func (x *DeleteProviderProfileResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteProviderProfileResponse.ProtoReflect.Descriptor instead. func (*DeleteProviderProfileResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{136} + return file_openshell_proto_rawDescGZIP(), []int{138} } func (x *DeleteProviderProfileResponse) GetOutcome() DeletionOutcome { @@ -11290,7 +11463,7 @@ type GetSandboxProviderEnvironmentRequest struct { func (x *GetSandboxProviderEnvironmentRequest) Reset() { *x = GetSandboxProviderEnvironmentRequest{} - mi := &file_openshell_proto_msgTypes[137] + mi := &file_openshell_proto_msgTypes[139] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11302,7 +11475,7 @@ func (x *GetSandboxProviderEnvironmentRequest) String() string { func (*GetSandboxProviderEnvironmentRequest) ProtoMessage() {} func (x *GetSandboxProviderEnvironmentRequest) 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 { @@ -11315,7 +11488,7 @@ func (x *GetSandboxProviderEnvironmentRequest) ProtoReflect() protoreflect.Messa // Deprecated: Use GetSandboxProviderEnvironmentRequest.ProtoReflect.Descriptor instead. func (*GetSandboxProviderEnvironmentRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{137} + return file_openshell_proto_rawDescGZIP(), []int{139} } func (x *GetSandboxProviderEnvironmentRequest) GetSandboxId() string { @@ -11351,7 +11524,7 @@ type StaticCredentialEndpointBinding struct { func (x *StaticCredentialEndpointBinding) Reset() { *x = StaticCredentialEndpointBinding{} - mi := &file_openshell_proto_msgTypes[138] + mi := &file_openshell_proto_msgTypes[140] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11363,7 +11536,7 @@ func (x *StaticCredentialEndpointBinding) String() string { func (*StaticCredentialEndpointBinding) ProtoMessage() {} func (x *StaticCredentialEndpointBinding) 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 { @@ -11376,7 +11549,7 @@ func (x *StaticCredentialEndpointBinding) ProtoReflect() protoreflect.Message { // Deprecated: Use StaticCredentialEndpointBinding.ProtoReflect.Descriptor instead. func (*StaticCredentialEndpointBinding) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{138} + return file_openshell_proto_rawDescGZIP(), []int{140} } func (x *StaticCredentialEndpointBinding) GetHost() string { @@ -11420,7 +11593,7 @@ type StaticCredentialBinding struct { func (x *StaticCredentialBinding) Reset() { *x = StaticCredentialBinding{} - mi := &file_openshell_proto_msgTypes[139] + mi := &file_openshell_proto_msgTypes[141] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11432,7 +11605,7 @@ func (x *StaticCredentialBinding) String() string { func (*StaticCredentialBinding) ProtoMessage() {} func (x *StaticCredentialBinding) 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 { @@ -11445,7 +11618,7 @@ func (x *StaticCredentialBinding) ProtoReflect() protoreflect.Message { // Deprecated: Use StaticCredentialBinding.ProtoReflect.Descriptor instead. func (*StaticCredentialBinding) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{139} + return file_openshell_proto_rawDescGZIP(), []int{141} } func (x *StaticCredentialBinding) GetEndpoints() []*StaticCredentialEndpointBinding { @@ -11513,7 +11686,7 @@ type GetSandboxProviderEnvironmentResponse struct { func (x *GetSandboxProviderEnvironmentResponse) Reset() { *x = GetSandboxProviderEnvironmentResponse{} - mi := &file_openshell_proto_msgTypes[140] + mi := &file_openshell_proto_msgTypes[142] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11525,7 +11698,7 @@ func (x *GetSandboxProviderEnvironmentResponse) String() string { func (*GetSandboxProviderEnvironmentResponse) ProtoMessage() {} func (x *GetSandboxProviderEnvironmentResponse) 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 { @@ -11538,7 +11711,7 @@ func (x *GetSandboxProviderEnvironmentResponse) ProtoReflect() protoreflect.Mess // Deprecated: Use GetSandboxProviderEnvironmentResponse.ProtoReflect.Descriptor instead. func (*GetSandboxProviderEnvironmentResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{140} + return file_openshell_proto_rawDescGZIP(), []int{142} } func (x *GetSandboxProviderEnvironmentResponse) GetEnvironment() map[string]string { @@ -11642,7 +11815,7 @@ type ExchangeProviderSubjectTokenRequest struct { func (x *ExchangeProviderSubjectTokenRequest) Reset() { *x = ExchangeProviderSubjectTokenRequest{} - mi := &file_openshell_proto_msgTypes[141] + mi := &file_openshell_proto_msgTypes[143] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11654,7 +11827,7 @@ func (x *ExchangeProviderSubjectTokenRequest) String() string { func (*ExchangeProviderSubjectTokenRequest) ProtoMessage() {} func (x *ExchangeProviderSubjectTokenRequest) 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 { @@ -11667,7 +11840,7 @@ func (x *ExchangeProviderSubjectTokenRequest) ProtoReflect() protoreflect.Messag // Deprecated: Use ExchangeProviderSubjectTokenRequest.ProtoReflect.Descriptor instead. func (*ExchangeProviderSubjectTokenRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{141} + return file_openshell_proto_rawDescGZIP(), []int{143} } func (x *ExchangeProviderSubjectTokenRequest) GetSandboxId() string { @@ -11709,7 +11882,7 @@ type ExchangeProviderSubjectTokenResponse struct { func (x *ExchangeProviderSubjectTokenResponse) Reset() { *x = ExchangeProviderSubjectTokenResponse{} - mi := &file_openshell_proto_msgTypes[142] + mi := &file_openshell_proto_msgTypes[144] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11721,7 +11894,7 @@ func (x *ExchangeProviderSubjectTokenResponse) String() string { func (*ExchangeProviderSubjectTokenResponse) ProtoMessage() {} func (x *ExchangeProviderSubjectTokenResponse) 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 { @@ -11734,7 +11907,7 @@ func (x *ExchangeProviderSubjectTokenResponse) ProtoReflect() protoreflect.Messa // Deprecated: Use ExchangeProviderSubjectTokenResponse.ProtoReflect.Descriptor instead. func (*ExchangeProviderSubjectTokenResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{142} + return file_openshell_proto_rawDescGZIP(), []int{144} } func (x *ExchangeProviderSubjectTokenResponse) GetAccessToken() string { @@ -11807,7 +11980,7 @@ type UpdateConfigRequest struct { func (x *UpdateConfigRequest) Reset() { *x = UpdateConfigRequest{} - mi := &file_openshell_proto_msgTypes[143] + mi := &file_openshell_proto_msgTypes[145] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11819,7 +11992,7 @@ func (x *UpdateConfigRequest) String() string { func (*UpdateConfigRequest) ProtoMessage() {} func (x *UpdateConfigRequest) 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 { @@ -11832,7 +12005,7 @@ func (x *UpdateConfigRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use UpdateConfigRequest.ProtoReflect.Descriptor instead. func (*UpdateConfigRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{143} + return file_openshell_proto_rawDescGZIP(), []int{145} } func (x *UpdateConfigRequest) GetWorkspaceScope() *datamodelv1.WorkspaceSelector { @@ -11929,7 +12102,7 @@ type PolicyMergeOperation struct { func (x *PolicyMergeOperation) Reset() { *x = PolicyMergeOperation{} - mi := &file_openshell_proto_msgTypes[144] + mi := &file_openshell_proto_msgTypes[146] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11941,7 +12114,7 @@ func (x *PolicyMergeOperation) String() string { func (*PolicyMergeOperation) ProtoMessage() {} func (x *PolicyMergeOperation) 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 { @@ -11954,7 +12127,7 @@ func (x *PolicyMergeOperation) ProtoReflect() protoreflect.Message { // Deprecated: Use PolicyMergeOperation.ProtoReflect.Descriptor instead. func (*PolicyMergeOperation) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{144} + return file_openshell_proto_rawDescGZIP(), []int{146} } func (x *PolicyMergeOperation) GetOperation() isPolicyMergeOperation_Operation { @@ -12068,7 +12241,7 @@ type AddNetworkRule struct { func (x *AddNetworkRule) Reset() { *x = AddNetworkRule{} - mi := &file_openshell_proto_msgTypes[145] + mi := &file_openshell_proto_msgTypes[147] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12080,7 +12253,7 @@ func (x *AddNetworkRule) String() string { func (*AddNetworkRule) ProtoMessage() {} func (x *AddNetworkRule) 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 { @@ -12093,7 +12266,7 @@ func (x *AddNetworkRule) ProtoReflect() protoreflect.Message { // Deprecated: Use AddNetworkRule.ProtoReflect.Descriptor instead. func (*AddNetworkRule) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{145} + return file_openshell_proto_rawDescGZIP(), []int{147} } func (x *AddNetworkRule) GetRuleName() string { @@ -12121,7 +12294,7 @@ type RemoveNetworkEndpoint struct { func (x *RemoveNetworkEndpoint) Reset() { *x = RemoveNetworkEndpoint{} - mi := &file_openshell_proto_msgTypes[146] + mi := &file_openshell_proto_msgTypes[148] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12133,7 +12306,7 @@ func (x *RemoveNetworkEndpoint) String() string { func (*RemoveNetworkEndpoint) ProtoMessage() {} func (x *RemoveNetworkEndpoint) 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 { @@ -12146,7 +12319,7 @@ func (x *RemoveNetworkEndpoint) ProtoReflect() protoreflect.Message { // Deprecated: Use RemoveNetworkEndpoint.ProtoReflect.Descriptor instead. func (*RemoveNetworkEndpoint) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{146} + return file_openshell_proto_rawDescGZIP(), []int{148} } func (x *RemoveNetworkEndpoint) GetRuleName() string { @@ -12179,7 +12352,7 @@ type RemoveNetworkRule struct { func (x *RemoveNetworkRule) Reset() { *x = RemoveNetworkRule{} - mi := &file_openshell_proto_msgTypes[147] + mi := &file_openshell_proto_msgTypes[149] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12191,7 +12364,7 @@ func (x *RemoveNetworkRule) String() string { func (*RemoveNetworkRule) ProtoMessage() {} func (x *RemoveNetworkRule) 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 { @@ -12204,7 +12377,7 @@ func (x *RemoveNetworkRule) ProtoReflect() protoreflect.Message { // Deprecated: Use RemoveNetworkRule.ProtoReflect.Descriptor instead. func (*RemoveNetworkRule) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{147} + return file_openshell_proto_rawDescGZIP(), []int{149} } func (x *RemoveNetworkRule) GetRuleName() string { @@ -12233,7 +12406,7 @@ type L7RuleTarget struct { func (x *L7RuleTarget) Reset() { *x = L7RuleTarget{} - mi := &file_openshell_proto_msgTypes[148] + mi := &file_openshell_proto_msgTypes[150] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12245,7 +12418,7 @@ func (x *L7RuleTarget) String() string { func (*L7RuleTarget) ProtoMessage() {} func (x *L7RuleTarget) 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 { @@ -12258,7 +12431,7 @@ func (x *L7RuleTarget) ProtoReflect() protoreflect.Message { // Deprecated: Use L7RuleTarget.ProtoReflect.Descriptor instead. func (*L7RuleTarget) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{148} + return file_openshell_proto_rawDescGZIP(), []int{150} } func (x *L7RuleTarget) GetRuleName() string { @@ -12313,7 +12486,7 @@ type AddDenyRules struct { func (x *AddDenyRules) Reset() { *x = AddDenyRules{} - mi := &file_openshell_proto_msgTypes[149] + mi := &file_openshell_proto_msgTypes[151] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12325,7 +12498,7 @@ func (x *AddDenyRules) String() string { func (*AddDenyRules) ProtoMessage() {} func (x *AddDenyRules) 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 { @@ -12338,7 +12511,7 @@ func (x *AddDenyRules) ProtoReflect() protoreflect.Message { // Deprecated: Use AddDenyRules.ProtoReflect.Descriptor instead. func (*AddDenyRules) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{149} + return file_openshell_proto_rawDescGZIP(), []int{151} } func (x *AddDenyRules) GetDenyRules() []*sandboxv1.L7DenyRule { @@ -12365,7 +12538,7 @@ type AddAllowRules struct { func (x *AddAllowRules) Reset() { *x = AddAllowRules{} - mi := &file_openshell_proto_msgTypes[150] + mi := &file_openshell_proto_msgTypes[152] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12377,7 +12550,7 @@ func (x *AddAllowRules) String() string { func (*AddAllowRules) ProtoMessage() {} func (x *AddAllowRules) 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 { @@ -12390,7 +12563,7 @@ func (x *AddAllowRules) ProtoReflect() protoreflect.Message { // Deprecated: Use AddAllowRules.ProtoReflect.Descriptor instead. func (*AddAllowRules) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{150} + return file_openshell_proto_rawDescGZIP(), []int{152} } func (x *AddAllowRules) GetRules() []*sandboxv1.L7Rule { @@ -12417,7 +12590,7 @@ type RemoveNetworkBinary struct { func (x *RemoveNetworkBinary) Reset() { *x = RemoveNetworkBinary{} - mi := &file_openshell_proto_msgTypes[151] + mi := &file_openshell_proto_msgTypes[153] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12429,7 +12602,7 @@ func (x *RemoveNetworkBinary) String() string { func (*RemoveNetworkBinary) ProtoMessage() {} func (x *RemoveNetworkBinary) 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 { @@ -12442,7 +12615,7 @@ func (x *RemoveNetworkBinary) ProtoReflect() protoreflect.Message { // Deprecated: Use RemoveNetworkBinary.ProtoReflect.Descriptor instead. func (*RemoveNetworkBinary) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{151} + return file_openshell_proto_rawDescGZIP(), []int{153} } func (x *RemoveNetworkBinary) GetRuleName() string { @@ -12478,7 +12651,7 @@ type UpdateConfigResponse struct { func (x *UpdateConfigResponse) Reset() { *x = UpdateConfigResponse{} - mi := &file_openshell_proto_msgTypes[152] + mi := &file_openshell_proto_msgTypes[154] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12490,7 +12663,7 @@ func (x *UpdateConfigResponse) String() string { func (*UpdateConfigResponse) ProtoMessage() {} func (x *UpdateConfigResponse) 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 { @@ -12503,7 +12676,7 @@ func (x *UpdateConfigResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use UpdateConfigResponse.ProtoReflect.Descriptor instead. func (*UpdateConfigResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{152} + return file_openshell_proto_rawDescGZIP(), []int{154} } func (x *UpdateConfigResponse) GetVersion() uint32 { @@ -12557,7 +12730,7 @@ type GetSandboxPolicyStatusRequest struct { func (x *GetSandboxPolicyStatusRequest) Reset() { *x = GetSandboxPolicyStatusRequest{} - mi := &file_openshell_proto_msgTypes[153] + mi := &file_openshell_proto_msgTypes[155] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12569,7 +12742,7 @@ func (x *GetSandboxPolicyStatusRequest) String() string { func (*GetSandboxPolicyStatusRequest) ProtoMessage() {} func (x *GetSandboxPolicyStatusRequest) 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 { @@ -12582,7 +12755,7 @@ func (x *GetSandboxPolicyStatusRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetSandboxPolicyStatusRequest.ProtoReflect.Descriptor instead. func (*GetSandboxPolicyStatusRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{153} + return file_openshell_proto_rawDescGZIP(), []int{155} } func (x *GetSandboxPolicyStatusRequest) GetWorkspaceScope() *datamodelv1.WorkspaceSelector { @@ -12626,7 +12799,7 @@ type GetSandboxPolicyStatusResponse struct { func (x *GetSandboxPolicyStatusResponse) Reset() { *x = GetSandboxPolicyStatusResponse{} - mi := &file_openshell_proto_msgTypes[154] + mi := &file_openshell_proto_msgTypes[156] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12638,7 +12811,7 @@ func (x *GetSandboxPolicyStatusResponse) String() string { func (*GetSandboxPolicyStatusResponse) ProtoMessage() {} func (x *GetSandboxPolicyStatusResponse) 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 { @@ -12651,7 +12824,7 @@ func (x *GetSandboxPolicyStatusResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use GetSandboxPolicyStatusResponse.ProtoReflect.Descriptor instead. func (*GetSandboxPolicyStatusResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{154} + return file_openshell_proto_rawDescGZIP(), []int{156} } func (x *GetSandboxPolicyStatusResponse) GetRevision() *SandboxPolicyRevision { @@ -12688,7 +12861,7 @@ type ListSandboxPoliciesRequest struct { func (x *ListSandboxPoliciesRequest) Reset() { *x = ListSandboxPoliciesRequest{} - mi := &file_openshell_proto_msgTypes[155] + mi := &file_openshell_proto_msgTypes[157] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12700,7 +12873,7 @@ func (x *ListSandboxPoliciesRequest) String() string { func (*ListSandboxPoliciesRequest) ProtoMessage() {} func (x *ListSandboxPoliciesRequest) 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 { @@ -12713,7 +12886,7 @@ func (x *ListSandboxPoliciesRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListSandboxPoliciesRequest.ProtoReflect.Descriptor instead. func (*ListSandboxPoliciesRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{155} + return file_openshell_proto_rawDescGZIP(), []int{157} } func (x *ListSandboxPoliciesRequest) GetWorkspaceScope() *datamodelv1.WorkspaceSelector { @@ -12765,7 +12938,7 @@ type ListSandboxPoliciesResponse struct { func (x *ListSandboxPoliciesResponse) Reset() { *x = ListSandboxPoliciesResponse{} - mi := &file_openshell_proto_msgTypes[156] + mi := &file_openshell_proto_msgTypes[158] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12777,7 +12950,7 @@ func (x *ListSandboxPoliciesResponse) String() string { func (*ListSandboxPoliciesResponse) ProtoMessage() {} func (x *ListSandboxPoliciesResponse) 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 { @@ -12790,7 +12963,7 @@ func (x *ListSandboxPoliciesResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListSandboxPoliciesResponse.ProtoReflect.Descriptor instead. func (*ListSandboxPoliciesResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{156} + return file_openshell_proto_rawDescGZIP(), []int{158} } func (x *ListSandboxPoliciesResponse) GetRevisions() []*SandboxPolicyRevision { @@ -12824,7 +12997,7 @@ type ReportPolicyStatusRequest struct { func (x *ReportPolicyStatusRequest) Reset() { *x = ReportPolicyStatusRequest{} - mi := &file_openshell_proto_msgTypes[157] + mi := &file_openshell_proto_msgTypes[159] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12836,7 +13009,7 @@ func (x *ReportPolicyStatusRequest) String() string { func (*ReportPolicyStatusRequest) ProtoMessage() {} func (x *ReportPolicyStatusRequest) 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 { @@ -12849,7 +13022,7 @@ func (x *ReportPolicyStatusRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ReportPolicyStatusRequest.ProtoReflect.Descriptor instead. func (*ReportPolicyStatusRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{157} + return file_openshell_proto_rawDescGZIP(), []int{159} } func (x *ReportPolicyStatusRequest) GetSandboxId() string { @@ -12889,7 +13062,7 @@ type ReportPolicyStatusResponse struct { func (x *ReportPolicyStatusResponse) Reset() { *x = ReportPolicyStatusResponse{} - mi := &file_openshell_proto_msgTypes[158] + mi := &file_openshell_proto_msgTypes[160] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12901,7 +13074,7 @@ func (x *ReportPolicyStatusResponse) String() string { func (*ReportPolicyStatusResponse) ProtoMessage() {} func (x *ReportPolicyStatusResponse) 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 { @@ -12914,7 +13087,7 @@ func (x *ReportPolicyStatusResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ReportPolicyStatusResponse.ProtoReflect.Descriptor instead. func (*ReportPolicyStatusResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{158} + return file_openshell_proto_rawDescGZIP(), []int{160} } type SandboxConfigurationAdmission struct { @@ -12932,7 +13105,7 @@ type SandboxConfigurationAdmission struct { func (x *SandboxConfigurationAdmission) Reset() { *x = SandboxConfigurationAdmission{} - mi := &file_openshell_proto_msgTypes[159] + mi := &file_openshell_proto_msgTypes[161] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12944,7 +13117,7 @@ func (x *SandboxConfigurationAdmission) String() string { func (*SandboxConfigurationAdmission) ProtoMessage() {} func (x *SandboxConfigurationAdmission) 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 { @@ -12957,7 +13130,7 @@ func (x *SandboxConfigurationAdmission) ProtoReflect() protoreflect.Message { // Deprecated: Use SandboxConfigurationAdmission.ProtoReflect.Descriptor instead. func (*SandboxConfigurationAdmission) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{159} + return file_openshell_proto_rawDescGZIP(), []int{161} } func (x *SandboxConfigurationAdmission) GetInstanceId() string { @@ -13021,7 +13194,7 @@ type ReportSandboxConfigurationRequest struct { func (x *ReportSandboxConfigurationRequest) Reset() { *x = ReportSandboxConfigurationRequest{} - mi := &file_openshell_proto_msgTypes[160] + mi := &file_openshell_proto_msgTypes[162] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13033,7 +13206,7 @@ func (x *ReportSandboxConfigurationRequest) String() string { func (*ReportSandboxConfigurationRequest) ProtoMessage() {} func (x *ReportSandboxConfigurationRequest) 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 { @@ -13046,7 +13219,7 @@ func (x *ReportSandboxConfigurationRequest) ProtoReflect() protoreflect.Message // Deprecated: Use ReportSandboxConfigurationRequest.ProtoReflect.Descriptor instead. func (*ReportSandboxConfigurationRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{160} + return file_openshell_proto_rawDescGZIP(), []int{162} } func (x *ReportSandboxConfigurationRequest) GetSandboxId() string { @@ -13078,7 +13251,7 @@ type ReportSandboxConfigurationResponse struct { func (x *ReportSandboxConfigurationResponse) Reset() { *x = ReportSandboxConfigurationResponse{} - mi := &file_openshell_proto_msgTypes[161] + mi := &file_openshell_proto_msgTypes[163] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13090,7 +13263,7 @@ func (x *ReportSandboxConfigurationResponse) String() string { func (*ReportSandboxConfigurationResponse) ProtoMessage() {} func (x *ReportSandboxConfigurationResponse) 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 { @@ -13103,7 +13276,7 @@ func (x *ReportSandboxConfigurationResponse) ProtoReflect() protoreflect.Message // Deprecated: Use ReportSandboxConfigurationResponse.ProtoReflect.Descriptor instead. func (*ReportSandboxConfigurationResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{161} + return file_openshell_proto_rawDescGZIP(), []int{163} } // A versioned policy revision with metadata. @@ -13136,7 +13309,7 @@ type SandboxPolicyRevision struct { func (x *SandboxPolicyRevision) Reset() { *x = SandboxPolicyRevision{} - mi := &file_openshell_proto_msgTypes[162] + mi := &file_openshell_proto_msgTypes[164] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13148,7 +13321,7 @@ func (x *SandboxPolicyRevision) String() string { func (*SandboxPolicyRevision) ProtoMessage() {} func (x *SandboxPolicyRevision) 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 { @@ -13161,7 +13334,7 @@ func (x *SandboxPolicyRevision) ProtoReflect() protoreflect.Message { // Deprecated: Use SandboxPolicyRevision.ProtoReflect.Descriptor instead. func (*SandboxPolicyRevision) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{162} + return file_openshell_proto_rawDescGZIP(), []int{164} } func (x *SandboxPolicyRevision) GetVersion() uint32 { @@ -13241,7 +13414,7 @@ type GetSandboxLogsRequest struct { func (x *GetSandboxLogsRequest) Reset() { *x = GetSandboxLogsRequest{} - mi := &file_openshell_proto_msgTypes[163] + mi := &file_openshell_proto_msgTypes[165] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13253,7 +13426,7 @@ func (x *GetSandboxLogsRequest) String() string { func (*GetSandboxLogsRequest) ProtoMessage() {} func (x *GetSandboxLogsRequest) 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 { @@ -13266,7 +13439,7 @@ func (x *GetSandboxLogsRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetSandboxLogsRequest.ProtoReflect.Descriptor instead. func (*GetSandboxLogsRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{163} + return file_openshell_proto_rawDescGZIP(), []int{165} } func (x *GetSandboxLogsRequest) GetWorkspaceScope() *datamodelv1.WorkspaceSelector { @@ -13324,7 +13497,7 @@ type PushSandboxLogsRequest struct { func (x *PushSandboxLogsRequest) Reset() { *x = PushSandboxLogsRequest{} - mi := &file_openshell_proto_msgTypes[164] + mi := &file_openshell_proto_msgTypes[166] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13336,7 +13509,7 @@ func (x *PushSandboxLogsRequest) String() string { func (*PushSandboxLogsRequest) ProtoMessage() {} func (x *PushSandboxLogsRequest) 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 { @@ -13349,7 +13522,7 @@ func (x *PushSandboxLogsRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use PushSandboxLogsRequest.ProtoReflect.Descriptor instead. func (*PushSandboxLogsRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{164} + return file_openshell_proto_rawDescGZIP(), []int{166} } func (x *PushSandboxLogsRequest) GetSandboxId() string { @@ -13375,7 +13548,7 @@ type PushSandboxLogsResponse struct { func (x *PushSandboxLogsResponse) Reset() { *x = PushSandboxLogsResponse{} - mi := &file_openshell_proto_msgTypes[165] + mi := &file_openshell_proto_msgTypes[167] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13387,7 +13560,7 @@ func (x *PushSandboxLogsResponse) String() string { func (*PushSandboxLogsResponse) ProtoMessage() {} func (x *PushSandboxLogsResponse) 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 { @@ -13400,7 +13573,7 @@ func (x *PushSandboxLogsResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use PushSandboxLogsResponse.ProtoReflect.Descriptor instead. func (*PushSandboxLogsResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{165} + return file_openshell_proto_rawDescGZIP(), []int{167} } // Get sandbox logs response. @@ -13416,7 +13589,7 @@ type GetSandboxLogsResponse struct { func (x *GetSandboxLogsResponse) Reset() { *x = GetSandboxLogsResponse{} - mi := &file_openshell_proto_msgTypes[166] + mi := &file_openshell_proto_msgTypes[168] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13428,7 +13601,7 @@ func (x *GetSandboxLogsResponse) String() string { func (*GetSandboxLogsResponse) ProtoMessage() {} func (x *GetSandboxLogsResponse) 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 { @@ -13441,7 +13614,7 @@ func (x *GetSandboxLogsResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use GetSandboxLogsResponse.ProtoReflect.Descriptor instead. func (*GetSandboxLogsResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{166} + return file_openshell_proto_rawDescGZIP(), []int{168} } func (x *GetSandboxLogsResponse) GetLogs() []*SandboxLogLine { @@ -13474,7 +13647,7 @@ type SupervisorMessage struct { func (x *SupervisorMessage) Reset() { *x = SupervisorMessage{} - mi := &file_openshell_proto_msgTypes[167] + mi := &file_openshell_proto_msgTypes[169] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13486,7 +13659,7 @@ func (x *SupervisorMessage) String() string { func (*SupervisorMessage) ProtoMessage() {} func (x *SupervisorMessage) 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 { @@ -13499,7 +13672,7 @@ func (x *SupervisorMessage) ProtoReflect() protoreflect.Message { // Deprecated: Use SupervisorMessage.ProtoReflect.Descriptor instead. func (*SupervisorMessage) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{167} + return file_openshell_proto_rawDescGZIP(), []int{169} } func (x *SupervisorMessage) GetPayload() isSupervisorMessage_Payload { @@ -13591,7 +13764,7 @@ type GatewayMessage struct { func (x *GatewayMessage) Reset() { *x = GatewayMessage{} - mi := &file_openshell_proto_msgTypes[168] + mi := &file_openshell_proto_msgTypes[170] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13603,7 +13776,7 @@ func (x *GatewayMessage) String() string { func (*GatewayMessage) ProtoMessage() {} func (x *GatewayMessage) 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 { @@ -13616,7 +13789,7 @@ func (x *GatewayMessage) ProtoReflect() protoreflect.Message { // Deprecated: Use GatewayMessage.ProtoReflect.Descriptor instead. func (*GatewayMessage) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{168} + return file_openshell_proto_rawDescGZIP(), []int{170} } func (x *GatewayMessage) GetPayload() isGatewayMessage_Payload { @@ -13746,7 +13919,7 @@ type SupervisorHello struct { func (x *SupervisorHello) Reset() { *x = SupervisorHello{} - mi := &file_openshell_proto_msgTypes[169] + mi := &file_openshell_proto_msgTypes[171] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13758,7 +13931,7 @@ func (x *SupervisorHello) String() string { func (*SupervisorHello) ProtoMessage() {} func (x *SupervisorHello) 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 { @@ -13771,7 +13944,7 @@ func (x *SupervisorHello) ProtoReflect() protoreflect.Message { // Deprecated: Use SupervisorHello.ProtoReflect.Descriptor instead. func (*SupervisorHello) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{169} + return file_openshell_proto_rawDescGZIP(), []int{171} } func (x *SupervisorHello) GetSandboxId() string { @@ -13829,7 +14002,7 @@ type SessionAccepted struct { func (x *SessionAccepted) Reset() { *x = SessionAccepted{} - mi := &file_openshell_proto_msgTypes[170] + mi := &file_openshell_proto_msgTypes[172] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13841,7 +14014,7 @@ func (x *SessionAccepted) String() string { func (*SessionAccepted) ProtoMessage() {} func (x *SessionAccepted) 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 { @@ -13854,7 +14027,7 @@ func (x *SessionAccepted) ProtoReflect() protoreflect.Message { // Deprecated: Use SessionAccepted.ProtoReflect.Descriptor instead. func (*SessionAccepted) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{170} + return file_openshell_proto_rawDescGZIP(), []int{172} } func (x *SessionAccepted) GetSessionId() string { @@ -13882,7 +14055,7 @@ type SessionRejected struct { func (x *SessionRejected) Reset() { *x = SessionRejected{} - mi := &file_openshell_proto_msgTypes[171] + mi := &file_openshell_proto_msgTypes[173] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13894,7 +14067,7 @@ func (x *SessionRejected) String() string { func (*SessionRejected) ProtoMessage() {} func (x *SessionRejected) 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 { @@ -13907,7 +14080,7 @@ func (x *SessionRejected) ProtoReflect() protoreflect.Message { // Deprecated: Use SessionRejected.ProtoReflect.Descriptor instead. func (*SessionRejected) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{171} + return file_openshell_proto_rawDescGZIP(), []int{173} } func (x *SessionRejected) GetReason() string { @@ -13936,7 +14109,7 @@ type SessionRedirect struct { func (x *SessionRedirect) Reset() { *x = SessionRedirect{} - mi := &file_openshell_proto_msgTypes[172] + mi := &file_openshell_proto_msgTypes[174] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13948,7 +14121,7 @@ func (x *SessionRedirect) String() string { func (*SessionRedirect) ProtoMessage() {} func (x *SessionRedirect) 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 { @@ -13961,7 +14134,7 @@ func (x *SessionRedirect) ProtoReflect() protoreflect.Message { // Deprecated: Use SessionRedirect.ProtoReflect.Descriptor instead. func (*SessionRedirect) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{172} + return file_openshell_proto_rawDescGZIP(), []int{174} } func (x *SessionRedirect) GetPeerEndpoint() string { @@ -13987,7 +14160,7 @@ type SupervisorHeartbeat struct { func (x *SupervisorHeartbeat) Reset() { *x = SupervisorHeartbeat{} - mi := &file_openshell_proto_msgTypes[173] + mi := &file_openshell_proto_msgTypes[175] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13999,7 +14172,7 @@ func (x *SupervisorHeartbeat) String() string { func (*SupervisorHeartbeat) ProtoMessage() {} func (x *SupervisorHeartbeat) 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 { @@ -14012,7 +14185,7 @@ func (x *SupervisorHeartbeat) ProtoReflect() protoreflect.Message { // Deprecated: Use SupervisorHeartbeat.ProtoReflect.Descriptor instead. func (*SupervisorHeartbeat) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{173} + return file_openshell_proto_rawDescGZIP(), []int{175} } // Gateway heartbeat. @@ -14024,7 +14197,7 @@ type GatewayHeartbeat struct { func (x *GatewayHeartbeat) Reset() { *x = GatewayHeartbeat{} - mi := &file_openshell_proto_msgTypes[174] + mi := &file_openshell_proto_msgTypes[176] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14036,7 +14209,7 @@ func (x *GatewayHeartbeat) String() string { func (*GatewayHeartbeat) ProtoMessage() {} func (x *GatewayHeartbeat) 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 { @@ -14049,7 +14222,7 @@ func (x *GatewayHeartbeat) ProtoReflect() protoreflect.Message { // Deprecated: Use GatewayHeartbeat.ProtoReflect.Descriptor instead. func (*GatewayHeartbeat) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{174} + return file_openshell_proto_rawDescGZIP(), []int{176} } // Terminal result reported before the supervisor shuts down. A successful RPC @@ -14066,7 +14239,7 @@ type ReportMainProcessExitRequest struct { func (x *ReportMainProcessExitRequest) Reset() { *x = ReportMainProcessExitRequest{} - mi := &file_openshell_proto_msgTypes[175] + mi := &file_openshell_proto_msgTypes[177] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14078,7 +14251,7 @@ func (x *ReportMainProcessExitRequest) String() string { func (*ReportMainProcessExitRequest) ProtoMessage() {} func (x *ReportMainProcessExitRequest) 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 { @@ -14091,7 +14264,7 @@ func (x *ReportMainProcessExitRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ReportMainProcessExitRequest.ProtoReflect.Descriptor instead. func (*ReportMainProcessExitRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{175} + return file_openshell_proto_rawDescGZIP(), []int{177} } func (x *ReportMainProcessExitRequest) GetSandboxId() string { @@ -14123,7 +14296,7 @@ type ReportMainProcessExitResponse struct { func (x *ReportMainProcessExitResponse) Reset() { *x = ReportMainProcessExitResponse{} - mi := &file_openshell_proto_msgTypes[176] + mi := &file_openshell_proto_msgTypes[178] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14135,7 +14308,7 @@ func (x *ReportMainProcessExitResponse) String() string { func (*ReportMainProcessExitResponse) ProtoMessage() {} func (x *ReportMainProcessExitResponse) 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 { @@ -14148,7 +14321,7 @@ func (x *ReportMainProcessExitResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ReportMainProcessExitResponse.ProtoReflect.Descriptor instead. func (*ReportMainProcessExitResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{176} + return file_openshell_proto_rawDescGZIP(), []int{178} } // Terminal-delivery completion reported after all expected foreground SSH @@ -14163,7 +14336,7 @@ type FinalizeMainProcessExitRequest struct { func (x *FinalizeMainProcessExitRequest) Reset() { *x = FinalizeMainProcessExitRequest{} - mi := &file_openshell_proto_msgTypes[177] + mi := &file_openshell_proto_msgTypes[179] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14175,7 +14348,7 @@ func (x *FinalizeMainProcessExitRequest) String() string { func (*FinalizeMainProcessExitRequest) ProtoMessage() {} func (x *FinalizeMainProcessExitRequest) 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 { @@ -14188,7 +14361,7 @@ func (x *FinalizeMainProcessExitRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use FinalizeMainProcessExitRequest.ProtoReflect.Descriptor instead. func (*FinalizeMainProcessExitRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{177} + return file_openshell_proto_rawDescGZIP(), []int{179} } func (x *FinalizeMainProcessExitRequest) GetSandboxId() string { @@ -14213,7 +14386,7 @@ type FinalizeMainProcessExitResponse struct { func (x *FinalizeMainProcessExitResponse) Reset() { *x = FinalizeMainProcessExitResponse{} - mi := &file_openshell_proto_msgTypes[178] + mi := &file_openshell_proto_msgTypes[180] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14225,7 +14398,7 @@ func (x *FinalizeMainProcessExitResponse) String() string { func (*FinalizeMainProcessExitResponse) ProtoMessage() {} func (x *FinalizeMainProcessExitResponse) 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 { @@ -14238,7 +14411,7 @@ func (x *FinalizeMainProcessExitResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use FinalizeMainProcessExitResponse.ProtoReflect.Descriptor instead. func (*FinalizeMainProcessExitResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{178} + return file_openshell_proto_rawDescGZIP(), []int{180} } // Gateway requests the supervisor to open a relay channel. @@ -14267,7 +14440,7 @@ type RelayOpen struct { func (x *RelayOpen) Reset() { *x = RelayOpen{} - mi := &file_openshell_proto_msgTypes[179] + mi := &file_openshell_proto_msgTypes[181] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14279,7 +14452,7 @@ func (x *RelayOpen) String() string { func (*RelayOpen) ProtoMessage() {} func (x *RelayOpen) 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 { @@ -14292,7 +14465,7 @@ func (x *RelayOpen) ProtoReflect() protoreflect.Message { // Deprecated: Use RelayOpen.ProtoReflect.Descriptor instead. func (*RelayOpen) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{179} + return file_openshell_proto_rawDescGZIP(), []int{181} } func (x *RelayOpen) GetChannelId() string { @@ -14359,7 +14532,7 @@ type SshRelayTarget struct { func (x *SshRelayTarget) Reset() { *x = SshRelayTarget{} - mi := &file_openshell_proto_msgTypes[180] + mi := &file_openshell_proto_msgTypes[182] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14371,7 +14544,7 @@ func (x *SshRelayTarget) String() string { func (*SshRelayTarget) ProtoMessage() {} func (x *SshRelayTarget) 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 { @@ -14384,7 +14557,7 @@ func (x *SshRelayTarget) ProtoReflect() protoreflect.Message { // Deprecated: Use SshRelayTarget.ProtoReflect.Descriptor instead. func (*SshRelayTarget) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{180} + return file_openshell_proto_rawDescGZIP(), []int{182} } // TCP target dialed by the supervisor from inside the sandbox. @@ -14400,7 +14573,7 @@ type TcpRelayTarget struct { func (x *TcpRelayTarget) Reset() { *x = TcpRelayTarget{} - mi := &file_openshell_proto_msgTypes[181] + mi := &file_openshell_proto_msgTypes[183] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14412,7 +14585,7 @@ func (x *TcpRelayTarget) String() string { func (*TcpRelayTarget) ProtoMessage() {} func (x *TcpRelayTarget) 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 { @@ -14425,7 +14598,7 @@ func (x *TcpRelayTarget) ProtoReflect() protoreflect.Message { // Deprecated: Use TcpRelayTarget.ProtoReflect.Descriptor instead. func (*TcpRelayTarget) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{181} + return file_openshell_proto_rawDescGZIP(), []int{183} } func (x *TcpRelayTarget) GetHost() string { @@ -14453,7 +14626,7 @@ type RelayInit struct { func (x *RelayInit) Reset() { *x = RelayInit{} - mi := &file_openshell_proto_msgTypes[182] + mi := &file_openshell_proto_msgTypes[184] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14465,7 +14638,7 @@ func (x *RelayInit) String() string { func (*RelayInit) ProtoMessage() {} func (x *RelayInit) 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 { @@ -14478,7 +14651,7 @@ func (x *RelayInit) ProtoReflect() protoreflect.Message { // Deprecated: Use RelayInit.ProtoReflect.Descriptor instead. func (*RelayInit) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{182} + return file_openshell_proto_rawDescGZIP(), []int{184} } func (x *RelayInit) GetChannelId() string { @@ -14505,7 +14678,7 @@ type RelayFrame struct { func (x *RelayFrame) Reset() { *x = RelayFrame{} - mi := &file_openshell_proto_msgTypes[183] + mi := &file_openshell_proto_msgTypes[185] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14517,7 +14690,7 @@ func (x *RelayFrame) String() string { func (*RelayFrame) ProtoMessage() {} func (x *RelayFrame) 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 { @@ -14530,7 +14703,7 @@ func (x *RelayFrame) ProtoReflect() protoreflect.Message { // Deprecated: Use RelayFrame.ProtoReflect.Descriptor instead. func (*RelayFrame) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{183} + return file_openshell_proto_rawDescGZIP(), []int{185} } func (x *RelayFrame) GetPayload() isRelayFrame_Payload { @@ -14590,7 +14763,7 @@ type PeerRelayInit struct { func (x *PeerRelayInit) Reset() { *x = PeerRelayInit{} - mi := &file_openshell_proto_msgTypes[184] + mi := &file_openshell_proto_msgTypes[186] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14602,7 +14775,7 @@ func (x *PeerRelayInit) String() string { func (*PeerRelayInit) ProtoMessage() {} func (x *PeerRelayInit) 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 { @@ -14615,7 +14788,7 @@ func (x *PeerRelayInit) ProtoReflect() protoreflect.Message { // Deprecated: Use PeerRelayInit.ProtoReflect.Descriptor instead. func (*PeerRelayInit) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{184} + return file_openshell_proto_rawDescGZIP(), []int{186} } func (x *PeerRelayInit) GetSandboxId() string { @@ -14653,7 +14826,7 @@ type PeerRelayFrame struct { func (x *PeerRelayFrame) Reset() { *x = PeerRelayFrame{} - mi := &file_openshell_proto_msgTypes[185] + mi := &file_openshell_proto_msgTypes[187] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14665,7 +14838,7 @@ func (x *PeerRelayFrame) String() string { func (*PeerRelayFrame) ProtoMessage() {} func (x *PeerRelayFrame) 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 { @@ -14678,7 +14851,7 @@ func (x *PeerRelayFrame) ProtoReflect() protoreflect.Message { // Deprecated: Use PeerRelayFrame.ProtoReflect.Descriptor instead. func (*PeerRelayFrame) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{185} + return file_openshell_proto_rawDescGZIP(), []int{187} } func (x *PeerRelayFrame) GetPayload() isPeerRelayFrame_Payload { @@ -14737,7 +14910,7 @@ type RelayOpenResult struct { func (x *RelayOpenResult) Reset() { *x = RelayOpenResult{} - mi := &file_openshell_proto_msgTypes[186] + mi := &file_openshell_proto_msgTypes[188] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14749,7 +14922,7 @@ func (x *RelayOpenResult) String() string { func (*RelayOpenResult) ProtoMessage() {} func (x *RelayOpenResult) 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 { @@ -14762,7 +14935,7 @@ func (x *RelayOpenResult) ProtoReflect() protoreflect.Message { // Deprecated: Use RelayOpenResult.ProtoReflect.Descriptor instead. func (*RelayOpenResult) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{186} + return file_openshell_proto_rawDescGZIP(), []int{188} } func (x *RelayOpenResult) GetChannelId() string { @@ -14799,7 +14972,7 @@ type RelayClose struct { func (x *RelayClose) Reset() { *x = RelayClose{} - mi := &file_openshell_proto_msgTypes[187] + mi := &file_openshell_proto_msgTypes[189] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14811,7 +14984,7 @@ func (x *RelayClose) String() string { func (*RelayClose) ProtoMessage() {} func (x *RelayClose) 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 { @@ -14824,7 +14997,7 @@ func (x *RelayClose) ProtoReflect() protoreflect.Message { // Deprecated: Use RelayClose.ProtoReflect.Descriptor instead. func (*RelayClose) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{187} + return file_openshell_proto_rawDescGZIP(), []int{189} } func (x *RelayClose) GetChannelId() string { @@ -14858,7 +15031,7 @@ type L7RequestSample struct { func (x *L7RequestSample) Reset() { *x = L7RequestSample{} - mi := &file_openshell_proto_msgTypes[188] + mi := &file_openshell_proto_msgTypes[190] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14870,7 +15043,7 @@ func (x *L7RequestSample) String() string { func (*L7RequestSample) ProtoMessage() {} func (x *L7RequestSample) 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 { @@ -14883,7 +15056,7 @@ func (x *L7RequestSample) ProtoReflect() protoreflect.Message { // Deprecated: Use L7RequestSample.ProtoReflect.Descriptor instead. func (*L7RequestSample) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{188} + return file_openshell_proto_rawDescGZIP(), []int{190} } func (x *L7RequestSample) GetMethod() string { @@ -14957,7 +15130,7 @@ type DenialSummary struct { func (x *DenialSummary) Reset() { *x = DenialSummary{} - mi := &file_openshell_proto_msgTypes[189] + mi := &file_openshell_proto_msgTypes[191] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14969,7 +15142,7 @@ func (x *DenialSummary) String() string { func (*DenialSummary) ProtoMessage() {} func (x *DenialSummary) 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 { @@ -14982,7 +15155,7 @@ func (x *DenialSummary) ProtoReflect() protoreflect.Message { // Deprecated: Use DenialSummary.ProtoReflect.Descriptor instead. func (*DenialSummary) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{189} + return file_openshell_proto_rawDescGZIP(), []int{191} } func (x *DenialSummary) GetSandboxId() string { @@ -15117,7 +15290,7 @@ type DenialGroupCount struct { func (x *DenialGroupCount) Reset() { *x = DenialGroupCount{} - mi := &file_openshell_proto_msgTypes[190] + mi := &file_openshell_proto_msgTypes[192] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -15129,7 +15302,7 @@ func (x *DenialGroupCount) String() string { func (*DenialGroupCount) ProtoMessage() {} func (x *DenialGroupCount) 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 { @@ -15142,7 +15315,7 @@ func (x *DenialGroupCount) ProtoReflect() protoreflect.Message { // Deprecated: Use DenialGroupCount.ProtoReflect.Descriptor instead. func (*DenialGroupCount) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{190} + return file_openshell_proto_rawDescGZIP(), []int{192} } func (x *DenialGroupCount) GetDenyGroup() string { @@ -15175,7 +15348,7 @@ type NetworkActivitySummary struct { func (x *NetworkActivitySummary) Reset() { *x = NetworkActivitySummary{} - mi := &file_openshell_proto_msgTypes[191] + mi := &file_openshell_proto_msgTypes[193] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -15187,7 +15360,7 @@ func (x *NetworkActivitySummary) String() string { func (*NetworkActivitySummary) ProtoMessage() {} func (x *NetworkActivitySummary) 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 { @@ -15200,7 +15373,7 @@ func (x *NetworkActivitySummary) ProtoReflect() protoreflect.Message { // Deprecated: Use NetworkActivitySummary.ProtoReflect.Descriptor instead. func (*NetworkActivitySummary) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{191} + return file_openshell_proto_rawDescGZIP(), []int{193} } func (x *NetworkActivitySummary) GetNetworkActivityCount() uint32 { @@ -15288,7 +15461,7 @@ type PolicyChunk struct { func (x *PolicyChunk) Reset() { *x = PolicyChunk{} - mi := &file_openshell_proto_msgTypes[192] + mi := &file_openshell_proto_msgTypes[194] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -15300,7 +15473,7 @@ func (x *PolicyChunk) String() string { func (*PolicyChunk) ProtoMessage() {} func (x *PolicyChunk) 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 { @@ -15313,7 +15486,7 @@ func (x *PolicyChunk) ProtoReflect() protoreflect.Message { // Deprecated: Use PolicyChunk.ProtoReflect.Descriptor instead. func (*PolicyChunk) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{192} + return file_openshell_proto_rawDescGZIP(), []int{194} } func (x *PolicyChunk) GetId() string { @@ -15501,7 +15674,7 @@ type DraftPolicyUpdate struct { func (x *DraftPolicyUpdate) Reset() { *x = DraftPolicyUpdate{} - mi := &file_openshell_proto_msgTypes[193] + mi := &file_openshell_proto_msgTypes[195] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -15513,7 +15686,7 @@ func (x *DraftPolicyUpdate) String() string { func (*DraftPolicyUpdate) ProtoMessage() {} func (x *DraftPolicyUpdate) 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 { @@ -15526,7 +15699,7 @@ func (x *DraftPolicyUpdate) ProtoReflect() protoreflect.Message { // Deprecated: Use DraftPolicyUpdate.ProtoReflect.Descriptor instead. func (*DraftPolicyUpdate) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{193} + return file_openshell_proto_rawDescGZIP(), []int{195} } func (x *DraftPolicyUpdate) GetDraftVersion() uint64 { @@ -15585,7 +15758,7 @@ type SubmitPolicyAnalysisRequest struct { func (x *SubmitPolicyAnalysisRequest) Reset() { *x = SubmitPolicyAnalysisRequest{} - mi := &file_openshell_proto_msgTypes[194] + mi := &file_openshell_proto_msgTypes[196] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -15597,7 +15770,7 @@ func (x *SubmitPolicyAnalysisRequest) String() string { func (*SubmitPolicyAnalysisRequest) ProtoMessage() {} func (x *SubmitPolicyAnalysisRequest) 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 { @@ -15610,7 +15783,7 @@ func (x *SubmitPolicyAnalysisRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use SubmitPolicyAnalysisRequest.ProtoReflect.Descriptor instead. func (*SubmitPolicyAnalysisRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{194} + return file_openshell_proto_rawDescGZIP(), []int{196} } func (x *SubmitPolicyAnalysisRequest) GetWorkspaceScope() *datamodelv1.WorkspaceSelector { @@ -15673,7 +15846,7 @@ type SubmitPolicyAnalysisResponse struct { func (x *SubmitPolicyAnalysisResponse) Reset() { *x = SubmitPolicyAnalysisResponse{} - mi := &file_openshell_proto_msgTypes[195] + mi := &file_openshell_proto_msgTypes[197] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -15685,7 +15858,7 @@ func (x *SubmitPolicyAnalysisResponse) String() string { func (*SubmitPolicyAnalysisResponse) ProtoMessage() {} func (x *SubmitPolicyAnalysisResponse) 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 { @@ -15698,7 +15871,7 @@ func (x *SubmitPolicyAnalysisResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use SubmitPolicyAnalysisResponse.ProtoReflect.Descriptor instead. func (*SubmitPolicyAnalysisResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{195} + return file_openshell_proto_rawDescGZIP(), []int{197} } func (x *SubmitPolicyAnalysisResponse) GetAcceptedChunks() uint32 { @@ -15743,7 +15916,7 @@ type GetDraftPolicyRequest struct { func (x *GetDraftPolicyRequest) Reset() { *x = GetDraftPolicyRequest{} - mi := &file_openshell_proto_msgTypes[196] + mi := &file_openshell_proto_msgTypes[198] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -15755,7 +15928,7 @@ func (x *GetDraftPolicyRequest) String() string { func (*GetDraftPolicyRequest) ProtoMessage() {} func (x *GetDraftPolicyRequest) 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 { @@ -15768,7 +15941,7 @@ func (x *GetDraftPolicyRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetDraftPolicyRequest.ProtoReflect.Descriptor instead. func (*GetDraftPolicyRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{196} + return file_openshell_proto_rawDescGZIP(), []int{198} } func (x *GetDraftPolicyRequest) GetWorkspaceScope() *datamodelv1.WorkspaceSelector { @@ -15808,7 +15981,7 @@ type GetDraftPolicyResponse struct { func (x *GetDraftPolicyResponse) Reset() { *x = GetDraftPolicyResponse{} - mi := &file_openshell_proto_msgTypes[197] + mi := &file_openshell_proto_msgTypes[199] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -15820,7 +15993,7 @@ func (x *GetDraftPolicyResponse) String() string { func (*GetDraftPolicyResponse) ProtoMessage() {} func (x *GetDraftPolicyResponse) 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 { @@ -15833,7 +16006,7 @@ func (x *GetDraftPolicyResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use GetDraftPolicyResponse.ProtoReflect.Descriptor instead. func (*GetDraftPolicyResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{197} + return file_openshell_proto_rawDescGZIP(), []int{199} } func (x *GetDraftPolicyResponse) GetChunks() []*PolicyChunk { @@ -15884,7 +16057,7 @@ type ApproveDraftChunkRequest struct { func (x *ApproveDraftChunkRequest) Reset() { *x = ApproveDraftChunkRequest{} - mi := &file_openshell_proto_msgTypes[198] + mi := &file_openshell_proto_msgTypes[200] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -15896,7 +16069,7 @@ func (x *ApproveDraftChunkRequest) String() string { func (*ApproveDraftChunkRequest) ProtoMessage() {} func (x *ApproveDraftChunkRequest) 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 { @@ -15909,7 +16082,7 @@ func (x *ApproveDraftChunkRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ApproveDraftChunkRequest.ProtoReflect.Descriptor instead. func (*ApproveDraftChunkRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{198} + return file_openshell_proto_rawDescGZIP(), []int{200} } func (x *ApproveDraftChunkRequest) GetWorkspaceScope() *datamodelv1.WorkspaceSelector { @@ -15959,7 +16132,7 @@ type ApproveDraftChunkResponse struct { func (x *ApproveDraftChunkResponse) Reset() { *x = ApproveDraftChunkResponse{} - mi := &file_openshell_proto_msgTypes[199] + mi := &file_openshell_proto_msgTypes[201] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -15971,7 +16144,7 @@ func (x *ApproveDraftChunkResponse) String() string { func (*ApproveDraftChunkResponse) ProtoMessage() {} func (x *ApproveDraftChunkResponse) 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 { @@ -15984,7 +16157,7 @@ func (x *ApproveDraftChunkResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ApproveDraftChunkResponse.ProtoReflect.Descriptor instead. func (*ApproveDraftChunkResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{199} + return file_openshell_proto_rawDescGZIP(), []int{201} } func (x *ApproveDraftChunkResponse) GetPolicyVersion() uint32 { @@ -16020,7 +16193,7 @@ type RejectDraftChunkRequest struct { func (x *RejectDraftChunkRequest) Reset() { *x = RejectDraftChunkRequest{} - mi := &file_openshell_proto_msgTypes[200] + mi := &file_openshell_proto_msgTypes[202] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -16032,7 +16205,7 @@ func (x *RejectDraftChunkRequest) String() string { func (*RejectDraftChunkRequest) ProtoMessage() {} func (x *RejectDraftChunkRequest) 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 { @@ -16045,7 +16218,7 @@ func (x *RejectDraftChunkRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use RejectDraftChunkRequest.ProtoReflect.Descriptor instead. func (*RejectDraftChunkRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{200} + return file_openshell_proto_rawDescGZIP(), []int{202} } func (x *RejectDraftChunkRequest) GetWorkspaceScope() *datamodelv1.WorkspaceSelector { @@ -16091,7 +16264,7 @@ type RejectDraftChunkResponse struct { func (x *RejectDraftChunkResponse) Reset() { *x = RejectDraftChunkResponse{} - mi := &file_openshell_proto_msgTypes[201] + mi := &file_openshell_proto_msgTypes[203] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -16103,7 +16276,7 @@ func (x *RejectDraftChunkResponse) String() string { func (*RejectDraftChunkResponse) ProtoMessage() {} func (x *RejectDraftChunkResponse) 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 { @@ -16116,7 +16289,7 @@ func (x *RejectDraftChunkResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use RejectDraftChunkResponse.ProtoReflect.Descriptor instead. func (*RejectDraftChunkResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{201} + return file_openshell_proto_rawDescGZIP(), []int{203} } // Approve all pending chunks. @@ -16130,7 +16303,7 @@ type DraftChunkApproval struct { func (x *DraftChunkApproval) Reset() { *x = DraftChunkApproval{} - mi := &file_openshell_proto_msgTypes[202] + mi := &file_openshell_proto_msgTypes[204] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -16142,7 +16315,7 @@ func (x *DraftChunkApproval) String() string { func (*DraftChunkApproval) ProtoMessage() {} func (x *DraftChunkApproval) 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 { @@ -16155,7 +16328,7 @@ func (x *DraftChunkApproval) ProtoReflect() protoreflect.Message { // Deprecated: Use DraftChunkApproval.ProtoReflect.Descriptor instead. func (*DraftChunkApproval) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{202} + return file_openshell_proto_rawDescGZIP(), []int{204} } func (x *DraftChunkApproval) GetChunkId() string { @@ -16191,7 +16364,7 @@ type ApproveAllDraftChunksRequest struct { func (x *ApproveAllDraftChunksRequest) Reset() { *x = ApproveAllDraftChunksRequest{} - mi := &file_openshell_proto_msgTypes[203] + mi := &file_openshell_proto_msgTypes[205] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -16203,7 +16376,7 @@ func (x *ApproveAllDraftChunksRequest) String() string { func (*ApproveAllDraftChunksRequest) ProtoMessage() {} func (x *ApproveAllDraftChunksRequest) 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 { @@ -16216,7 +16389,7 @@ func (x *ApproveAllDraftChunksRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ApproveAllDraftChunksRequest.ProtoReflect.Descriptor instead. func (*ApproveAllDraftChunksRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{203} + return file_openshell_proto_rawDescGZIP(), []int{205} } func (x *ApproveAllDraftChunksRequest) GetWorkspaceScope() *datamodelv1.WorkspaceSelector { @@ -16271,7 +16444,7 @@ type ApproveAllDraftChunksResponse struct { func (x *ApproveAllDraftChunksResponse) Reset() { *x = ApproveAllDraftChunksResponse{} - mi := &file_openshell_proto_msgTypes[204] + mi := &file_openshell_proto_msgTypes[206] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -16283,7 +16456,7 @@ func (x *ApproveAllDraftChunksResponse) String() string { func (*ApproveAllDraftChunksResponse) ProtoMessage() {} func (x *ApproveAllDraftChunksResponse) 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 { @@ -16296,7 +16469,7 @@ func (x *ApproveAllDraftChunksResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ApproveAllDraftChunksResponse.ProtoReflect.Descriptor instead. func (*ApproveAllDraftChunksResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{204} + return file_openshell_proto_rawDescGZIP(), []int{206} } func (x *ApproveAllDraftChunksResponse) GetPolicyVersion() uint32 { @@ -16346,7 +16519,7 @@ type EditDraftChunkRequest struct { func (x *EditDraftChunkRequest) Reset() { *x = EditDraftChunkRequest{} - mi := &file_openshell_proto_msgTypes[205] + mi := &file_openshell_proto_msgTypes[207] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -16358,7 +16531,7 @@ func (x *EditDraftChunkRequest) String() string { func (*EditDraftChunkRequest) ProtoMessage() {} func (x *EditDraftChunkRequest) 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 { @@ -16371,7 +16544,7 @@ func (x *EditDraftChunkRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use EditDraftChunkRequest.ProtoReflect.Descriptor instead. func (*EditDraftChunkRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{205} + return file_openshell_proto_rawDescGZIP(), []int{207} } func (x *EditDraftChunkRequest) GetWorkspaceScope() *datamodelv1.WorkspaceSelector { @@ -16417,7 +16590,7 @@ type EditDraftChunkResponse struct { func (x *EditDraftChunkResponse) Reset() { *x = EditDraftChunkResponse{} - mi := &file_openshell_proto_msgTypes[206] + mi := &file_openshell_proto_msgTypes[208] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -16429,7 +16602,7 @@ func (x *EditDraftChunkResponse) String() string { func (*EditDraftChunkResponse) ProtoMessage() {} func (x *EditDraftChunkResponse) 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 { @@ -16442,7 +16615,7 @@ func (x *EditDraftChunkResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use EditDraftChunkResponse.ProtoReflect.Descriptor instead. func (*EditDraftChunkResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{206} + return file_openshell_proto_rawDescGZIP(), []int{208} } // Reverse an approval (remove merged rule from active policy). @@ -16462,7 +16635,7 @@ type UndoDraftChunkRequest struct { func (x *UndoDraftChunkRequest) Reset() { *x = UndoDraftChunkRequest{} - mi := &file_openshell_proto_msgTypes[207] + mi := &file_openshell_proto_msgTypes[209] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -16474,7 +16647,7 @@ func (x *UndoDraftChunkRequest) String() string { func (*UndoDraftChunkRequest) ProtoMessage() {} func (x *UndoDraftChunkRequest) 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 { @@ -16487,7 +16660,7 @@ func (x *UndoDraftChunkRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use UndoDraftChunkRequest.ProtoReflect.Descriptor instead. func (*UndoDraftChunkRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{207} + return file_openshell_proto_rawDescGZIP(), []int{209} } func (x *UndoDraftChunkRequest) GetWorkspaceScope() *datamodelv1.WorkspaceSelector { @@ -16530,7 +16703,7 @@ type UndoDraftChunkResponse struct { func (x *UndoDraftChunkResponse) Reset() { *x = UndoDraftChunkResponse{} - mi := &file_openshell_proto_msgTypes[208] + mi := &file_openshell_proto_msgTypes[210] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -16542,7 +16715,7 @@ func (x *UndoDraftChunkResponse) String() string { func (*UndoDraftChunkResponse) ProtoMessage() {} func (x *UndoDraftChunkResponse) 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 { @@ -16555,7 +16728,7 @@ func (x *UndoDraftChunkResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use UndoDraftChunkResponse.ProtoReflect.Descriptor instead. func (*UndoDraftChunkResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{208} + return file_openshell_proto_rawDescGZIP(), []int{210} } func (x *UndoDraftChunkResponse) GetPolicyVersion() uint32 { @@ -16587,7 +16760,7 @@ type ClearDraftChunksRequest struct { func (x *ClearDraftChunksRequest) Reset() { *x = ClearDraftChunksRequest{} - mi := &file_openshell_proto_msgTypes[209] + mi := &file_openshell_proto_msgTypes[211] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -16599,7 +16772,7 @@ func (x *ClearDraftChunksRequest) String() string { func (*ClearDraftChunksRequest) ProtoMessage() {} func (x *ClearDraftChunksRequest) 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 { @@ -16612,7 +16785,7 @@ func (x *ClearDraftChunksRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ClearDraftChunksRequest.ProtoReflect.Descriptor instead. func (*ClearDraftChunksRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{209} + return file_openshell_proto_rawDescGZIP(), []int{211} } func (x *ClearDraftChunksRequest) GetWorkspaceScope() *datamodelv1.WorkspaceSelector { @@ -16646,7 +16819,7 @@ type ClearDraftChunksResponse struct { func (x *ClearDraftChunksResponse) Reset() { *x = ClearDraftChunksResponse{} - mi := &file_openshell_proto_msgTypes[210] + mi := &file_openshell_proto_msgTypes[212] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -16658,7 +16831,7 @@ func (x *ClearDraftChunksResponse) String() string { func (*ClearDraftChunksResponse) ProtoMessage() {} func (x *ClearDraftChunksResponse) 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 { @@ -16671,7 +16844,7 @@ func (x *ClearDraftChunksResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ClearDraftChunksResponse.ProtoReflect.Descriptor instead. func (*ClearDraftChunksResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{210} + return file_openshell_proto_rawDescGZIP(), []int{212} } func (x *ClearDraftChunksResponse) GetChunksCleared() uint32 { @@ -16693,7 +16866,7 @@ type GetDraftHistoryRequest struct { func (x *GetDraftHistoryRequest) Reset() { *x = GetDraftHistoryRequest{} - mi := &file_openshell_proto_msgTypes[211] + mi := &file_openshell_proto_msgTypes[213] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -16705,7 +16878,7 @@ func (x *GetDraftHistoryRequest) String() string { func (*GetDraftHistoryRequest) ProtoMessage() {} func (x *GetDraftHistoryRequest) 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 { @@ -16718,7 +16891,7 @@ func (x *GetDraftHistoryRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetDraftHistoryRequest.ProtoReflect.Descriptor instead. func (*GetDraftHistoryRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{211} + return file_openshell_proto_rawDescGZIP(), []int{213} } func (x *GetDraftHistoryRequest) GetWorkspaceScope() *datamodelv1.WorkspaceSelector { @@ -16752,7 +16925,7 @@ type DraftHistoryEntry struct { func (x *DraftHistoryEntry) Reset() { *x = DraftHistoryEntry{} - mi := &file_openshell_proto_msgTypes[212] + mi := &file_openshell_proto_msgTypes[214] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -16764,7 +16937,7 @@ func (x *DraftHistoryEntry) String() string { func (*DraftHistoryEntry) ProtoMessage() {} func (x *DraftHistoryEntry) 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 { @@ -16777,7 +16950,7 @@ func (x *DraftHistoryEntry) ProtoReflect() protoreflect.Message { // Deprecated: Use DraftHistoryEntry.ProtoReflect.Descriptor instead. func (*DraftHistoryEntry) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{212} + return file_openshell_proto_rawDescGZIP(), []int{214} } func (x *DraftHistoryEntry) GetEventTime() *timestamppb.Timestamp { @@ -16818,7 +16991,7 @@ type GetDraftHistoryResponse struct { func (x *GetDraftHistoryResponse) Reset() { *x = GetDraftHistoryResponse{} - mi := &file_openshell_proto_msgTypes[213] + mi := &file_openshell_proto_msgTypes[215] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -16830,7 +17003,7 @@ func (x *GetDraftHistoryResponse) String() string { func (*GetDraftHistoryResponse) ProtoMessage() {} func (x *GetDraftHistoryResponse) 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 { @@ -16843,7 +17016,7 @@ func (x *GetDraftHistoryResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use GetDraftHistoryResponse.ProtoReflect.Descriptor instead. func (*GetDraftHistoryResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{213} + return file_openshell_proto_rawDescGZIP(), []int{215} } func (x *GetDraftHistoryResponse) GetEntries() []*DraftHistoryEntry { @@ -16868,7 +17041,7 @@ type CreateWorkspaceRequest struct { func (x *CreateWorkspaceRequest) Reset() { *x = CreateWorkspaceRequest{} - mi := &file_openshell_proto_msgTypes[214] + mi := &file_openshell_proto_msgTypes[216] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -16880,7 +17053,7 @@ func (x *CreateWorkspaceRequest) String() string { func (*CreateWorkspaceRequest) ProtoMessage() {} func (x *CreateWorkspaceRequest) 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 { @@ -16893,7 +17066,7 @@ func (x *CreateWorkspaceRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use CreateWorkspaceRequest.ProtoReflect.Descriptor instead. func (*CreateWorkspaceRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{214} + return file_openshell_proto_rawDescGZIP(), []int{216} } func (x *CreateWorkspaceRequest) GetName() string { @@ -16927,7 +17100,7 @@ type CreateWorkspaceResponse struct { func (x *CreateWorkspaceResponse) Reset() { *x = CreateWorkspaceResponse{} - mi := &file_openshell_proto_msgTypes[215] + mi := &file_openshell_proto_msgTypes[217] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -16939,7 +17112,7 @@ func (x *CreateWorkspaceResponse) String() string { func (*CreateWorkspaceResponse) ProtoMessage() {} func (x *CreateWorkspaceResponse) 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 { @@ -16952,7 +17125,7 @@ func (x *CreateWorkspaceResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use CreateWorkspaceResponse.ProtoReflect.Descriptor instead. func (*CreateWorkspaceResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{215} + return file_openshell_proto_rawDescGZIP(), []int{217} } func (x *CreateWorkspaceResponse) GetWorkspace() *datamodelv1.Workspace { @@ -16973,7 +17146,7 @@ type GetWorkspaceRequest struct { func (x *GetWorkspaceRequest) Reset() { *x = GetWorkspaceRequest{} - mi := &file_openshell_proto_msgTypes[216] + mi := &file_openshell_proto_msgTypes[218] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -16985,7 +17158,7 @@ func (x *GetWorkspaceRequest) String() string { func (*GetWorkspaceRequest) ProtoMessage() {} func (x *GetWorkspaceRequest) 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 { @@ -16998,7 +17171,7 @@ func (x *GetWorkspaceRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetWorkspaceRequest.ProtoReflect.Descriptor instead. func (*GetWorkspaceRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{216} + return file_openshell_proto_rawDescGZIP(), []int{218} } func (x *GetWorkspaceRequest) GetName() string { @@ -17018,7 +17191,7 @@ type GetWorkspaceResponse struct { func (x *GetWorkspaceResponse) Reset() { *x = GetWorkspaceResponse{} - mi := &file_openshell_proto_msgTypes[217] + mi := &file_openshell_proto_msgTypes[219] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -17030,7 +17203,7 @@ func (x *GetWorkspaceResponse) String() string { func (*GetWorkspaceResponse) ProtoMessage() {} func (x *GetWorkspaceResponse) 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 { @@ -17043,7 +17216,7 @@ func (x *GetWorkspaceResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use GetWorkspaceResponse.ProtoReflect.Descriptor instead. func (*GetWorkspaceResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{217} + return file_openshell_proto_rawDescGZIP(), []int{219} } func (x *GetWorkspaceResponse) GetWorkspace() *datamodelv1.Workspace { @@ -17070,7 +17243,7 @@ type ListWorkspacesRequest struct { func (x *ListWorkspacesRequest) Reset() { *x = ListWorkspacesRequest{} - mi := &file_openshell_proto_msgTypes[218] + mi := &file_openshell_proto_msgTypes[220] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -17082,7 +17255,7 @@ func (x *ListWorkspacesRequest) String() string { func (*ListWorkspacesRequest) ProtoMessage() {} func (x *ListWorkspacesRequest) 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 { @@ -17095,7 +17268,7 @@ func (x *ListWorkspacesRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListWorkspacesRequest.ProtoReflect.Descriptor instead. func (*ListWorkspacesRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{218} + return file_openshell_proto_rawDescGZIP(), []int{220} } func (x *ListWorkspacesRequest) GetPageSize() int32 { @@ -17131,7 +17304,7 @@ type ListWorkspacesResponse struct { func (x *ListWorkspacesResponse) Reset() { *x = ListWorkspacesResponse{} - mi := &file_openshell_proto_msgTypes[219] + mi := &file_openshell_proto_msgTypes[221] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -17143,7 +17316,7 @@ func (x *ListWorkspacesResponse) String() string { func (*ListWorkspacesResponse) ProtoMessage() {} func (x *ListWorkspacesResponse) 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 { @@ -17156,7 +17329,7 @@ func (x *ListWorkspacesResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListWorkspacesResponse.ProtoReflect.Descriptor instead. func (*ListWorkspacesResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{219} + return file_openshell_proto_rawDescGZIP(), []int{221} } func (x *ListWorkspacesResponse) GetWorkspaces() []*datamodelv1.Workspace { @@ -17187,7 +17360,7 @@ type DeleteWorkspaceRequest struct { func (x *DeleteWorkspaceRequest) Reset() { *x = DeleteWorkspaceRequest{} - mi := &file_openshell_proto_msgTypes[220] + mi := &file_openshell_proto_msgTypes[222] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -17199,7 +17372,7 @@ func (x *DeleteWorkspaceRequest) String() string { func (*DeleteWorkspaceRequest) ProtoMessage() {} func (x *DeleteWorkspaceRequest) 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 { @@ -17212,7 +17385,7 @@ func (x *DeleteWorkspaceRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteWorkspaceRequest.ProtoReflect.Descriptor instead. func (*DeleteWorkspaceRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{220} + return file_openshell_proto_rawDescGZIP(), []int{222} } func (x *DeleteWorkspaceRequest) GetName() string { @@ -17246,7 +17419,7 @@ type DeleteWorkspaceResponse struct { func (x *DeleteWorkspaceResponse) Reset() { *x = DeleteWorkspaceResponse{} - mi := &file_openshell_proto_msgTypes[221] + mi := &file_openshell_proto_msgTypes[223] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -17258,7 +17431,7 @@ func (x *DeleteWorkspaceResponse) String() string { func (*DeleteWorkspaceResponse) ProtoMessage() {} func (x *DeleteWorkspaceResponse) 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 { @@ -17271,7 +17444,7 @@ func (x *DeleteWorkspaceResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteWorkspaceResponse.ProtoReflect.Descriptor instead. func (*DeleteWorkspaceResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{221} + return file_openshell_proto_rawDescGZIP(), []int{223} } func (x *DeleteWorkspaceResponse) GetOutcome() DeletionOutcome { @@ -17295,7 +17468,7 @@ type WorkspaceMember struct { func (x *WorkspaceMember) Reset() { *x = WorkspaceMember{} - mi := &file_openshell_proto_msgTypes[222] + mi := &file_openshell_proto_msgTypes[224] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -17307,7 +17480,7 @@ func (x *WorkspaceMember) String() string { func (*WorkspaceMember) ProtoMessage() {} func (x *WorkspaceMember) 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 { @@ -17320,7 +17493,7 @@ func (x *WorkspaceMember) ProtoReflect() protoreflect.Message { // Deprecated: Use WorkspaceMember.ProtoReflect.Descriptor instead. func (*WorkspaceMember) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{222} + return file_openshell_proto_rawDescGZIP(), []int{224} } func (x *WorkspaceMember) GetMetadata() *datamodelv1.ObjectMeta { @@ -17361,7 +17534,7 @@ type AddWorkspaceMemberRequest struct { func (x *AddWorkspaceMemberRequest) Reset() { *x = AddWorkspaceMemberRequest{} - mi := &file_openshell_proto_msgTypes[223] + mi := &file_openshell_proto_msgTypes[225] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -17373,7 +17546,7 @@ func (x *AddWorkspaceMemberRequest) String() string { func (*AddWorkspaceMemberRequest) ProtoMessage() {} func (x *AddWorkspaceMemberRequest) 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 { @@ -17386,7 +17559,7 @@ func (x *AddWorkspaceMemberRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use AddWorkspaceMemberRequest.ProtoReflect.Descriptor instead. func (*AddWorkspaceMemberRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{223} + return file_openshell_proto_rawDescGZIP(), []int{225} } func (x *AddWorkspaceMemberRequest) GetWorkspaceScope() *datamodelv1.WorkspaceSelector { @@ -17427,7 +17600,7 @@ type AddWorkspaceMemberResponse struct { func (x *AddWorkspaceMemberResponse) Reset() { *x = AddWorkspaceMemberResponse{} - mi := &file_openshell_proto_msgTypes[224] + mi := &file_openshell_proto_msgTypes[226] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -17439,7 +17612,7 @@ func (x *AddWorkspaceMemberResponse) String() string { func (*AddWorkspaceMemberResponse) ProtoMessage() {} func (x *AddWorkspaceMemberResponse) 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 { @@ -17452,7 +17625,7 @@ func (x *AddWorkspaceMemberResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use AddWorkspaceMemberResponse.ProtoReflect.Descriptor instead. func (*AddWorkspaceMemberResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{224} + return file_openshell_proto_rawDescGZIP(), []int{226} } func (x *AddWorkspaceMemberResponse) GetMember() *WorkspaceMember { @@ -17478,7 +17651,7 @@ type RemoveWorkspaceMemberRequest struct { func (x *RemoveWorkspaceMemberRequest) Reset() { *x = RemoveWorkspaceMemberRequest{} - mi := &file_openshell_proto_msgTypes[225] + mi := &file_openshell_proto_msgTypes[227] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -17490,7 +17663,7 @@ func (x *RemoveWorkspaceMemberRequest) String() string { func (*RemoveWorkspaceMemberRequest) ProtoMessage() {} func (x *RemoveWorkspaceMemberRequest) 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 { @@ -17503,7 +17676,7 @@ func (x *RemoveWorkspaceMemberRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use RemoveWorkspaceMemberRequest.ProtoReflect.Descriptor instead. func (*RemoveWorkspaceMemberRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{225} + return file_openshell_proto_rawDescGZIP(), []int{227} } func (x *RemoveWorkspaceMemberRequest) GetWorkspaceScope() *datamodelv1.WorkspaceSelector { @@ -17544,7 +17717,7 @@ type RemoveWorkspaceMemberResponse struct { func (x *RemoveWorkspaceMemberResponse) Reset() { *x = RemoveWorkspaceMemberResponse{} - mi := &file_openshell_proto_msgTypes[226] + mi := &file_openshell_proto_msgTypes[228] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -17556,7 +17729,7 @@ func (x *RemoveWorkspaceMemberResponse) String() string { func (*RemoveWorkspaceMemberResponse) ProtoMessage() {} func (x *RemoveWorkspaceMemberResponse) 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 { @@ -17569,7 +17742,7 @@ func (x *RemoveWorkspaceMemberResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use RemoveWorkspaceMemberResponse.ProtoReflect.Descriptor instead. func (*RemoveWorkspaceMemberResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{226} + return file_openshell_proto_rawDescGZIP(), []int{228} } func (x *RemoveWorkspaceMemberResponse) GetOutcome() DeletionOutcome { @@ -17596,7 +17769,7 @@ type ListWorkspaceMembersRequest struct { func (x *ListWorkspaceMembersRequest) Reset() { *x = ListWorkspaceMembersRequest{} - mi := &file_openshell_proto_msgTypes[227] + mi := &file_openshell_proto_msgTypes[229] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -17608,7 +17781,7 @@ func (x *ListWorkspaceMembersRequest) String() string { func (*ListWorkspaceMembersRequest) ProtoMessage() {} func (x *ListWorkspaceMembersRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[227] + mi := &file_openshell_proto_msgTypes[229] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -17621,7 +17794,7 @@ func (x *ListWorkspaceMembersRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListWorkspaceMembersRequest.ProtoReflect.Descriptor instead. func (*ListWorkspaceMembersRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{227} + return file_openshell_proto_rawDescGZIP(), []int{229} } func (x *ListWorkspaceMembersRequest) GetWorkspaceScope() *datamodelv1.WorkspaceSelector { @@ -17657,7 +17830,7 @@ type ListWorkspaceMembersResponse struct { func (x *ListWorkspaceMembersResponse) Reset() { *x = ListWorkspaceMembersResponse{} - mi := &file_openshell_proto_msgTypes[228] + mi := &file_openshell_proto_msgTypes[230] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -17669,7 +17842,7 @@ func (x *ListWorkspaceMembersResponse) String() string { func (*ListWorkspaceMembersResponse) ProtoMessage() {} func (x *ListWorkspaceMembersResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[228] + mi := &file_openshell_proto_msgTypes[230] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -17682,7 +17855,7 @@ func (x *ListWorkspaceMembersResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListWorkspaceMembersResponse.ProtoReflect.Descriptor instead. func (*ListWorkspaceMembersResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{228} + return file_openshell_proto_rawDescGZIP(), []int{230} } func (x *ListWorkspaceMembersResponse) GetMembers() []*WorkspaceMember { @@ -17717,7 +17890,7 @@ type ExtensionServiceCredential struct { func (x *ExtensionServiceCredential) Reset() { *x = ExtensionServiceCredential{} - mi := &file_openshell_proto_msgTypes[229] + mi := &file_openshell_proto_msgTypes[231] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -17729,7 +17902,7 @@ func (x *ExtensionServiceCredential) String() string { func (*ExtensionServiceCredential) ProtoMessage() {} func (x *ExtensionServiceCredential) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[229] + mi := &file_openshell_proto_msgTypes[231] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -17742,7 +17915,7 @@ func (x *ExtensionServiceCredential) ProtoReflect() protoreflect.Message { // Deprecated: Use ExtensionServiceCredential.ProtoReflect.Descriptor instead. func (*ExtensionServiceCredential) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{229} + return file_openshell_proto_rawDescGZIP(), []int{231} } func (x *ExtensionServiceCredential) GetServiceName() string { @@ -17782,7 +17955,7 @@ type EndpointObservation struct { func (x *EndpointObservation) Reset() { *x = EndpointObservation{} - mi := &file_openshell_proto_msgTypes[230] + mi := &file_openshell_proto_msgTypes[232] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -17794,7 +17967,7 @@ func (x *EndpointObservation) String() string { func (*EndpointObservation) ProtoMessage() {} func (x *EndpointObservation) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[230] + mi := &file_openshell_proto_msgTypes[232] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -17807,7 +17980,7 @@ func (x *EndpointObservation) ProtoReflect() protoreflect.Message { // Deprecated: Use EndpointObservation.ProtoReflect.Descriptor instead. func (*EndpointObservation) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{230} + return file_openshell_proto_rawDescGZIP(), []int{232} } func (x *EndpointObservation) GetEndpointId() string { @@ -17860,7 +18033,7 @@ type ReportEndpointStatusRequest struct { func (x *ReportEndpointStatusRequest) Reset() { *x = ReportEndpointStatusRequest{} - mi := &file_openshell_proto_msgTypes[231] + mi := &file_openshell_proto_msgTypes[233] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -17872,7 +18045,7 @@ func (x *ReportEndpointStatusRequest) String() string { func (*ReportEndpointStatusRequest) ProtoMessage() {} func (x *ReportEndpointStatusRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[231] + mi := &file_openshell_proto_msgTypes[233] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -17885,7 +18058,7 @@ func (x *ReportEndpointStatusRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ReportEndpointStatusRequest.ProtoReflect.Descriptor instead. func (*ReportEndpointStatusRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{231} + return file_openshell_proto_rawDescGZIP(), []int{233} } func (x *ReportEndpointStatusRequest) GetSandboxId() string { @@ -17954,7 +18127,7 @@ type TokenGrantStatus struct { func (x *TokenGrantStatus) Reset() { *x = TokenGrantStatus{} - mi := &file_openshell_proto_msgTypes[232] + mi := &file_openshell_proto_msgTypes[234] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -17966,7 +18139,7 @@ func (x *TokenGrantStatus) String() string { func (*TokenGrantStatus) ProtoMessage() {} func (x *TokenGrantStatus) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[232] + mi := &file_openshell_proto_msgTypes[234] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -17979,7 +18152,7 @@ func (x *TokenGrantStatus) ProtoReflect() protoreflect.Message { // Deprecated: Use TokenGrantStatus.ProtoReflect.Descriptor instead. func (*TokenGrantStatus) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{232} + return file_openshell_proto_rawDescGZIP(), []int{234} } func (x *TokenGrantStatus) GetLastFailure() *TokenGrantFailureObservation { @@ -18006,7 +18179,7 @@ type TokenGrantFailureObservation struct { func (x *TokenGrantFailureObservation) Reset() { *x = TokenGrantFailureObservation{} - mi := &file_openshell_proto_msgTypes[233] + mi := &file_openshell_proto_msgTypes[235] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -18018,7 +18191,7 @@ func (x *TokenGrantFailureObservation) String() string { func (*TokenGrantFailureObservation) ProtoMessage() {} func (x *TokenGrantFailureObservation) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[233] + mi := &file_openshell_proto_msgTypes[235] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -18031,7 +18204,7 @@ func (x *TokenGrantFailureObservation) ProtoReflect() protoreflect.Message { // Deprecated: Use TokenGrantFailureObservation.ProtoReflect.Descriptor instead. func (*TokenGrantFailureObservation) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{233} + return file_openshell_proto_rawDescGZIP(), []int{235} } func (x *TokenGrantFailureObservation) GetDestinationHost() string { @@ -18064,7 +18237,7 @@ type ReportEndpointStatusResponse struct { func (x *ReportEndpointStatusResponse) Reset() { *x = ReportEndpointStatusResponse{} - mi := &file_openshell_proto_msgTypes[234] + mi := &file_openshell_proto_msgTypes[236] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -18076,7 +18249,7 @@ func (x *ReportEndpointStatusResponse) String() string { func (*ReportEndpointStatusResponse) ProtoMessage() {} func (x *ReportEndpointStatusResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[234] + mi := &file_openshell_proto_msgTypes[236] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -18089,7 +18262,7 @@ func (x *ReportEndpointStatusResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ReportEndpointStatusResponse.ProtoReflect.Descriptor instead. func (*ReportEndpointStatusResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{234} + return file_openshell_proto_rawDescGZIP(), []int{236} } // A configured endpoint and its last accepted network result in one record. @@ -18123,7 +18296,7 @@ type EndpointStatus struct { func (x *EndpointStatus) Reset() { *x = EndpointStatus{} - mi := &file_openshell_proto_msgTypes[235] + mi := &file_openshell_proto_msgTypes[237] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -18135,7 +18308,7 @@ func (x *EndpointStatus) String() string { func (*EndpointStatus) ProtoMessage() {} func (x *EndpointStatus) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[235] + mi := &file_openshell_proto_msgTypes[237] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -18148,7 +18321,7 @@ func (x *EndpointStatus) ProtoReflect() protoreflect.Message { // Deprecated: Use EndpointStatus.ProtoReflect.Descriptor instead. func (*EndpointStatus) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{235} + return file_openshell_proto_rawDescGZIP(), []int{237} } func (x *EndpointStatus) GetEndpointId() string { @@ -18243,7 +18416,7 @@ type SandboxProvisioning struct { func (x *SandboxProvisioning) Reset() { *x = SandboxProvisioning{} - mi := &file_openshell_proto_msgTypes[236] + mi := &file_openshell_proto_msgTypes[238] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -18255,7 +18428,7 @@ func (x *SandboxProvisioning) String() string { func (*SandboxProvisioning) ProtoMessage() {} func (x *SandboxProvisioning) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[236] + mi := &file_openshell_proto_msgTypes[238] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -18268,7 +18441,7 @@ func (x *SandboxProvisioning) ProtoReflect() protoreflect.Message { // Deprecated: Use SandboxProvisioning.ProtoReflect.Descriptor instead. func (*SandboxProvisioning) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{236} + return file_openshell_proto_rawDescGZIP(), []int{238} } func (x *SandboxProvisioning) GetAttemptId() string { @@ -18391,7 +18564,7 @@ type SandboxServiceExposure struct { func (x *SandboxServiceExposure) Reset() { *x = SandboxServiceExposure{} - mi := &file_openshell_proto_msgTypes[237] + mi := &file_openshell_proto_msgTypes[239] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -18403,7 +18576,7 @@ func (x *SandboxServiceExposure) String() string { func (*SandboxServiceExposure) ProtoMessage() {} func (x *SandboxServiceExposure) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[237] + mi := &file_openshell_proto_msgTypes[239] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -18416,7 +18589,7 @@ func (x *SandboxServiceExposure) ProtoReflect() protoreflect.Message { // Deprecated: Use SandboxServiceExposure.ProtoReflect.Descriptor instead. func (*SandboxServiceExposure) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{237} + return file_openshell_proto_rawDescGZIP(), []int{239} } func (x *SandboxServiceExposure) GetService() string { @@ -18470,7 +18643,7 @@ type EndpointFailure struct { func (x *EndpointFailure) Reset() { *x = EndpointFailure{} - mi := &file_openshell_proto_msgTypes[238] + mi := &file_openshell_proto_msgTypes[240] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -18482,7 +18655,7 @@ func (x *EndpointFailure) String() string { func (*EndpointFailure) ProtoMessage() {} func (x *EndpointFailure) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[238] + mi := &file_openshell_proto_msgTypes[240] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -18495,7 +18668,7 @@ func (x *EndpointFailure) ProtoReflect() protoreflect.Message { // Deprecated: Use EndpointFailure.ProtoReflect.Descriptor instead. func (*EndpointFailure) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{238} + return file_openshell_proto_rawDescGZIP(), []int{240} } func (x *EndpointFailure) GetDomain() EndpointFailureDomain { @@ -18695,7 +18868,7 @@ const file_openshell_proto_rawDesc = "" + "\tmax_burst\x18\x02 \x01(\rR\bmaxBurst\"b\n" + "!SandboxWorkloadTemplateProvenance\x12\x12\n" + "\x04name\x18\x01 \x01(\tR\x04name\x12)\n" + - "\x10resource_version\x18\x02 \x01(\tR\x0fresourceVersion\"\xf2\a\n" + + "\x10resource_version\x18\x02 \x01(\tR\x0fresourceVersion\"\xde\b\n" + "\rSandboxStatus\x12\x1b\n" + "\tagent_pod\x18\x02 \x01(\tR\bagentPod\x12\x19\n" + "\bagent_fd\x18\x03 \x01(\tR\aagentFd\x12\x1d\n" + @@ -18716,10 +18889,17 @@ const file_openshell_proto_rawDesc = "" + "\rrestart_count\x18\x0e \x01(\rR\frestartCount\x12F\n" + "\x11next_restart_time\x18\x0f \x01(\v2\x1a.google.protobuf.TimestampR\x0fnextRestartTime\x12U\n" + "\x19main_process_started_time\x18\x10 \x01(\v2\x1a.google.protobuf.TimestampR\x16mainProcessStartedTime\x12c\n" + - "\x18last_token_grant_failure\x18\x11 \x01(\v2*.openshell.v1.TokenGrantFailureObservationR\x15lastTokenGrantFailureB\f\n" + + "\x18last_token_grant_failure\x18\x11 \x01(\v2*.openshell.v1.TokenGrantFailureObservationR\x15lastTokenGrantFailure\x12C\n" + + "\fimage_update\x18\x12 \x01(\v2 .openshell.v1.SandboxImageUpdateR\vimageUpdate\x12%\n" + + "\x0eimage_revision\x18\x13 \x01(\x04R\rimageRevisionB\f\n" + "\n" + "_exit_codeB\x1a\n" + - "\x18_configuration_activated\"\xd1\x01\n" + + "\x18_configuration_activated\"\x90\x01\n" + + "\x12SandboxImageUpdate\x12!\n" + + "\foperation_id\x18\x01 \x01(\tR\voperationId\x12%\n" + + "\x0eprevious_image\x18\x02 \x01(\tR\rpreviousImage\x12\x14\n" + + "\x05image\x18\x03 \x01(\tR\x05image\x12\x1a\n" + + "\brevision\x18\x04 \x01(\x04R\brevision\"\xd1\x01\n" + "\x10SandboxCondition\x12\x12\n" + "\x04type\x18\x01 \x01(\tR\x04type\x12\x16\n" + "\x06status\x18\x02 \x01(\tR\x06status\x12\x16\n" + @@ -18753,7 +18933,14 @@ const file_openshell_proto_rawDesc = "" + "\x05value\x18\x02 \x01(\tR\x05value:\x028\x01\x1a>\n" + "\x10AnnotationsEntry\x12\x10\n" + "\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" + - "\x05value\x18\x02 \x01(\tR\x05value:\x028\x01\"\xd4\x01\n" + + "\x05value\x18\x02 \x01(\tR\x05value:\x028\x01\"\xef\x01\n" + + "\x14UpdateSandboxRequest\x12R\n" + + "\x0fworkspace_scope\x18\x01 \x01(\v2).openshell.datamodel.v1.WorkspaceSelectorR\x0eworkspaceScope\x12\x12\n" + + "\x04name\x18\x02 \x01(\tR\x04name\x12\x14\n" + + "\x05image\x18\x03 \x01(\tR\x05image\x12:\n" + + "\x19expected_resource_version\x18\x04 \x01(\x04R\x17expectedResourceVersion\x12\x1d\n" + + "\n" + + "request_id\x18\x05 \x01(\tR\trequestId\"\xd4\x01\n" + "\x1cCreateSandboxTemplateRequest\x12R\n" + "\x0fworkspace_scope\x18\x02 \x01(\v2).openshell.datamodel.v1.WorkspaceSelectorR\x0eworkspaceScope\x12A\n" + "\btemplate\x18\x01 \x01(\v2%.openshell.v1.SandboxWorkloadTemplateR\btemplate\x12\x1d\n" + @@ -20091,7 +20278,7 @@ const file_openshell_proto_rawDesc = "" + "-SERVICE_AUTHORIZATION_MODE_BEARER_PASSTHROUGH\x10\x02*i\n" + "\x15EndpointFailureDomain\x12'\n" + "#ENDPOINT_FAILURE_DOMAIN_UNSPECIFIED\x10\x00\x12'\n" + - "#ENDPOINT_FAILURE_DOMAIN_TOKEN_GRANT\x10\x012\xb5V\n" + + "#ENDPOINT_FAILURE_DOMAIN_TOKEN_GRANT\x10\x012\xacW\n" + "\tOpenShell\x12Z\n" + "\x06Health\x12\x1b.openshell.v1.HealthRequest\x1a\x1c.openshell.v1.HealthResponse\"\x15\x82\xb5\x18\x11\n" + "\x0funauthenticated\x12i\n" + @@ -20100,6 +20287,8 @@ const file_openshell_proto_rawDesc = "" + "\x0eGetGatewayInfo\x12#.openshell.v1.GetGatewayInfoRequest\x1a$.openshell.v1.GetGatewayInfoResponse\")\x82\xb5\x18%\n" + "\x06bearer\x1a\x0eplatform_admin\"\vconfig:read\x12u\n" + "\rCreateSandbox\x12\".openshell.v1.CreateSandboxRequest\x1a\x1d.openshell.v1.SandboxResponse\"!\x82\xb5\x18\x1d\n" + + "\x06bearer\x12\x04user\"\rsandbox:write\x12u\n" + + "\rUpdateSandbox\x12\".openshell.v1.UpdateSandboxRequest\x1a\x1d.openshell.v1.SandboxResponse\"!\x82\xb5\x18\x1d\n" + "\x06bearer\x12\x04user\"\rsandbox:write\x12\x93\x01\n" + "\x15BeginRootfsTarStaging\x12*.openshell.v1.BeginRootfsTarStagingRequest\x1a+.openshell.v1.BeginRootfsTarStagingResponse\"!\x82\xb5\x18\x1d\n" + "\x06bearer\x12\x04user\"\rsandbox:write\x12n\n" + @@ -20281,7 +20470,7 @@ func file_openshell_proto_rawDescGZIP() []byte { } var file_openshell_proto_enumTypes = make([]protoimpl.EnumInfo, 21) -var file_openshell_proto_msgTypes = make([]protoimpl.MessageInfo, 263) +var file_openshell_proto_msgTypes = make([]protoimpl.MessageInfo, 265) var file_openshell_proto_goTypes = []any{ (ExtensionKind)(0), // 0: openshell.v1.ExtensionKind (SandboxPhase)(0), // 1: openshell.v1.SandboxPhase @@ -20334,264 +20523,266 @@ var file_openshell_proto_goTypes = []any{ (*SandboxStartup)(nil), // 48: openshell.v1.SandboxStartup (*SandboxWorkloadTemplateProvenance)(nil), // 49: openshell.v1.SandboxWorkloadTemplateProvenance (*SandboxStatus)(nil), // 50: openshell.v1.SandboxStatus - (*SandboxCondition)(nil), // 51: openshell.v1.SandboxCondition - (*PlatformEvent)(nil), // 52: openshell.v1.PlatformEvent - (*CreateSandboxRequest)(nil), // 53: openshell.v1.CreateSandboxRequest - (*CreateSandboxTemplateRequest)(nil), // 54: openshell.v1.CreateSandboxTemplateRequest - (*GetSandboxTemplateRequest)(nil), // 55: openshell.v1.GetSandboxTemplateRequest - (*ListSandboxTemplatesRequest)(nil), // 56: openshell.v1.ListSandboxTemplatesRequest - (*DeleteSandboxTemplateRequest)(nil), // 57: openshell.v1.DeleteSandboxTemplateRequest - (*SandboxTemplateResponse)(nil), // 58: openshell.v1.SandboxTemplateResponse - (*ListSandboxTemplatesResponse)(nil), // 59: openshell.v1.ListSandboxTemplatesResponse - (*DeleteSandboxTemplateResponse)(nil), // 60: openshell.v1.DeleteSandboxTemplateResponse - (*BeginRootfsTarStagingRequest)(nil), // 61: openshell.v1.BeginRootfsTarStagingRequest - (*BeginRootfsTarStagingResponse)(nil), // 62: openshell.v1.BeginRootfsTarStagingResponse - (*GetSandboxRequest)(nil), // 63: openshell.v1.GetSandboxRequest - (*ListSandboxesRequest)(nil), // 64: openshell.v1.ListSandboxesRequest - (*ListSandboxProvidersRequest)(nil), // 65: openshell.v1.ListSandboxProvidersRequest - (*AttachSandboxProviderRequest)(nil), // 66: openshell.v1.AttachSandboxProviderRequest - (*DetachSandboxProviderRequest)(nil), // 67: openshell.v1.DetachSandboxProviderRequest - (*DeleteSandboxRequest)(nil), // 68: openshell.v1.DeleteSandboxRequest - (*StopSandboxRequest)(nil), // 69: openshell.v1.StopSandboxRequest - (*StartSandboxRequest)(nil), // 70: openshell.v1.StartSandboxRequest - (*SandboxResponse)(nil), // 71: openshell.v1.SandboxResponse - (*ListSandboxesResponse)(nil), // 72: openshell.v1.ListSandboxesResponse - (*ListSandboxProvidersResponse)(nil), // 73: openshell.v1.ListSandboxProvidersResponse - (*AttachSandboxProviderResponse)(nil), // 74: openshell.v1.AttachSandboxProviderResponse - (*DetachSandboxProviderResponse)(nil), // 75: openshell.v1.DetachSandboxProviderResponse - (*ProviderDesiredIdentity)(nil), // 76: openshell.v1.ProviderDesiredIdentity - (*ConfigSnapshotRevision)(nil), // 77: openshell.v1.ConfigSnapshotRevision - (*SandboxConfigRevision)(nil), // 78: openshell.v1.SandboxConfigRevision - (*ConfigUpdateOperation)(nil), // 79: openshell.v1.ConfigUpdateOperation - (*ProviderMutationReceipt)(nil), // 80: openshell.v1.ProviderMutationReceipt - (*ProviderReadinessObservation)(nil), // 81: openshell.v1.ProviderReadinessObservation - (*ProviderReadinessStatus)(nil), // 82: openshell.v1.ProviderReadinessStatus - (*GetSandboxProviderStatusRequest)(nil), // 83: openshell.v1.GetSandboxProviderStatusRequest - (*GetSandboxProviderStatusResponse)(nil), // 84: openshell.v1.GetSandboxProviderStatusResponse - (*ReportProviderReadinessRequest)(nil), // 85: openshell.v1.ReportProviderReadinessRequest - (*ReportProviderReadinessResponse)(nil), // 86: openshell.v1.ReportProviderReadinessResponse - (*DeleteSandboxResponse)(nil), // 87: openshell.v1.DeleteSandboxResponse - (*CreateSshSessionRequest)(nil), // 88: openshell.v1.CreateSshSessionRequest - (*CreateSshSessionResponse)(nil), // 89: openshell.v1.CreateSshSessionResponse - (*ExposeServiceRequest)(nil), // 90: openshell.v1.ExposeServiceRequest - (*GetServiceRequest)(nil), // 91: openshell.v1.GetServiceRequest - (*ListServicesRequest)(nil), // 92: openshell.v1.ListServicesRequest - (*ListServicesResponse)(nil), // 93: openshell.v1.ListServicesResponse - (*DeleteServiceRequest)(nil), // 94: openshell.v1.DeleteServiceRequest - (*DeleteServiceResponse)(nil), // 95: openshell.v1.DeleteServiceResponse - (*ServiceEndpoint)(nil), // 96: openshell.v1.ServiceEndpoint - (*ServiceEndpointResponse)(nil), // 97: openshell.v1.ServiceEndpointResponse - (*RevokeSshSessionRequest)(nil), // 98: openshell.v1.RevokeSshSessionRequest - (*RevokeSshSessionResponse)(nil), // 99: openshell.v1.RevokeSshSessionResponse - (*ExecSandboxRequest)(nil), // 100: openshell.v1.ExecSandboxRequest - (*ExecSandboxStdout)(nil), // 101: openshell.v1.ExecSandboxStdout - (*ExecSandboxStderr)(nil), // 102: openshell.v1.ExecSandboxStderr - (*ExecSandboxExit)(nil), // 103: openshell.v1.ExecSandboxExit - (*ExecSandboxEvent)(nil), // 104: openshell.v1.ExecSandboxEvent - (*TcpForwardInit)(nil), // 105: openshell.v1.TcpForwardInit - (*TcpForwardFrame)(nil), // 106: openshell.v1.TcpForwardFrame - (*ExecSandboxInput)(nil), // 107: openshell.v1.ExecSandboxInput - (*ExecSandboxWindowResize)(nil), // 108: openshell.v1.ExecSandboxWindowResize - (*SshSession)(nil), // 109: openshell.v1.SshSession - (*WatchSandboxRequest)(nil), // 110: openshell.v1.WatchSandboxRequest - (*SandboxStreamEvent)(nil), // 111: openshell.v1.SandboxStreamEvent - (*SandboxLogLine)(nil), // 112: openshell.v1.SandboxLogLine - (*SandboxStreamWarning)(nil), // 113: openshell.v1.SandboxStreamWarning - (*CreateProviderRequest)(nil), // 114: openshell.v1.CreateProviderRequest - (*GetProviderRequest)(nil), // 115: openshell.v1.GetProviderRequest - (*GetProviderCredentialsRequest)(nil), // 116: openshell.v1.GetProviderCredentialsRequest - (*ProviderCredentialValue)(nil), // 117: openshell.v1.ProviderCredentialValue - (*GetProviderCredentialsResponse)(nil), // 118: openshell.v1.GetProviderCredentialsResponse - (*ListProvidersRequest)(nil), // 119: openshell.v1.ListProvidersRequest - (*UpdateProviderRequest)(nil), // 120: openshell.v1.UpdateProviderRequest - (*DeleteProviderRequest)(nil), // 121: openshell.v1.DeleteProviderRequest - (*ProviderResponse)(nil), // 122: openshell.v1.ProviderResponse - (*ListProvidersResponse)(nil), // 123: openshell.v1.ListProvidersResponse - (*ListProviderProfilesRequest)(nil), // 124: openshell.v1.ListProviderProfilesRequest - (*GetProviderProfileRequest)(nil), // 125: openshell.v1.GetProviderProfileRequest - (*ProviderProfileImportItem)(nil), // 126: openshell.v1.ProviderProfileImportItem - (*ProviderProfileDiagnostic)(nil), // 127: openshell.v1.ProviderProfileDiagnostic - (*ProviderCredentialTokenGrantAudienceOverride)(nil), // 128: openshell.v1.ProviderCredentialTokenGrantAudienceOverride - (*ProviderCredentialTokenGrantSubjectToken)(nil), // 129: openshell.v1.ProviderCredentialTokenGrantSubjectToken - (*ProviderCredentialTokenGrant)(nil), // 130: openshell.v1.ProviderCredentialTokenGrant - (*ProviderProfileCredential)(nil), // 131: openshell.v1.ProviderProfileCredential - (*ProviderCredentialRefreshMaterial)(nil), // 132: openshell.v1.ProviderCredentialRefreshMaterial - (*ProviderCredentialRefreshOutput)(nil), // 133: openshell.v1.ProviderCredentialRefreshOutput - (*ProviderCredentialRefresh)(nil), // 134: openshell.v1.ProviderCredentialRefresh - (*ProviderCredentialRefreshStatus)(nil), // 135: openshell.v1.ProviderCredentialRefreshStatus - (*ProviderProfileDiscovery)(nil), // 136: openshell.v1.ProviderProfileDiscovery - (*GetProviderRefreshStatusRequest)(nil), // 137: openshell.v1.GetProviderRefreshStatusRequest - (*GetProviderRefreshStatusResponse)(nil), // 138: openshell.v1.GetProviderRefreshStatusResponse - (*ConfigureProviderRefreshRequest)(nil), // 139: openshell.v1.ConfigureProviderRefreshRequest - (*ConfigureProviderRefreshResponse)(nil), // 140: openshell.v1.ConfigureProviderRefreshResponse - (*RotateProviderCredentialRequest)(nil), // 141: openshell.v1.RotateProviderCredentialRequest - (*RotateProviderCredentialResponse)(nil), // 142: openshell.v1.RotateProviderCredentialResponse - (*DeleteProviderRefreshRequest)(nil), // 143: openshell.v1.DeleteProviderRefreshRequest - (*DeleteProviderRefreshResponse)(nil), // 144: openshell.v1.DeleteProviderRefreshResponse - (*ProviderProfile)(nil), // 145: openshell.v1.ProviderProfile - (*ProviderProfileFile)(nil), // 146: openshell.v1.ProviderProfileFile - (*ProviderProfileResponse)(nil), // 147: openshell.v1.ProviderProfileResponse - (*ListProviderProfilesResponse)(nil), // 148: openshell.v1.ListProviderProfilesResponse - (*ImportProviderProfilesRequest)(nil), // 149: openshell.v1.ImportProviderProfilesRequest - (*ImportProviderProfilesResponse)(nil), // 150: openshell.v1.ImportProviderProfilesResponse - (*UpdateProviderProfilesRequest)(nil), // 151: openshell.v1.UpdateProviderProfilesRequest - (*UpdateProviderProfilesResponse)(nil), // 152: openshell.v1.UpdateProviderProfilesResponse - (*LintProviderProfilesRequest)(nil), // 153: openshell.v1.LintProviderProfilesRequest - (*LintProviderProfilesResponse)(nil), // 154: openshell.v1.LintProviderProfilesResponse - (*DeleteProviderResponse)(nil), // 155: openshell.v1.DeleteProviderResponse - (*DeleteProviderProfileRequest)(nil), // 156: openshell.v1.DeleteProviderProfileRequest - (*DeleteProviderProfileResponse)(nil), // 157: openshell.v1.DeleteProviderProfileResponse - (*GetSandboxProviderEnvironmentRequest)(nil), // 158: openshell.v1.GetSandboxProviderEnvironmentRequest - (*StaticCredentialEndpointBinding)(nil), // 159: openshell.v1.StaticCredentialEndpointBinding - (*StaticCredentialBinding)(nil), // 160: openshell.v1.StaticCredentialBinding - (*GetSandboxProviderEnvironmentResponse)(nil), // 161: openshell.v1.GetSandboxProviderEnvironmentResponse - (*ExchangeProviderSubjectTokenRequest)(nil), // 162: openshell.v1.ExchangeProviderSubjectTokenRequest - (*ExchangeProviderSubjectTokenResponse)(nil), // 163: openshell.v1.ExchangeProviderSubjectTokenResponse - (*UpdateConfigRequest)(nil), // 164: openshell.v1.UpdateConfigRequest - (*PolicyMergeOperation)(nil), // 165: openshell.v1.PolicyMergeOperation - (*AddNetworkRule)(nil), // 166: openshell.v1.AddNetworkRule - (*RemoveNetworkEndpoint)(nil), // 167: openshell.v1.RemoveNetworkEndpoint - (*RemoveNetworkRule)(nil), // 168: openshell.v1.RemoveNetworkRule - (*L7RuleTarget)(nil), // 169: openshell.v1.L7RuleTarget - (*AddDenyRules)(nil), // 170: openshell.v1.AddDenyRules - (*AddAllowRules)(nil), // 171: openshell.v1.AddAllowRules - (*RemoveNetworkBinary)(nil), // 172: openshell.v1.RemoveNetworkBinary - (*UpdateConfigResponse)(nil), // 173: openshell.v1.UpdateConfigResponse - (*GetSandboxPolicyStatusRequest)(nil), // 174: openshell.v1.GetSandboxPolicyStatusRequest - (*GetSandboxPolicyStatusResponse)(nil), // 175: openshell.v1.GetSandboxPolicyStatusResponse - (*ListSandboxPoliciesRequest)(nil), // 176: openshell.v1.ListSandboxPoliciesRequest - (*ListSandboxPoliciesResponse)(nil), // 177: openshell.v1.ListSandboxPoliciesResponse - (*ReportPolicyStatusRequest)(nil), // 178: openshell.v1.ReportPolicyStatusRequest - (*ReportPolicyStatusResponse)(nil), // 179: openshell.v1.ReportPolicyStatusResponse - (*SandboxConfigurationAdmission)(nil), // 180: openshell.v1.SandboxConfigurationAdmission - (*ReportSandboxConfigurationRequest)(nil), // 181: openshell.v1.ReportSandboxConfigurationRequest - (*ReportSandboxConfigurationResponse)(nil), // 182: openshell.v1.ReportSandboxConfigurationResponse - (*SandboxPolicyRevision)(nil), // 183: openshell.v1.SandboxPolicyRevision - (*GetSandboxLogsRequest)(nil), // 184: openshell.v1.GetSandboxLogsRequest - (*PushSandboxLogsRequest)(nil), // 185: openshell.v1.PushSandboxLogsRequest - (*PushSandboxLogsResponse)(nil), // 186: openshell.v1.PushSandboxLogsResponse - (*GetSandboxLogsResponse)(nil), // 187: openshell.v1.GetSandboxLogsResponse - (*SupervisorMessage)(nil), // 188: openshell.v1.SupervisorMessage - (*GatewayMessage)(nil), // 189: openshell.v1.GatewayMessage - (*SupervisorHello)(nil), // 190: openshell.v1.SupervisorHello - (*SessionAccepted)(nil), // 191: openshell.v1.SessionAccepted - (*SessionRejected)(nil), // 192: openshell.v1.SessionRejected - (*SessionRedirect)(nil), // 193: openshell.v1.SessionRedirect - (*SupervisorHeartbeat)(nil), // 194: openshell.v1.SupervisorHeartbeat - (*GatewayHeartbeat)(nil), // 195: openshell.v1.GatewayHeartbeat - (*ReportMainProcessExitRequest)(nil), // 196: openshell.v1.ReportMainProcessExitRequest - (*ReportMainProcessExitResponse)(nil), // 197: openshell.v1.ReportMainProcessExitResponse - (*FinalizeMainProcessExitRequest)(nil), // 198: openshell.v1.FinalizeMainProcessExitRequest - (*FinalizeMainProcessExitResponse)(nil), // 199: openshell.v1.FinalizeMainProcessExitResponse - (*RelayOpen)(nil), // 200: openshell.v1.RelayOpen - (*SshRelayTarget)(nil), // 201: openshell.v1.SshRelayTarget - (*TcpRelayTarget)(nil), // 202: openshell.v1.TcpRelayTarget - (*RelayInit)(nil), // 203: openshell.v1.RelayInit - (*RelayFrame)(nil), // 204: openshell.v1.RelayFrame - (*PeerRelayInit)(nil), // 205: openshell.v1.PeerRelayInit - (*PeerRelayFrame)(nil), // 206: openshell.v1.PeerRelayFrame - (*RelayOpenResult)(nil), // 207: openshell.v1.RelayOpenResult - (*RelayClose)(nil), // 208: openshell.v1.RelayClose - (*L7RequestSample)(nil), // 209: openshell.v1.L7RequestSample - (*DenialSummary)(nil), // 210: openshell.v1.DenialSummary - (*DenialGroupCount)(nil), // 211: openshell.v1.DenialGroupCount - (*NetworkActivitySummary)(nil), // 212: openshell.v1.NetworkActivitySummary - (*PolicyChunk)(nil), // 213: openshell.v1.PolicyChunk - (*DraftPolicyUpdate)(nil), // 214: openshell.v1.DraftPolicyUpdate - (*SubmitPolicyAnalysisRequest)(nil), // 215: openshell.v1.SubmitPolicyAnalysisRequest - (*SubmitPolicyAnalysisResponse)(nil), // 216: openshell.v1.SubmitPolicyAnalysisResponse - (*GetDraftPolicyRequest)(nil), // 217: openshell.v1.GetDraftPolicyRequest - (*GetDraftPolicyResponse)(nil), // 218: openshell.v1.GetDraftPolicyResponse - (*ApproveDraftChunkRequest)(nil), // 219: openshell.v1.ApproveDraftChunkRequest - (*ApproveDraftChunkResponse)(nil), // 220: openshell.v1.ApproveDraftChunkResponse - (*RejectDraftChunkRequest)(nil), // 221: openshell.v1.RejectDraftChunkRequest - (*RejectDraftChunkResponse)(nil), // 222: openshell.v1.RejectDraftChunkResponse - (*DraftChunkApproval)(nil), // 223: openshell.v1.DraftChunkApproval - (*ApproveAllDraftChunksRequest)(nil), // 224: openshell.v1.ApproveAllDraftChunksRequest - (*ApproveAllDraftChunksResponse)(nil), // 225: openshell.v1.ApproveAllDraftChunksResponse - (*EditDraftChunkRequest)(nil), // 226: openshell.v1.EditDraftChunkRequest - (*EditDraftChunkResponse)(nil), // 227: openshell.v1.EditDraftChunkResponse - (*UndoDraftChunkRequest)(nil), // 228: openshell.v1.UndoDraftChunkRequest - (*UndoDraftChunkResponse)(nil), // 229: openshell.v1.UndoDraftChunkResponse - (*ClearDraftChunksRequest)(nil), // 230: openshell.v1.ClearDraftChunksRequest - (*ClearDraftChunksResponse)(nil), // 231: openshell.v1.ClearDraftChunksResponse - (*GetDraftHistoryRequest)(nil), // 232: openshell.v1.GetDraftHistoryRequest - (*DraftHistoryEntry)(nil), // 233: openshell.v1.DraftHistoryEntry - (*GetDraftHistoryResponse)(nil), // 234: openshell.v1.GetDraftHistoryResponse - (*CreateWorkspaceRequest)(nil), // 235: openshell.v1.CreateWorkspaceRequest - (*CreateWorkspaceResponse)(nil), // 236: openshell.v1.CreateWorkspaceResponse - (*GetWorkspaceRequest)(nil), // 237: openshell.v1.GetWorkspaceRequest - (*GetWorkspaceResponse)(nil), // 238: openshell.v1.GetWorkspaceResponse - (*ListWorkspacesRequest)(nil), // 239: openshell.v1.ListWorkspacesRequest - (*ListWorkspacesResponse)(nil), // 240: openshell.v1.ListWorkspacesResponse - (*DeleteWorkspaceRequest)(nil), // 241: openshell.v1.DeleteWorkspaceRequest - (*DeleteWorkspaceResponse)(nil), // 242: openshell.v1.DeleteWorkspaceResponse - (*WorkspaceMember)(nil), // 243: openshell.v1.WorkspaceMember - (*AddWorkspaceMemberRequest)(nil), // 244: openshell.v1.AddWorkspaceMemberRequest - (*AddWorkspaceMemberResponse)(nil), // 245: openshell.v1.AddWorkspaceMemberResponse - (*RemoveWorkspaceMemberRequest)(nil), // 246: openshell.v1.RemoveWorkspaceMemberRequest - (*RemoveWorkspaceMemberResponse)(nil), // 247: openshell.v1.RemoveWorkspaceMemberResponse - (*ListWorkspaceMembersRequest)(nil), // 248: openshell.v1.ListWorkspaceMembersRequest - (*ListWorkspaceMembersResponse)(nil), // 249: openshell.v1.ListWorkspaceMembersResponse - (*ExtensionServiceCredential)(nil), // 250: openshell.v1.ExtensionServiceCredential - (*EndpointObservation)(nil), // 251: openshell.v1.EndpointObservation - (*ReportEndpointStatusRequest)(nil), // 252: openshell.v1.ReportEndpointStatusRequest - (*TokenGrantStatus)(nil), // 253: openshell.v1.TokenGrantStatus - (*TokenGrantFailureObservation)(nil), // 254: openshell.v1.TokenGrantFailureObservation - (*ReportEndpointStatusResponse)(nil), // 255: openshell.v1.ReportEndpointStatusResponse - (*EndpointStatus)(nil), // 256: openshell.v1.EndpointStatus - (*SandboxProvisioning)(nil), // 257: openshell.v1.SandboxProvisioning - (*SandboxServiceExposure)(nil), // 258: openshell.v1.SandboxServiceExposure - (*EndpointFailure)(nil), // 259: openshell.v1.EndpointFailure - nil, // 260: openshell.v1.SandboxSpec.EnvironmentEntry - nil, // 261: openshell.v1.SandboxTemplate.LabelsEntry - nil, // 262: openshell.v1.SandboxTemplate.AnnotationsEntry - nil, // 263: openshell.v1.SandboxTemplate.EnvironmentEntry - nil, // 264: openshell.v1.SandboxWorkloadConfig.EnvironmentEntry - nil, // 265: openshell.v1.PlatformEvent.MetadataEntry - nil, // 266: openshell.v1.CreateSandboxRequest.LabelsEntry - nil, // 267: openshell.v1.CreateSandboxRequest.AnnotationsEntry - nil, // 268: openshell.v1.SandboxResponse.ServiceUrlsEntry - nil, // 269: openshell.v1.ExecSandboxRequest.EnvironmentEntry - nil, // 270: openshell.v1.SandboxLogLine.FieldsEntry - nil, // 271: openshell.v1.GetProviderCredentialsResponse.CredentialsEntry - nil, // 272: openshell.v1.UpdateProviderRequest.CredentialExpirationTimesEntry - nil, // 273: openshell.v1.ConfigureProviderRefreshRequest.MaterialEntry - nil, // 274: openshell.v1.ProviderProfile.AnnotationsEntry - nil, // 275: openshell.v1.GetSandboxProviderEnvironmentResponse.EnvironmentEntry - nil, // 276: openshell.v1.GetSandboxProviderEnvironmentResponse.CredentialExpirationTimesEntry - nil, // 277: openshell.v1.GetSandboxProviderEnvironmentResponse.DynamicCredentialsEntry - nil, // 278: openshell.v1.GetSandboxProviderEnvironmentResponse.StaticCredentialBindingsEntry - nil, // 279: openshell.v1.GetSandboxProviderEnvironmentResponse.FilesEntry - nil, // 280: openshell.v1.UpdateConfigRequest.AnnotationsEntry - nil, // 281: openshell.v1.UpdateConfigResponse.AnnotationsEntry - nil, // 282: openshell.v1.SandboxPolicyRevision.ProvenanceEntry - nil, // 283: openshell.v1.CreateWorkspaceRequest.LabelsEntry - (*timestamppb.Timestamp)(nil), // 284: google.protobuf.Timestamp - (*datamodelv1.ObjectMeta)(nil), // 285: openshell.datamodel.v1.ObjectMeta - (*sandboxv1.SandboxPolicy)(nil), // 286: openshell.sandbox.v1.SandboxPolicy - (*structpb.Struct)(nil), // 287: google.protobuf.Struct - (*durationpb.Duration)(nil), // 288: google.protobuf.Duration - (*datamodelv1.WorkspaceSelector)(nil), // 289: openshell.datamodel.v1.WorkspaceSelector - (*datamodelv1.Provider)(nil), // 290: openshell.datamodel.v1.Provider - (sandboxv1.PolicySource)(0), // 291: openshell.sandbox.v1.PolicySource - (*sandboxv1.NetworkEndpoint)(nil), // 292: openshell.sandbox.v1.NetworkEndpoint - (*sandboxv1.NetworkBinary)(nil), // 293: openshell.sandbox.v1.NetworkBinary - (*sandboxv1.SettingValue)(nil), // 294: openshell.sandbox.v1.SettingValue - (*sandboxv1.NetworkPolicyRule)(nil), // 295: openshell.sandbox.v1.NetworkPolicyRule - (*sandboxv1.L7DenyRule)(nil), // 296: openshell.sandbox.v1.L7DenyRule - (*sandboxv1.L7Rule)(nil), // 297: openshell.sandbox.v1.L7Rule - (*datamodelv1.Workspace)(nil), // 298: openshell.datamodel.v1.Workspace - (*sandboxv1.GetSandboxConfigRequest)(nil), // 299: openshell.sandbox.v1.GetSandboxConfigRequest - (*sandboxv1.GetGatewayConfigRequest)(nil), // 300: openshell.sandbox.v1.GetGatewayConfigRequest - (*sandboxv1.GetSandboxConfigResponse)(nil), // 301: openshell.sandbox.v1.GetSandboxConfigResponse - (*sandboxv1.GetGatewayConfigResponse)(nil), // 302: openshell.sandbox.v1.GetGatewayConfigResponse + (*SandboxImageUpdate)(nil), // 51: openshell.v1.SandboxImageUpdate + (*SandboxCondition)(nil), // 52: openshell.v1.SandboxCondition + (*PlatformEvent)(nil), // 53: openshell.v1.PlatformEvent + (*CreateSandboxRequest)(nil), // 54: openshell.v1.CreateSandboxRequest + (*UpdateSandboxRequest)(nil), // 55: openshell.v1.UpdateSandboxRequest + (*CreateSandboxTemplateRequest)(nil), // 56: openshell.v1.CreateSandboxTemplateRequest + (*GetSandboxTemplateRequest)(nil), // 57: openshell.v1.GetSandboxTemplateRequest + (*ListSandboxTemplatesRequest)(nil), // 58: openshell.v1.ListSandboxTemplatesRequest + (*DeleteSandboxTemplateRequest)(nil), // 59: openshell.v1.DeleteSandboxTemplateRequest + (*SandboxTemplateResponse)(nil), // 60: openshell.v1.SandboxTemplateResponse + (*ListSandboxTemplatesResponse)(nil), // 61: openshell.v1.ListSandboxTemplatesResponse + (*DeleteSandboxTemplateResponse)(nil), // 62: openshell.v1.DeleteSandboxTemplateResponse + (*BeginRootfsTarStagingRequest)(nil), // 63: openshell.v1.BeginRootfsTarStagingRequest + (*BeginRootfsTarStagingResponse)(nil), // 64: openshell.v1.BeginRootfsTarStagingResponse + (*GetSandboxRequest)(nil), // 65: openshell.v1.GetSandboxRequest + (*ListSandboxesRequest)(nil), // 66: openshell.v1.ListSandboxesRequest + (*ListSandboxProvidersRequest)(nil), // 67: openshell.v1.ListSandboxProvidersRequest + (*AttachSandboxProviderRequest)(nil), // 68: openshell.v1.AttachSandboxProviderRequest + (*DetachSandboxProviderRequest)(nil), // 69: openshell.v1.DetachSandboxProviderRequest + (*DeleteSandboxRequest)(nil), // 70: openshell.v1.DeleteSandboxRequest + (*StopSandboxRequest)(nil), // 71: openshell.v1.StopSandboxRequest + (*StartSandboxRequest)(nil), // 72: openshell.v1.StartSandboxRequest + (*SandboxResponse)(nil), // 73: openshell.v1.SandboxResponse + (*ListSandboxesResponse)(nil), // 74: openshell.v1.ListSandboxesResponse + (*ListSandboxProvidersResponse)(nil), // 75: openshell.v1.ListSandboxProvidersResponse + (*AttachSandboxProviderResponse)(nil), // 76: openshell.v1.AttachSandboxProviderResponse + (*DetachSandboxProviderResponse)(nil), // 77: openshell.v1.DetachSandboxProviderResponse + (*ProviderDesiredIdentity)(nil), // 78: openshell.v1.ProviderDesiredIdentity + (*ConfigSnapshotRevision)(nil), // 79: openshell.v1.ConfigSnapshotRevision + (*SandboxConfigRevision)(nil), // 80: openshell.v1.SandboxConfigRevision + (*ConfigUpdateOperation)(nil), // 81: openshell.v1.ConfigUpdateOperation + (*ProviderMutationReceipt)(nil), // 82: openshell.v1.ProviderMutationReceipt + (*ProviderReadinessObservation)(nil), // 83: openshell.v1.ProviderReadinessObservation + (*ProviderReadinessStatus)(nil), // 84: openshell.v1.ProviderReadinessStatus + (*GetSandboxProviderStatusRequest)(nil), // 85: openshell.v1.GetSandboxProviderStatusRequest + (*GetSandboxProviderStatusResponse)(nil), // 86: openshell.v1.GetSandboxProviderStatusResponse + (*ReportProviderReadinessRequest)(nil), // 87: openshell.v1.ReportProviderReadinessRequest + (*ReportProviderReadinessResponse)(nil), // 88: openshell.v1.ReportProviderReadinessResponse + (*DeleteSandboxResponse)(nil), // 89: openshell.v1.DeleteSandboxResponse + (*CreateSshSessionRequest)(nil), // 90: openshell.v1.CreateSshSessionRequest + (*CreateSshSessionResponse)(nil), // 91: openshell.v1.CreateSshSessionResponse + (*ExposeServiceRequest)(nil), // 92: openshell.v1.ExposeServiceRequest + (*GetServiceRequest)(nil), // 93: openshell.v1.GetServiceRequest + (*ListServicesRequest)(nil), // 94: openshell.v1.ListServicesRequest + (*ListServicesResponse)(nil), // 95: openshell.v1.ListServicesResponse + (*DeleteServiceRequest)(nil), // 96: openshell.v1.DeleteServiceRequest + (*DeleteServiceResponse)(nil), // 97: openshell.v1.DeleteServiceResponse + (*ServiceEndpoint)(nil), // 98: openshell.v1.ServiceEndpoint + (*ServiceEndpointResponse)(nil), // 99: openshell.v1.ServiceEndpointResponse + (*RevokeSshSessionRequest)(nil), // 100: openshell.v1.RevokeSshSessionRequest + (*RevokeSshSessionResponse)(nil), // 101: openshell.v1.RevokeSshSessionResponse + (*ExecSandboxRequest)(nil), // 102: openshell.v1.ExecSandboxRequest + (*ExecSandboxStdout)(nil), // 103: openshell.v1.ExecSandboxStdout + (*ExecSandboxStderr)(nil), // 104: openshell.v1.ExecSandboxStderr + (*ExecSandboxExit)(nil), // 105: openshell.v1.ExecSandboxExit + (*ExecSandboxEvent)(nil), // 106: openshell.v1.ExecSandboxEvent + (*TcpForwardInit)(nil), // 107: openshell.v1.TcpForwardInit + (*TcpForwardFrame)(nil), // 108: openshell.v1.TcpForwardFrame + (*ExecSandboxInput)(nil), // 109: openshell.v1.ExecSandboxInput + (*ExecSandboxWindowResize)(nil), // 110: openshell.v1.ExecSandboxWindowResize + (*SshSession)(nil), // 111: openshell.v1.SshSession + (*WatchSandboxRequest)(nil), // 112: openshell.v1.WatchSandboxRequest + (*SandboxStreamEvent)(nil), // 113: openshell.v1.SandboxStreamEvent + (*SandboxLogLine)(nil), // 114: openshell.v1.SandboxLogLine + (*SandboxStreamWarning)(nil), // 115: openshell.v1.SandboxStreamWarning + (*CreateProviderRequest)(nil), // 116: openshell.v1.CreateProviderRequest + (*GetProviderRequest)(nil), // 117: openshell.v1.GetProviderRequest + (*GetProviderCredentialsRequest)(nil), // 118: openshell.v1.GetProviderCredentialsRequest + (*ProviderCredentialValue)(nil), // 119: openshell.v1.ProviderCredentialValue + (*GetProviderCredentialsResponse)(nil), // 120: openshell.v1.GetProviderCredentialsResponse + (*ListProvidersRequest)(nil), // 121: openshell.v1.ListProvidersRequest + (*UpdateProviderRequest)(nil), // 122: openshell.v1.UpdateProviderRequest + (*DeleteProviderRequest)(nil), // 123: openshell.v1.DeleteProviderRequest + (*ProviderResponse)(nil), // 124: openshell.v1.ProviderResponse + (*ListProvidersResponse)(nil), // 125: openshell.v1.ListProvidersResponse + (*ListProviderProfilesRequest)(nil), // 126: openshell.v1.ListProviderProfilesRequest + (*GetProviderProfileRequest)(nil), // 127: openshell.v1.GetProviderProfileRequest + (*ProviderProfileImportItem)(nil), // 128: openshell.v1.ProviderProfileImportItem + (*ProviderProfileDiagnostic)(nil), // 129: openshell.v1.ProviderProfileDiagnostic + (*ProviderCredentialTokenGrantAudienceOverride)(nil), // 130: openshell.v1.ProviderCredentialTokenGrantAudienceOverride + (*ProviderCredentialTokenGrantSubjectToken)(nil), // 131: openshell.v1.ProviderCredentialTokenGrantSubjectToken + (*ProviderCredentialTokenGrant)(nil), // 132: openshell.v1.ProviderCredentialTokenGrant + (*ProviderProfileCredential)(nil), // 133: openshell.v1.ProviderProfileCredential + (*ProviderCredentialRefreshMaterial)(nil), // 134: openshell.v1.ProviderCredentialRefreshMaterial + (*ProviderCredentialRefreshOutput)(nil), // 135: openshell.v1.ProviderCredentialRefreshOutput + (*ProviderCredentialRefresh)(nil), // 136: openshell.v1.ProviderCredentialRefresh + (*ProviderCredentialRefreshStatus)(nil), // 137: openshell.v1.ProviderCredentialRefreshStatus + (*ProviderProfileDiscovery)(nil), // 138: openshell.v1.ProviderProfileDiscovery + (*GetProviderRefreshStatusRequest)(nil), // 139: openshell.v1.GetProviderRefreshStatusRequest + (*GetProviderRefreshStatusResponse)(nil), // 140: openshell.v1.GetProviderRefreshStatusResponse + (*ConfigureProviderRefreshRequest)(nil), // 141: openshell.v1.ConfigureProviderRefreshRequest + (*ConfigureProviderRefreshResponse)(nil), // 142: openshell.v1.ConfigureProviderRefreshResponse + (*RotateProviderCredentialRequest)(nil), // 143: openshell.v1.RotateProviderCredentialRequest + (*RotateProviderCredentialResponse)(nil), // 144: openshell.v1.RotateProviderCredentialResponse + (*DeleteProviderRefreshRequest)(nil), // 145: openshell.v1.DeleteProviderRefreshRequest + (*DeleteProviderRefreshResponse)(nil), // 146: openshell.v1.DeleteProviderRefreshResponse + (*ProviderProfile)(nil), // 147: openshell.v1.ProviderProfile + (*ProviderProfileFile)(nil), // 148: openshell.v1.ProviderProfileFile + (*ProviderProfileResponse)(nil), // 149: openshell.v1.ProviderProfileResponse + (*ListProviderProfilesResponse)(nil), // 150: openshell.v1.ListProviderProfilesResponse + (*ImportProviderProfilesRequest)(nil), // 151: openshell.v1.ImportProviderProfilesRequest + (*ImportProviderProfilesResponse)(nil), // 152: openshell.v1.ImportProviderProfilesResponse + (*UpdateProviderProfilesRequest)(nil), // 153: openshell.v1.UpdateProviderProfilesRequest + (*UpdateProviderProfilesResponse)(nil), // 154: openshell.v1.UpdateProviderProfilesResponse + (*LintProviderProfilesRequest)(nil), // 155: openshell.v1.LintProviderProfilesRequest + (*LintProviderProfilesResponse)(nil), // 156: openshell.v1.LintProviderProfilesResponse + (*DeleteProviderResponse)(nil), // 157: openshell.v1.DeleteProviderResponse + (*DeleteProviderProfileRequest)(nil), // 158: openshell.v1.DeleteProviderProfileRequest + (*DeleteProviderProfileResponse)(nil), // 159: openshell.v1.DeleteProviderProfileResponse + (*GetSandboxProviderEnvironmentRequest)(nil), // 160: openshell.v1.GetSandboxProviderEnvironmentRequest + (*StaticCredentialEndpointBinding)(nil), // 161: openshell.v1.StaticCredentialEndpointBinding + (*StaticCredentialBinding)(nil), // 162: openshell.v1.StaticCredentialBinding + (*GetSandboxProviderEnvironmentResponse)(nil), // 163: openshell.v1.GetSandboxProviderEnvironmentResponse + (*ExchangeProviderSubjectTokenRequest)(nil), // 164: openshell.v1.ExchangeProviderSubjectTokenRequest + (*ExchangeProviderSubjectTokenResponse)(nil), // 165: openshell.v1.ExchangeProviderSubjectTokenResponse + (*UpdateConfigRequest)(nil), // 166: openshell.v1.UpdateConfigRequest + (*PolicyMergeOperation)(nil), // 167: openshell.v1.PolicyMergeOperation + (*AddNetworkRule)(nil), // 168: openshell.v1.AddNetworkRule + (*RemoveNetworkEndpoint)(nil), // 169: openshell.v1.RemoveNetworkEndpoint + (*RemoveNetworkRule)(nil), // 170: openshell.v1.RemoveNetworkRule + (*L7RuleTarget)(nil), // 171: openshell.v1.L7RuleTarget + (*AddDenyRules)(nil), // 172: openshell.v1.AddDenyRules + (*AddAllowRules)(nil), // 173: openshell.v1.AddAllowRules + (*RemoveNetworkBinary)(nil), // 174: openshell.v1.RemoveNetworkBinary + (*UpdateConfigResponse)(nil), // 175: openshell.v1.UpdateConfigResponse + (*GetSandboxPolicyStatusRequest)(nil), // 176: openshell.v1.GetSandboxPolicyStatusRequest + (*GetSandboxPolicyStatusResponse)(nil), // 177: openshell.v1.GetSandboxPolicyStatusResponse + (*ListSandboxPoliciesRequest)(nil), // 178: openshell.v1.ListSandboxPoliciesRequest + (*ListSandboxPoliciesResponse)(nil), // 179: openshell.v1.ListSandboxPoliciesResponse + (*ReportPolicyStatusRequest)(nil), // 180: openshell.v1.ReportPolicyStatusRequest + (*ReportPolicyStatusResponse)(nil), // 181: openshell.v1.ReportPolicyStatusResponse + (*SandboxConfigurationAdmission)(nil), // 182: openshell.v1.SandboxConfigurationAdmission + (*ReportSandboxConfigurationRequest)(nil), // 183: openshell.v1.ReportSandboxConfigurationRequest + (*ReportSandboxConfigurationResponse)(nil), // 184: openshell.v1.ReportSandboxConfigurationResponse + (*SandboxPolicyRevision)(nil), // 185: openshell.v1.SandboxPolicyRevision + (*GetSandboxLogsRequest)(nil), // 186: openshell.v1.GetSandboxLogsRequest + (*PushSandboxLogsRequest)(nil), // 187: openshell.v1.PushSandboxLogsRequest + (*PushSandboxLogsResponse)(nil), // 188: openshell.v1.PushSandboxLogsResponse + (*GetSandboxLogsResponse)(nil), // 189: openshell.v1.GetSandboxLogsResponse + (*SupervisorMessage)(nil), // 190: openshell.v1.SupervisorMessage + (*GatewayMessage)(nil), // 191: openshell.v1.GatewayMessage + (*SupervisorHello)(nil), // 192: openshell.v1.SupervisorHello + (*SessionAccepted)(nil), // 193: openshell.v1.SessionAccepted + (*SessionRejected)(nil), // 194: openshell.v1.SessionRejected + (*SessionRedirect)(nil), // 195: openshell.v1.SessionRedirect + (*SupervisorHeartbeat)(nil), // 196: openshell.v1.SupervisorHeartbeat + (*GatewayHeartbeat)(nil), // 197: openshell.v1.GatewayHeartbeat + (*ReportMainProcessExitRequest)(nil), // 198: openshell.v1.ReportMainProcessExitRequest + (*ReportMainProcessExitResponse)(nil), // 199: openshell.v1.ReportMainProcessExitResponse + (*FinalizeMainProcessExitRequest)(nil), // 200: openshell.v1.FinalizeMainProcessExitRequest + (*FinalizeMainProcessExitResponse)(nil), // 201: openshell.v1.FinalizeMainProcessExitResponse + (*RelayOpen)(nil), // 202: openshell.v1.RelayOpen + (*SshRelayTarget)(nil), // 203: openshell.v1.SshRelayTarget + (*TcpRelayTarget)(nil), // 204: openshell.v1.TcpRelayTarget + (*RelayInit)(nil), // 205: openshell.v1.RelayInit + (*RelayFrame)(nil), // 206: openshell.v1.RelayFrame + (*PeerRelayInit)(nil), // 207: openshell.v1.PeerRelayInit + (*PeerRelayFrame)(nil), // 208: openshell.v1.PeerRelayFrame + (*RelayOpenResult)(nil), // 209: openshell.v1.RelayOpenResult + (*RelayClose)(nil), // 210: openshell.v1.RelayClose + (*L7RequestSample)(nil), // 211: openshell.v1.L7RequestSample + (*DenialSummary)(nil), // 212: openshell.v1.DenialSummary + (*DenialGroupCount)(nil), // 213: openshell.v1.DenialGroupCount + (*NetworkActivitySummary)(nil), // 214: openshell.v1.NetworkActivitySummary + (*PolicyChunk)(nil), // 215: openshell.v1.PolicyChunk + (*DraftPolicyUpdate)(nil), // 216: openshell.v1.DraftPolicyUpdate + (*SubmitPolicyAnalysisRequest)(nil), // 217: openshell.v1.SubmitPolicyAnalysisRequest + (*SubmitPolicyAnalysisResponse)(nil), // 218: openshell.v1.SubmitPolicyAnalysisResponse + (*GetDraftPolicyRequest)(nil), // 219: openshell.v1.GetDraftPolicyRequest + (*GetDraftPolicyResponse)(nil), // 220: openshell.v1.GetDraftPolicyResponse + (*ApproveDraftChunkRequest)(nil), // 221: openshell.v1.ApproveDraftChunkRequest + (*ApproveDraftChunkResponse)(nil), // 222: openshell.v1.ApproveDraftChunkResponse + (*RejectDraftChunkRequest)(nil), // 223: openshell.v1.RejectDraftChunkRequest + (*RejectDraftChunkResponse)(nil), // 224: openshell.v1.RejectDraftChunkResponse + (*DraftChunkApproval)(nil), // 225: openshell.v1.DraftChunkApproval + (*ApproveAllDraftChunksRequest)(nil), // 226: openshell.v1.ApproveAllDraftChunksRequest + (*ApproveAllDraftChunksResponse)(nil), // 227: openshell.v1.ApproveAllDraftChunksResponse + (*EditDraftChunkRequest)(nil), // 228: openshell.v1.EditDraftChunkRequest + (*EditDraftChunkResponse)(nil), // 229: openshell.v1.EditDraftChunkResponse + (*UndoDraftChunkRequest)(nil), // 230: openshell.v1.UndoDraftChunkRequest + (*UndoDraftChunkResponse)(nil), // 231: openshell.v1.UndoDraftChunkResponse + (*ClearDraftChunksRequest)(nil), // 232: openshell.v1.ClearDraftChunksRequest + (*ClearDraftChunksResponse)(nil), // 233: openshell.v1.ClearDraftChunksResponse + (*GetDraftHistoryRequest)(nil), // 234: openshell.v1.GetDraftHistoryRequest + (*DraftHistoryEntry)(nil), // 235: openshell.v1.DraftHistoryEntry + (*GetDraftHistoryResponse)(nil), // 236: openshell.v1.GetDraftHistoryResponse + (*CreateWorkspaceRequest)(nil), // 237: openshell.v1.CreateWorkspaceRequest + (*CreateWorkspaceResponse)(nil), // 238: openshell.v1.CreateWorkspaceResponse + (*GetWorkspaceRequest)(nil), // 239: openshell.v1.GetWorkspaceRequest + (*GetWorkspaceResponse)(nil), // 240: openshell.v1.GetWorkspaceResponse + (*ListWorkspacesRequest)(nil), // 241: openshell.v1.ListWorkspacesRequest + (*ListWorkspacesResponse)(nil), // 242: openshell.v1.ListWorkspacesResponse + (*DeleteWorkspaceRequest)(nil), // 243: openshell.v1.DeleteWorkspaceRequest + (*DeleteWorkspaceResponse)(nil), // 244: openshell.v1.DeleteWorkspaceResponse + (*WorkspaceMember)(nil), // 245: openshell.v1.WorkspaceMember + (*AddWorkspaceMemberRequest)(nil), // 246: openshell.v1.AddWorkspaceMemberRequest + (*AddWorkspaceMemberResponse)(nil), // 247: openshell.v1.AddWorkspaceMemberResponse + (*RemoveWorkspaceMemberRequest)(nil), // 248: openshell.v1.RemoveWorkspaceMemberRequest + (*RemoveWorkspaceMemberResponse)(nil), // 249: openshell.v1.RemoveWorkspaceMemberResponse + (*ListWorkspaceMembersRequest)(nil), // 250: openshell.v1.ListWorkspaceMembersRequest + (*ListWorkspaceMembersResponse)(nil), // 251: openshell.v1.ListWorkspaceMembersResponse + (*ExtensionServiceCredential)(nil), // 252: openshell.v1.ExtensionServiceCredential + (*EndpointObservation)(nil), // 253: openshell.v1.EndpointObservation + (*ReportEndpointStatusRequest)(nil), // 254: openshell.v1.ReportEndpointStatusRequest + (*TokenGrantStatus)(nil), // 255: openshell.v1.TokenGrantStatus + (*TokenGrantFailureObservation)(nil), // 256: openshell.v1.TokenGrantFailureObservation + (*ReportEndpointStatusResponse)(nil), // 257: openshell.v1.ReportEndpointStatusResponse + (*EndpointStatus)(nil), // 258: openshell.v1.EndpointStatus + (*SandboxProvisioning)(nil), // 259: openshell.v1.SandboxProvisioning + (*SandboxServiceExposure)(nil), // 260: openshell.v1.SandboxServiceExposure + (*EndpointFailure)(nil), // 261: openshell.v1.EndpointFailure + nil, // 262: openshell.v1.SandboxSpec.EnvironmentEntry + nil, // 263: openshell.v1.SandboxTemplate.LabelsEntry + nil, // 264: openshell.v1.SandboxTemplate.AnnotationsEntry + nil, // 265: openshell.v1.SandboxTemplate.EnvironmentEntry + nil, // 266: openshell.v1.SandboxWorkloadConfig.EnvironmentEntry + nil, // 267: openshell.v1.PlatformEvent.MetadataEntry + nil, // 268: openshell.v1.CreateSandboxRequest.LabelsEntry + nil, // 269: openshell.v1.CreateSandboxRequest.AnnotationsEntry + nil, // 270: openshell.v1.SandboxResponse.ServiceUrlsEntry + nil, // 271: openshell.v1.ExecSandboxRequest.EnvironmentEntry + nil, // 272: openshell.v1.SandboxLogLine.FieldsEntry + nil, // 273: openshell.v1.GetProviderCredentialsResponse.CredentialsEntry + nil, // 274: openshell.v1.UpdateProviderRequest.CredentialExpirationTimesEntry + nil, // 275: openshell.v1.ConfigureProviderRefreshRequest.MaterialEntry + nil, // 276: openshell.v1.ProviderProfile.AnnotationsEntry + nil, // 277: openshell.v1.GetSandboxProviderEnvironmentResponse.EnvironmentEntry + nil, // 278: openshell.v1.GetSandboxProviderEnvironmentResponse.CredentialExpirationTimesEntry + nil, // 279: openshell.v1.GetSandboxProviderEnvironmentResponse.DynamicCredentialsEntry + nil, // 280: openshell.v1.GetSandboxProviderEnvironmentResponse.StaticCredentialBindingsEntry + nil, // 281: openshell.v1.GetSandboxProviderEnvironmentResponse.FilesEntry + nil, // 282: openshell.v1.UpdateConfigRequest.AnnotationsEntry + nil, // 283: openshell.v1.UpdateConfigResponse.AnnotationsEntry + nil, // 284: openshell.v1.SandboxPolicyRevision.ProvenanceEntry + nil, // 285: openshell.v1.CreateWorkspaceRequest.LabelsEntry + (*timestamppb.Timestamp)(nil), // 286: google.protobuf.Timestamp + (*datamodelv1.ObjectMeta)(nil), // 287: openshell.datamodel.v1.ObjectMeta + (*sandboxv1.SandboxPolicy)(nil), // 288: openshell.sandbox.v1.SandboxPolicy + (*structpb.Struct)(nil), // 289: google.protobuf.Struct + (*durationpb.Duration)(nil), // 290: google.protobuf.Duration + (*datamodelv1.WorkspaceSelector)(nil), // 291: openshell.datamodel.v1.WorkspaceSelector + (*datamodelv1.Provider)(nil), // 292: openshell.datamodel.v1.Provider + (sandboxv1.PolicySource)(0), // 293: openshell.sandbox.v1.PolicySource + (*sandboxv1.NetworkEndpoint)(nil), // 294: openshell.sandbox.v1.NetworkEndpoint + (*sandboxv1.NetworkBinary)(nil), // 295: openshell.sandbox.v1.NetworkBinary + (*sandboxv1.SettingValue)(nil), // 296: openshell.sandbox.v1.SettingValue + (*sandboxv1.NetworkPolicyRule)(nil), // 297: openshell.sandbox.v1.NetworkPolicyRule + (*sandboxv1.L7DenyRule)(nil), // 298: openshell.sandbox.v1.L7DenyRule + (*sandboxv1.L7Rule)(nil), // 299: openshell.sandbox.v1.L7Rule + (*datamodelv1.Workspace)(nil), // 300: openshell.datamodel.v1.Workspace + (*sandboxv1.GetSandboxConfigRequest)(nil), // 301: openshell.sandbox.v1.GetSandboxConfigRequest + (*sandboxv1.GetGatewayConfigRequest)(nil), // 302: openshell.sandbox.v1.GetGatewayConfigRequest + (*sandboxv1.GetSandboxConfigResponse)(nil), // 303: openshell.sandbox.v1.GetSandboxConfigResponse + (*sandboxv1.GetGatewayConfigResponse)(nil), // 304: openshell.sandbox.v1.GetGatewayConfigResponse } var file_openshell_proto_depIdxs = []int32{ - 284, // 0: openshell.v1.IssueSandboxTokenResponse.expiration_time:type_name -> google.protobuf.Timestamp - 284, // 1: openshell.v1.RefreshSandboxTokenResponse.expiration_time:type_name -> google.protobuf.Timestamp - 250, // 2: openshell.v1.RefreshSandboxTokenResponse.extension_credentials:type_name -> openshell.v1.ExtensionServiceCredential - 284, // 3: openshell.v1.RefreshSandboxTokenResponse.sandbox_expiration_time:type_name -> google.protobuf.Timestamp + 286, // 0: openshell.v1.IssueSandboxTokenResponse.expiration_time:type_name -> google.protobuf.Timestamp + 286, // 1: openshell.v1.RefreshSandboxTokenResponse.expiration_time:type_name -> google.protobuf.Timestamp + 252, // 2: openshell.v1.RefreshSandboxTokenResponse.extension_credentials:type_name -> openshell.v1.ExtensionServiceCredential + 286, // 3: openshell.v1.RefreshSandboxTokenResponse.sandbox_expiration_time:type_name -> google.protobuf.Timestamp 13, // 4: openshell.v1.HealthResponse.status:type_name -> openshell.v1.ServiceStatus 13, // 5: openshell.v1.GetGatewayInfoResponse.status:type_name -> openshell.v1.ServiceStatus 32, // 6: openshell.v1.GetGatewayInfoResponse.compute_drivers:type_name -> openshell.v1.ComputeDriverInfo @@ -20602,503 +20793,507 @@ var file_openshell_proto_depIdxs = []int32{ 35, // 11: openshell.v1.ResourceCapabilities.cpu:type_name -> openshell.v1.CpuResourceCapabilities 36, // 12: openshell.v1.ResourceCapabilities.memory:type_name -> openshell.v1.MemoryResourceCapabilities 37, // 13: openshell.v1.ResourceCapabilities.gpu:type_name -> openshell.v1.GpuResourceCapabilities - 285, // 14: openshell.v1.Sandbox.metadata:type_name -> openshell.datamodel.v1.ObjectMeta + 287, // 14: openshell.v1.Sandbox.metadata:type_name -> openshell.datamodel.v1.ObjectMeta 39, // 15: openshell.v1.Sandbox.spec:type_name -> openshell.v1.SandboxSpec 50, // 16: openshell.v1.Sandbox.status:type_name -> openshell.v1.SandboxStatus 49, // 17: openshell.v1.Sandbox.created_from_workload_template:type_name -> openshell.v1.SandboxWorkloadTemplateProvenance - 260, // 18: openshell.v1.SandboxSpec.environment:type_name -> openshell.v1.SandboxSpec.EnvironmentEntry + 262, // 18: openshell.v1.SandboxSpec.environment:type_name -> openshell.v1.SandboxSpec.EnvironmentEntry 42, // 19: openshell.v1.SandboxSpec.template:type_name -> openshell.v1.SandboxTemplate - 286, // 20: openshell.v1.SandboxSpec.policy:type_name -> openshell.sandbox.v1.SandboxPolicy + 288, // 20: openshell.v1.SandboxSpec.policy:type_name -> openshell.sandbox.v1.SandboxPolicy 40, // 21: openshell.v1.SandboxSpec.resource_requirements:type_name -> openshell.v1.ResourceRequirements 16, // 22: openshell.v1.SandboxSpec.restart_policy:type_name -> openshell.v1.SandboxRestartPolicy 41, // 23: openshell.v1.ResourceRequirements.gpu:type_name -> openshell.v1.GpuResourceRequirements - 261, // 24: openshell.v1.SandboxTemplate.labels:type_name -> openshell.v1.SandboxTemplate.LabelsEntry - 262, // 25: openshell.v1.SandboxTemplate.annotations:type_name -> openshell.v1.SandboxTemplate.AnnotationsEntry - 263, // 26: openshell.v1.SandboxTemplate.environment:type_name -> openshell.v1.SandboxTemplate.EnvironmentEntry - 287, // 27: openshell.v1.SandboxTemplate.resources:type_name -> google.protobuf.Struct - 287, // 28: openshell.v1.SandboxTemplate.driver_config:type_name -> google.protobuf.Struct - 285, // 29: openshell.v1.SandboxWorkloadTemplate.metadata:type_name -> openshell.datamodel.v1.ObjectMeta + 263, // 24: openshell.v1.SandboxTemplate.labels:type_name -> openshell.v1.SandboxTemplate.LabelsEntry + 264, // 25: openshell.v1.SandboxTemplate.annotations:type_name -> openshell.v1.SandboxTemplate.AnnotationsEntry + 265, // 26: openshell.v1.SandboxTemplate.environment:type_name -> openshell.v1.SandboxTemplate.EnvironmentEntry + 289, // 27: openshell.v1.SandboxTemplate.resources:type_name -> google.protobuf.Struct + 289, // 28: openshell.v1.SandboxTemplate.driver_config:type_name -> google.protobuf.Struct + 287, // 29: openshell.v1.SandboxWorkloadTemplate.metadata:type_name -> openshell.datamodel.v1.ObjectMeta 44, // 30: openshell.v1.SandboxWorkloadTemplate.spec:type_name -> openshell.v1.SandboxWorkloadTemplateSpec 45, // 31: openshell.v1.SandboxWorkloadTemplateSpec.workload:type_name -> openshell.v1.SandboxWorkloadConfig - 287, // 32: openshell.v1.SandboxWorkloadTemplateSpec.driver_config:type_name -> google.protobuf.Struct + 289, // 32: openshell.v1.SandboxWorkloadTemplateSpec.driver_config:type_name -> google.protobuf.Struct 47, // 33: openshell.v1.SandboxWorkloadTemplateSpec.desired_service_level:type_name -> openshell.v1.SandboxServiceLevel - 264, // 34: openshell.v1.SandboxWorkloadConfig.environment:type_name -> openshell.v1.SandboxWorkloadConfig.EnvironmentEntry + 266, // 34: openshell.v1.SandboxWorkloadConfig.environment:type_name -> openshell.v1.SandboxWorkloadConfig.EnvironmentEntry 46, // 35: openshell.v1.SandboxWorkloadConfig.resources:type_name -> openshell.v1.SandboxResources 41, // 36: openshell.v1.SandboxResources.gpu:type_name -> openshell.v1.GpuResourceRequirements 48, // 37: openshell.v1.SandboxServiceLevel.startup:type_name -> openshell.v1.SandboxStartup - 288, // 38: openshell.v1.SandboxStartup.ready_within:type_name -> google.protobuf.Duration - 51, // 39: openshell.v1.SandboxStatus.conditions:type_name -> openshell.v1.SandboxCondition + 290, // 38: openshell.v1.SandboxStartup.ready_within:type_name -> google.protobuf.Duration + 52, // 39: openshell.v1.SandboxStatus.conditions:type_name -> openshell.v1.SandboxCondition 1, // 40: openshell.v1.SandboxStatus.phase:type_name -> openshell.v1.SandboxPhase - 256, // 41: openshell.v1.SandboxStatus.endpoint_statuses:type_name -> openshell.v1.EndpointStatus - 180, // 42: openshell.v1.SandboxStatus.configuration_admission:type_name -> openshell.v1.SandboxConfigurationAdmission - 257, // 43: openshell.v1.SandboxStatus.provisioning:type_name -> openshell.v1.SandboxProvisioning - 284, // 44: openshell.v1.SandboxStatus.next_restart_time:type_name -> google.protobuf.Timestamp - 284, // 45: openshell.v1.SandboxStatus.main_process_started_time:type_name -> google.protobuf.Timestamp - 254, // 46: openshell.v1.SandboxStatus.last_token_grant_failure:type_name -> openshell.v1.TokenGrantFailureObservation - 284, // 47: openshell.v1.SandboxCondition.transition_time:type_name -> google.protobuf.Timestamp - 284, // 48: openshell.v1.PlatformEvent.event_time:type_name -> google.protobuf.Timestamp - 265, // 49: openshell.v1.PlatformEvent.metadata:type_name -> openshell.v1.PlatformEvent.MetadataEntry - 289, // 50: openshell.v1.CreateSandboxRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 39, // 51: openshell.v1.CreateSandboxRequest.spec:type_name -> openshell.v1.SandboxSpec - 266, // 52: openshell.v1.CreateSandboxRequest.labels:type_name -> openshell.v1.CreateSandboxRequest.LabelsEntry - 267, // 53: openshell.v1.CreateSandboxRequest.annotations:type_name -> openshell.v1.CreateSandboxRequest.AnnotationsEntry - 258, // 54: openshell.v1.CreateSandboxRequest.service_exposures:type_name -> openshell.v1.SandboxServiceExposure - 289, // 55: openshell.v1.CreateSandboxTemplateRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 43, // 56: openshell.v1.CreateSandboxTemplateRequest.template:type_name -> openshell.v1.SandboxWorkloadTemplate - 289, // 57: openshell.v1.GetSandboxTemplateRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 289, // 58: openshell.v1.ListSandboxTemplatesRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 289, // 59: openshell.v1.DeleteSandboxTemplateRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 43, // 60: openshell.v1.SandboxTemplateResponse.template:type_name -> openshell.v1.SandboxWorkloadTemplate - 43, // 61: openshell.v1.ListSandboxTemplatesResponse.templates:type_name -> openshell.v1.SandboxWorkloadTemplate - 17, // 62: openshell.v1.DeleteSandboxTemplateResponse.outcome:type_name -> openshell.v1.DeletionOutcome - 289, // 63: openshell.v1.BeginRootfsTarStagingRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 284, // 64: openshell.v1.BeginRootfsTarStagingResponse.expiration_time:type_name -> google.protobuf.Timestamp - 289, // 65: openshell.v1.GetSandboxRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 289, // 66: openshell.v1.ListSandboxesRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 289, // 67: openshell.v1.ListSandboxProvidersRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 289, // 68: openshell.v1.AttachSandboxProviderRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 289, // 69: openshell.v1.DetachSandboxProviderRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 289, // 70: openshell.v1.DeleteSandboxRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 289, // 71: openshell.v1.StopSandboxRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 289, // 72: openshell.v1.StartSandboxRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 38, // 73: openshell.v1.SandboxResponse.sandbox:type_name -> openshell.v1.Sandbox - 268, // 74: openshell.v1.SandboxResponse.service_urls:type_name -> openshell.v1.SandboxResponse.ServiceUrlsEntry - 38, // 75: openshell.v1.ListSandboxesResponse.sandboxes:type_name -> openshell.v1.Sandbox - 290, // 76: openshell.v1.ListSandboxProvidersResponse.providers:type_name -> openshell.datamodel.v1.Provider - 38, // 77: openshell.v1.AttachSandboxProviderResponse.sandbox:type_name -> openshell.v1.Sandbox - 80, // 78: openshell.v1.AttachSandboxProviderResponse.receipt:type_name -> openshell.v1.ProviderMutationReceipt - 38, // 79: openshell.v1.DetachSandboxProviderResponse.sandbox:type_name -> openshell.v1.Sandbox - 80, // 80: openshell.v1.DetachSandboxProviderResponse.receipt:type_name -> openshell.v1.ProviderMutationReceipt - 78, // 81: openshell.v1.ConfigSnapshotRevision.sandbox_config:type_name -> openshell.v1.SandboxConfigRevision - 76, // 82: openshell.v1.ConfigSnapshotRevision.provider_target:type_name -> openshell.v1.ProviderDesiredIdentity - 291, // 83: openshell.v1.SandboxConfigRevision.policy_source:type_name -> openshell.sandbox.v1.PolicySource - 5, // 84: openshell.v1.ConfigUpdateOperation.component:type_name -> openshell.v1.ConfigComponent - 77, // 85: openshell.v1.ConfigUpdateOperation.target_revision:type_name -> openshell.v1.ConfigSnapshotRevision - 7, // 86: openshell.v1.ConfigUpdateOperation.state:type_name -> openshell.v1.ConfigUpdateOperationState - 6, // 87: openshell.v1.ConfigUpdateOperation.outcome:type_name -> openshell.v1.ConfigApplyOutcome - 284, // 88: openshell.v1.ConfigUpdateOperation.created_time:type_name -> google.protobuf.Timestamp - 284, // 89: openshell.v1.ConfigUpdateOperation.updated_time:type_name -> google.protobuf.Timestamp - 284, // 90: openshell.v1.ConfigUpdateOperation.completed_time:type_name -> google.protobuf.Timestamp - 2, // 91: openshell.v1.ProviderMutationReceipt.kind:type_name -> openshell.v1.ProviderMutationKind - 76, // 92: openshell.v1.ProviderMutationReceipt.desired:type_name -> openshell.v1.ProviderDesiredIdentity - 284, // 93: openshell.v1.ProviderMutationReceipt.persisted_time:type_name -> google.protobuf.Timestamp - 4, // 94: openshell.v1.ProviderReadinessObservation.reason:type_name -> openshell.v1.ProviderReadinessReason - 80, // 95: openshell.v1.ProviderReadinessStatus.receipt:type_name -> openshell.v1.ProviderMutationReceipt - 3, // 96: openshell.v1.ProviderReadinessStatus.state:type_name -> openshell.v1.ProviderReadinessState - 4, // 97: openshell.v1.ProviderReadinessStatus.reason:type_name -> openshell.v1.ProviderReadinessReason - 81, // 98: openshell.v1.ProviderReadinessStatus.observed:type_name -> openshell.v1.ProviderReadinessObservation - 284, // 99: openshell.v1.ProviderReadinessStatus.observed_time:type_name -> google.protobuf.Timestamp - 284, // 100: openshell.v1.ProviderReadinessStatus.evaluated_time:type_name -> google.protobuf.Timestamp - 79, // 101: openshell.v1.ProviderReadinessStatus.operation:type_name -> openshell.v1.ConfigUpdateOperation - 289, // 102: openshell.v1.GetSandboxProviderStatusRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 82, // 103: openshell.v1.GetSandboxProviderStatusResponse.status:type_name -> openshell.v1.ProviderReadinessStatus - 81, // 104: openshell.v1.ReportProviderReadinessRequest.observation:type_name -> openshell.v1.ProviderReadinessObservation - 288, // 105: openshell.v1.ReportProviderReadinessResponse.report_interval:type_name -> google.protobuf.Duration - 288, // 106: openshell.v1.ReportProviderReadinessResponse.observation_ttl:type_name -> google.protobuf.Duration - 17, // 107: openshell.v1.DeleteSandboxResponse.outcome:type_name -> openshell.v1.DeletionOutcome - 289, // 108: openshell.v1.CreateSshSessionRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 284, // 109: openshell.v1.CreateSshSessionResponse.expiration_time:type_name -> google.protobuf.Timestamp - 289, // 110: openshell.v1.ExposeServiceRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 19, // 111: openshell.v1.ExposeServiceRequest.authorization_mode:type_name -> openshell.v1.ServiceAuthorizationMode - 289, // 112: openshell.v1.GetServiceRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 289, // 113: openshell.v1.ListServicesRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 97, // 114: openshell.v1.ListServicesResponse.services:type_name -> openshell.v1.ServiceEndpointResponse - 289, // 115: openshell.v1.DeleteServiceRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 17, // 116: openshell.v1.DeleteServiceResponse.outcome:type_name -> openshell.v1.DeletionOutcome - 285, // 117: openshell.v1.ServiceEndpoint.metadata:type_name -> openshell.datamodel.v1.ObjectMeta - 19, // 118: openshell.v1.ServiceEndpoint.authorization_mode:type_name -> openshell.v1.ServiceAuthorizationMode - 96, // 119: openshell.v1.ServiceEndpointResponse.endpoint:type_name -> openshell.v1.ServiceEndpoint - 17, // 120: openshell.v1.RevokeSshSessionResponse.outcome:type_name -> openshell.v1.DeletionOutcome - 289, // 121: openshell.v1.ExecSandboxRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 269, // 122: openshell.v1.ExecSandboxRequest.environment:type_name -> openshell.v1.ExecSandboxRequest.EnvironmentEntry - 288, // 123: openshell.v1.ExecSandboxRequest.execution_timeout:type_name -> google.protobuf.Duration - 101, // 124: openshell.v1.ExecSandboxEvent.stdout:type_name -> openshell.v1.ExecSandboxStdout - 102, // 125: openshell.v1.ExecSandboxEvent.stderr:type_name -> openshell.v1.ExecSandboxStderr - 103, // 126: openshell.v1.ExecSandboxEvent.exit:type_name -> openshell.v1.ExecSandboxExit - 201, // 127: openshell.v1.TcpForwardInit.ssh:type_name -> openshell.v1.SshRelayTarget - 202, // 128: openshell.v1.TcpForwardInit.tcp:type_name -> openshell.v1.TcpRelayTarget - 105, // 129: openshell.v1.TcpForwardFrame.init:type_name -> openshell.v1.TcpForwardInit - 100, // 130: openshell.v1.ExecSandboxInput.start:type_name -> openshell.v1.ExecSandboxRequest - 108, // 131: openshell.v1.ExecSandboxInput.resize:type_name -> openshell.v1.ExecSandboxWindowResize - 285, // 132: openshell.v1.SshSession.metadata:type_name -> openshell.datamodel.v1.ObjectMeta - 284, // 133: openshell.v1.SshSession.expiration_time:type_name -> google.protobuf.Timestamp - 289, // 134: openshell.v1.WatchSandboxRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 284, // 135: openshell.v1.WatchSandboxRequest.since_time:type_name -> google.protobuf.Timestamp - 38, // 136: openshell.v1.SandboxStreamEvent.sandbox:type_name -> openshell.v1.Sandbox - 112, // 137: openshell.v1.SandboxStreamEvent.log:type_name -> openshell.v1.SandboxLogLine - 52, // 138: openshell.v1.SandboxStreamEvent.event:type_name -> openshell.v1.PlatformEvent - 113, // 139: openshell.v1.SandboxStreamEvent.warning:type_name -> openshell.v1.SandboxStreamWarning - 214, // 140: openshell.v1.SandboxStreamEvent.draft_policy_update:type_name -> openshell.v1.DraftPolicyUpdate - 284, // 141: openshell.v1.SandboxLogLine.event_time:type_name -> google.protobuf.Timestamp - 270, // 142: openshell.v1.SandboxLogLine.fields:type_name -> openshell.v1.SandboxLogLine.FieldsEntry - 289, // 143: openshell.v1.CreateProviderRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 290, // 144: openshell.v1.CreateProviderRequest.provider:type_name -> openshell.datamodel.v1.Provider - 289, // 145: openshell.v1.GetProviderRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 289, // 146: openshell.v1.GetProviderCredentialsRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 288, // 147: openshell.v1.GetProviderCredentialsRequest.minimum_remaining_lifetime:type_name -> google.protobuf.Duration - 284, // 148: openshell.v1.ProviderCredentialValue.expiration_time:type_name -> google.protobuf.Timestamp - 271, // 149: openshell.v1.GetProviderCredentialsResponse.credentials:type_name -> openshell.v1.GetProviderCredentialsResponse.CredentialsEntry - 289, // 150: openshell.v1.ListProvidersRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 289, // 151: openshell.v1.UpdateProviderRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 290, // 152: openshell.v1.UpdateProviderRequest.provider:type_name -> openshell.datamodel.v1.Provider - 272, // 153: openshell.v1.UpdateProviderRequest.credential_expiration_times:type_name -> openshell.v1.UpdateProviderRequest.CredentialExpirationTimesEntry - 289, // 154: openshell.v1.DeleteProviderRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 290, // 155: openshell.v1.ProviderResponse.provider:type_name -> openshell.datamodel.v1.Provider - 80, // 156: openshell.v1.ProviderResponse.target_receipts:type_name -> openshell.v1.ProviderMutationReceipt - 290, // 157: openshell.v1.ListProvidersResponse.providers:type_name -> openshell.datamodel.v1.Provider - 289, // 158: openshell.v1.ListProviderProfilesRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 289, // 159: openshell.v1.GetProviderProfileRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 145, // 160: openshell.v1.ProviderProfileImportItem.profile:type_name -> openshell.v1.ProviderProfile - 288, // 161: openshell.v1.ProviderCredentialTokenGrant.cache_ttl:type_name -> google.protobuf.Duration - 128, // 162: openshell.v1.ProviderCredentialTokenGrant.audience_overrides:type_name -> openshell.v1.ProviderCredentialTokenGrantAudienceOverride - 8, // 163: openshell.v1.ProviderCredentialTokenGrant.grant_type:type_name -> openshell.v1.ProviderCredentialTokenGrantType - 129, // 164: openshell.v1.ProviderCredentialTokenGrant.subject_token:type_name -> openshell.v1.ProviderCredentialTokenGrantSubjectToken - 134, // 165: openshell.v1.ProviderProfileCredential.refresh:type_name -> openshell.v1.ProviderCredentialRefresh - 130, // 166: openshell.v1.ProviderProfileCredential.token_grant:type_name -> openshell.v1.ProviderCredentialTokenGrant - 9, // 167: openshell.v1.ProviderCredentialRefresh.strategy:type_name -> openshell.v1.ProviderCredentialRefreshStrategy - 288, // 168: openshell.v1.ProviderCredentialRefresh.refresh_before:type_name -> google.protobuf.Duration - 288, // 169: openshell.v1.ProviderCredentialRefresh.max_lifetime:type_name -> google.protobuf.Duration - 132, // 170: openshell.v1.ProviderCredentialRefresh.material:type_name -> openshell.v1.ProviderCredentialRefreshMaterial - 133, // 171: openshell.v1.ProviderCredentialRefresh.additional_outputs:type_name -> openshell.v1.ProviderCredentialRefreshOutput - 9, // 172: openshell.v1.ProviderCredentialRefreshStatus.strategy:type_name -> openshell.v1.ProviderCredentialRefreshStrategy - 284, // 173: openshell.v1.ProviderCredentialRefreshStatus.expiration_time:type_name -> google.protobuf.Timestamp - 284, // 174: openshell.v1.ProviderCredentialRefreshStatus.next_refresh_time:type_name -> google.protobuf.Timestamp - 284, // 175: openshell.v1.ProviderCredentialRefreshStatus.last_refresh_time:type_name -> google.protobuf.Timestamp - 15, // 176: openshell.v1.ProviderCredentialRefreshStatus.recovery_action:type_name -> openshell.v1.ProviderCredentialRefreshRecoveryAction - 284, // 177: openshell.v1.ProviderCredentialRefreshStatus.last_error_time:type_name -> google.protobuf.Timestamp - 289, // 178: openshell.v1.GetProviderRefreshStatusRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 135, // 179: openshell.v1.GetProviderRefreshStatusResponse.credentials:type_name -> openshell.v1.ProviderCredentialRefreshStatus - 289, // 180: openshell.v1.ConfigureProviderRefreshRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 9, // 181: openshell.v1.ConfigureProviderRefreshRequest.strategy:type_name -> openshell.v1.ProviderCredentialRefreshStrategy - 273, // 182: openshell.v1.ConfigureProviderRefreshRequest.material:type_name -> openshell.v1.ConfigureProviderRefreshRequest.MaterialEntry - 284, // 183: openshell.v1.ConfigureProviderRefreshRequest.expiration_time:type_name -> google.protobuf.Timestamp - 135, // 184: openshell.v1.ConfigureProviderRefreshResponse.status:type_name -> openshell.v1.ProviderCredentialRefreshStatus - 289, // 185: openshell.v1.RotateProviderCredentialRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 135, // 186: openshell.v1.RotateProviderCredentialResponse.status:type_name -> openshell.v1.ProviderCredentialRefreshStatus - 289, // 187: openshell.v1.DeleteProviderRefreshRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 17, // 188: openshell.v1.DeleteProviderRefreshResponse.outcome:type_name -> openshell.v1.DeletionOutcome - 10, // 189: openshell.v1.ProviderProfile.category:type_name -> openshell.v1.ProviderProfileCategory - 131, // 190: openshell.v1.ProviderProfile.credentials:type_name -> openshell.v1.ProviderProfileCredential - 292, // 191: openshell.v1.ProviderProfile.endpoints:type_name -> openshell.sandbox.v1.NetworkEndpoint - 293, // 192: openshell.v1.ProviderProfile.binaries:type_name -> openshell.sandbox.v1.NetworkBinary - 136, // 193: openshell.v1.ProviderProfile.discovery:type_name -> openshell.v1.ProviderProfileDiscovery - 274, // 194: openshell.v1.ProviderProfile.annotations:type_name -> openshell.v1.ProviderProfile.AnnotationsEntry - 146, // 195: openshell.v1.ProviderProfile.files:type_name -> openshell.v1.ProviderProfileFile - 145, // 196: openshell.v1.ProviderProfileResponse.profile:type_name -> openshell.v1.ProviderProfile - 145, // 197: openshell.v1.ListProviderProfilesResponse.profiles:type_name -> openshell.v1.ProviderProfile - 289, // 198: openshell.v1.ImportProviderProfilesRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 126, // 199: openshell.v1.ImportProviderProfilesRequest.profiles:type_name -> openshell.v1.ProviderProfileImportItem - 127, // 200: openshell.v1.ImportProviderProfilesResponse.diagnostics:type_name -> openshell.v1.ProviderProfileDiagnostic - 145, // 201: openshell.v1.ImportProviderProfilesResponse.profiles:type_name -> openshell.v1.ProviderProfile - 289, // 202: openshell.v1.UpdateProviderProfilesRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 126, // 203: openshell.v1.UpdateProviderProfilesRequest.profile:type_name -> openshell.v1.ProviderProfileImportItem - 127, // 204: openshell.v1.UpdateProviderProfilesResponse.diagnostics:type_name -> openshell.v1.ProviderProfileDiagnostic - 145, // 205: openshell.v1.UpdateProviderProfilesResponse.profile:type_name -> openshell.v1.ProviderProfile - 289, // 206: openshell.v1.LintProviderProfilesRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 126, // 207: openshell.v1.LintProviderProfilesRequest.profiles:type_name -> openshell.v1.ProviderProfileImportItem - 127, // 208: openshell.v1.LintProviderProfilesResponse.diagnostics:type_name -> openshell.v1.ProviderProfileDiagnostic - 17, // 209: openshell.v1.DeleteProviderResponse.outcome:type_name -> openshell.v1.DeletionOutcome - 289, // 210: openshell.v1.DeleteProviderProfileRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 17, // 211: openshell.v1.DeleteProviderProfileResponse.outcome:type_name -> openshell.v1.DeletionOutcome - 159, // 212: openshell.v1.StaticCredentialBinding.endpoints:type_name -> openshell.v1.StaticCredentialEndpointBinding - 275, // 213: openshell.v1.GetSandboxProviderEnvironmentResponse.environment:type_name -> openshell.v1.GetSandboxProviderEnvironmentResponse.EnvironmentEntry - 276, // 214: openshell.v1.GetSandboxProviderEnvironmentResponse.credential_expiration_times:type_name -> openshell.v1.GetSandboxProviderEnvironmentResponse.CredentialExpirationTimesEntry - 277, // 215: openshell.v1.GetSandboxProviderEnvironmentResponse.dynamic_credentials:type_name -> openshell.v1.GetSandboxProviderEnvironmentResponse.DynamicCredentialsEntry - 278, // 216: openshell.v1.GetSandboxProviderEnvironmentResponse.static_credential_bindings:type_name -> openshell.v1.GetSandboxProviderEnvironmentResponse.StaticCredentialBindingsEntry - 4, // 217: openshell.v1.GetSandboxProviderEnvironmentResponse.readiness_reason:type_name -> openshell.v1.ProviderReadinessReason - 279, // 218: openshell.v1.GetSandboxProviderEnvironmentResponse.files:type_name -> openshell.v1.GetSandboxProviderEnvironmentResponse.FilesEntry - 288, // 219: openshell.v1.ExchangeProviderSubjectTokenResponse.expires_after:type_name -> google.protobuf.Duration - 289, // 220: openshell.v1.UpdateConfigRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 286, // 221: openshell.v1.UpdateConfigRequest.policy:type_name -> openshell.sandbox.v1.SandboxPolicy - 294, // 222: openshell.v1.UpdateConfigRequest.setting_value:type_name -> openshell.sandbox.v1.SettingValue - 165, // 223: openshell.v1.UpdateConfigRequest.merge_operations:type_name -> openshell.v1.PolicyMergeOperation - 280, // 224: openshell.v1.UpdateConfigRequest.annotations:type_name -> openshell.v1.UpdateConfigRequest.AnnotationsEntry - 166, // 225: openshell.v1.PolicyMergeOperation.add_rule:type_name -> openshell.v1.AddNetworkRule - 167, // 226: openshell.v1.PolicyMergeOperation.remove_endpoint:type_name -> openshell.v1.RemoveNetworkEndpoint - 168, // 227: openshell.v1.PolicyMergeOperation.remove_rule:type_name -> openshell.v1.RemoveNetworkRule - 170, // 228: openshell.v1.PolicyMergeOperation.add_deny_rules:type_name -> openshell.v1.AddDenyRules - 171, // 229: openshell.v1.PolicyMergeOperation.add_allow_rules:type_name -> openshell.v1.AddAllowRules - 172, // 230: openshell.v1.PolicyMergeOperation.remove_binary:type_name -> openshell.v1.RemoveNetworkBinary - 295, // 231: openshell.v1.AddNetworkRule.rule:type_name -> openshell.sandbox.v1.NetworkPolicyRule - 293, // 232: openshell.v1.L7RuleTarget.binaries:type_name -> openshell.sandbox.v1.NetworkBinary - 296, // 233: openshell.v1.AddDenyRules.deny_rules:type_name -> openshell.sandbox.v1.L7DenyRule - 169, // 234: openshell.v1.AddDenyRules.target:type_name -> openshell.v1.L7RuleTarget - 297, // 235: openshell.v1.AddAllowRules.rules:type_name -> openshell.sandbox.v1.L7Rule - 169, // 236: openshell.v1.AddAllowRules.target:type_name -> openshell.v1.L7RuleTarget - 281, // 237: openshell.v1.UpdateConfigResponse.annotations:type_name -> openshell.v1.UpdateConfigResponse.AnnotationsEntry - 289, // 238: openshell.v1.GetSandboxPolicyStatusRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 183, // 239: openshell.v1.GetSandboxPolicyStatusResponse.revision:type_name -> openshell.v1.SandboxPolicyRevision - 289, // 240: openshell.v1.ListSandboxPoliciesRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 183, // 241: openshell.v1.ListSandboxPoliciesResponse.revisions:type_name -> openshell.v1.SandboxPolicyRevision - 12, // 242: openshell.v1.ReportPolicyStatusRequest.status:type_name -> openshell.v1.PolicyStatus - 11, // 243: openshell.v1.SandboxConfigurationAdmission.state:type_name -> openshell.v1.ConfigurationAdmissionState - 180, // 244: openshell.v1.ReportSandboxConfigurationRequest.admission:type_name -> openshell.v1.SandboxConfigurationAdmission - 12, // 245: openshell.v1.SandboxPolicyRevision.status:type_name -> openshell.v1.PolicyStatus - 284, // 246: openshell.v1.SandboxPolicyRevision.created_time:type_name -> google.protobuf.Timestamp - 284, // 247: openshell.v1.SandboxPolicyRevision.loaded_time:type_name -> google.protobuf.Timestamp - 286, // 248: openshell.v1.SandboxPolicyRevision.policy:type_name -> openshell.sandbox.v1.SandboxPolicy - 282, // 249: openshell.v1.SandboxPolicyRevision.provenance:type_name -> openshell.v1.SandboxPolicyRevision.ProvenanceEntry - 289, // 250: openshell.v1.GetSandboxLogsRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 284, // 251: openshell.v1.GetSandboxLogsRequest.since_time:type_name -> google.protobuf.Timestamp - 112, // 252: openshell.v1.PushSandboxLogsRequest.logs:type_name -> openshell.v1.SandboxLogLine - 112, // 253: openshell.v1.GetSandboxLogsResponse.logs:type_name -> openshell.v1.SandboxLogLine - 190, // 254: openshell.v1.SupervisorMessage.hello:type_name -> openshell.v1.SupervisorHello - 194, // 255: openshell.v1.SupervisorMessage.heartbeat:type_name -> openshell.v1.SupervisorHeartbeat - 207, // 256: openshell.v1.SupervisorMessage.relay_open_result:type_name -> openshell.v1.RelayOpenResult - 208, // 257: openshell.v1.SupervisorMessage.relay_close:type_name -> openshell.v1.RelayClose - 191, // 258: openshell.v1.GatewayMessage.session_accepted:type_name -> openshell.v1.SessionAccepted - 192, // 259: openshell.v1.GatewayMessage.session_rejected:type_name -> openshell.v1.SessionRejected - 195, // 260: openshell.v1.GatewayMessage.heartbeat:type_name -> openshell.v1.GatewayHeartbeat - 200, // 261: openshell.v1.GatewayMessage.relay_open:type_name -> openshell.v1.RelayOpen - 208, // 262: openshell.v1.GatewayMessage.relay_close:type_name -> openshell.v1.RelayClose - 193, // 263: openshell.v1.GatewayMessage.session_redirect:type_name -> openshell.v1.SessionRedirect - 288, // 264: openshell.v1.SessionAccepted.heartbeat_interval:type_name -> google.protobuf.Duration - 201, // 265: openshell.v1.RelayOpen.ssh:type_name -> openshell.v1.SshRelayTarget - 202, // 266: openshell.v1.RelayOpen.tcp:type_name -> openshell.v1.TcpRelayTarget - 203, // 267: openshell.v1.RelayFrame.init:type_name -> openshell.v1.RelayInit - 200, // 268: openshell.v1.PeerRelayInit.relay_open:type_name -> openshell.v1.RelayOpen - 205, // 269: openshell.v1.PeerRelayFrame.init:type_name -> openshell.v1.PeerRelayInit - 284, // 270: openshell.v1.DenialSummary.first_seen_time:type_name -> google.protobuf.Timestamp - 284, // 271: openshell.v1.DenialSummary.last_seen_time:type_name -> google.protobuf.Timestamp - 209, // 272: openshell.v1.DenialSummary.l7_request_samples:type_name -> openshell.v1.L7RequestSample - 211, // 273: openshell.v1.NetworkActivitySummary.denials_by_group:type_name -> openshell.v1.DenialGroupCount - 295, // 274: openshell.v1.PolicyChunk.proposed_rule:type_name -> openshell.sandbox.v1.NetworkPolicyRule - 284, // 275: openshell.v1.PolicyChunk.created_time:type_name -> google.protobuf.Timestamp - 284, // 276: openshell.v1.PolicyChunk.decided_time:type_name -> google.protobuf.Timestamp - 284, // 277: openshell.v1.PolicyChunk.first_seen_time:type_name -> google.protobuf.Timestamp - 284, // 278: openshell.v1.PolicyChunk.last_seen_time:type_name -> google.protobuf.Timestamp - 286, // 279: openshell.v1.PolicyChunk.current_effective_policy:type_name -> openshell.sandbox.v1.SandboxPolicy - 286, // 280: openshell.v1.PolicyChunk.candidate_effective_policy:type_name -> openshell.sandbox.v1.SandboxPolicy - 289, // 281: openshell.v1.SubmitPolicyAnalysisRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 210, // 282: openshell.v1.SubmitPolicyAnalysisRequest.summaries:type_name -> openshell.v1.DenialSummary - 213, // 283: openshell.v1.SubmitPolicyAnalysisRequest.proposed_chunks:type_name -> openshell.v1.PolicyChunk - 212, // 284: openshell.v1.SubmitPolicyAnalysisRequest.network_activity_summaries:type_name -> openshell.v1.NetworkActivitySummary - 289, // 285: openshell.v1.GetDraftPolicyRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 213, // 286: openshell.v1.GetDraftPolicyResponse.chunks:type_name -> openshell.v1.PolicyChunk - 284, // 287: openshell.v1.GetDraftPolicyResponse.last_analyzed_time:type_name -> google.protobuf.Timestamp - 289, // 288: openshell.v1.ApproveDraftChunkRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 289, // 289: openshell.v1.RejectDraftChunkRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 289, // 290: openshell.v1.ApproveAllDraftChunksRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 223, // 291: openshell.v1.ApproveAllDraftChunksRequest.approvals:type_name -> openshell.v1.DraftChunkApproval - 289, // 292: openshell.v1.EditDraftChunkRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 295, // 293: openshell.v1.EditDraftChunkRequest.proposed_rule:type_name -> openshell.sandbox.v1.NetworkPolicyRule - 289, // 294: openshell.v1.UndoDraftChunkRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 289, // 295: openshell.v1.ClearDraftChunksRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 289, // 296: openshell.v1.GetDraftHistoryRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 284, // 297: openshell.v1.DraftHistoryEntry.event_time:type_name -> google.protobuf.Timestamp - 233, // 298: openshell.v1.GetDraftHistoryResponse.entries:type_name -> openshell.v1.DraftHistoryEntry - 283, // 299: openshell.v1.CreateWorkspaceRequest.labels:type_name -> openshell.v1.CreateWorkspaceRequest.LabelsEntry - 298, // 300: openshell.v1.CreateWorkspaceResponse.workspace:type_name -> openshell.datamodel.v1.Workspace - 298, // 301: openshell.v1.GetWorkspaceResponse.workspace:type_name -> openshell.datamodel.v1.Workspace - 298, // 302: openshell.v1.ListWorkspacesResponse.workspaces:type_name -> openshell.datamodel.v1.Workspace - 17, // 303: openshell.v1.DeleteWorkspaceResponse.outcome:type_name -> openshell.v1.DeletionOutcome - 285, // 304: openshell.v1.WorkspaceMember.metadata:type_name -> openshell.datamodel.v1.ObjectMeta - 14, // 305: openshell.v1.WorkspaceMember.role:type_name -> openshell.v1.WorkspaceRole - 289, // 306: openshell.v1.AddWorkspaceMemberRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 14, // 307: openshell.v1.AddWorkspaceMemberRequest.role:type_name -> openshell.v1.WorkspaceRole - 243, // 308: openshell.v1.AddWorkspaceMemberResponse.member:type_name -> openshell.v1.WorkspaceMember - 289, // 309: openshell.v1.RemoveWorkspaceMemberRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 17, // 310: openshell.v1.RemoveWorkspaceMemberResponse.outcome:type_name -> openshell.v1.DeletionOutcome - 289, // 311: openshell.v1.ListWorkspaceMembersRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 243, // 312: openshell.v1.ListWorkspaceMembersResponse.members:type_name -> openshell.v1.WorkspaceMember - 284, // 313: openshell.v1.ExtensionServiceCredential.expiration_time:type_name -> google.protobuf.Timestamp - 18, // 314: openshell.v1.EndpointObservation.result:type_name -> openshell.v1.EndpointResult - 259, // 315: openshell.v1.EndpointObservation.failure:type_name -> openshell.v1.EndpointFailure - 251, // 316: openshell.v1.ReportEndpointStatusRequest.observations:type_name -> openshell.v1.EndpointObservation - 253, // 317: openshell.v1.ReportEndpointStatusRequest.token_grant_status:type_name -> openshell.v1.TokenGrantStatus - 254, // 318: openshell.v1.TokenGrantStatus.last_failure:type_name -> openshell.v1.TokenGrantFailureObservation - 259, // 319: openshell.v1.TokenGrantFailureObservation.failure:type_name -> openshell.v1.EndpointFailure - 18, // 320: openshell.v1.EndpointStatus.last_result:type_name -> openshell.v1.EndpointResult - 284, // 321: openshell.v1.EndpointStatus.last_reported_time:type_name -> google.protobuf.Timestamp - 259, // 322: openshell.v1.EndpointStatus.last_failure:type_name -> openshell.v1.EndpointFailure - 284, // 323: openshell.v1.SandboxProvisioning.configuration_change_time:type_name -> google.protobuf.Timestamp - 284, // 324: openshell.v1.SandboxProvisioning.first_rejection_time:type_name -> google.protobuf.Timestamp - 284, // 325: openshell.v1.SandboxProvisioning.deadline:type_name -> google.protobuf.Timestamp - 284, // 326: openshell.v1.SandboxProvisioning.timeout_time:type_name -> google.protobuf.Timestamp - 284, // 327: openshell.v1.SandboxProvisioning.cleanup_completed_time:type_name -> google.protobuf.Timestamp - 284, // 328: openshell.v1.SandboxProvisioning.cleanup_retry_time:type_name -> google.protobuf.Timestamp - 284, // 329: openshell.v1.SandboxProvisioning.attachment_change_time:type_name -> google.protobuf.Timestamp - 284, // 330: openshell.v1.SandboxProvisioning.preparation_deadline:type_name -> google.protobuf.Timestamp - 284, // 331: openshell.v1.SandboxProvisioning.admission_start_time:type_name -> google.protobuf.Timestamp - 19, // 332: openshell.v1.SandboxServiceExposure.authorization_mode:type_name -> openshell.v1.ServiceAuthorizationMode - 20, // 333: openshell.v1.EndpointFailure.domain:type_name -> openshell.v1.EndpointFailureDomain - 15, // 334: openshell.v1.EndpointFailure.recovery_action:type_name -> openshell.v1.ProviderCredentialRefreshRecoveryAction - 117, // 335: openshell.v1.GetProviderCredentialsResponse.CredentialsEntry.value:type_name -> openshell.v1.ProviderCredentialValue - 284, // 336: openshell.v1.UpdateProviderRequest.CredentialExpirationTimesEntry.value:type_name -> google.protobuf.Timestamp - 284, // 337: openshell.v1.GetSandboxProviderEnvironmentResponse.CredentialExpirationTimesEntry.value:type_name -> google.protobuf.Timestamp - 131, // 338: openshell.v1.GetSandboxProviderEnvironmentResponse.DynamicCredentialsEntry.value:type_name -> openshell.v1.ProviderProfileCredential - 160, // 339: openshell.v1.GetSandboxProviderEnvironmentResponse.StaticCredentialBindingsEntry.value:type_name -> openshell.v1.StaticCredentialBinding - 25, // 340: openshell.v1.OpenShell.Health:input_type -> openshell.v1.HealthRequest - 27, // 341: openshell.v1.OpenShell.GetCurrentUser:input_type -> openshell.v1.GetCurrentUserRequest - 29, // 342: openshell.v1.OpenShell.GetGatewayInfo:input_type -> openshell.v1.GetGatewayInfoRequest - 53, // 343: openshell.v1.OpenShell.CreateSandbox:input_type -> openshell.v1.CreateSandboxRequest - 61, // 344: openshell.v1.OpenShell.BeginRootfsTarStaging:input_type -> openshell.v1.BeginRootfsTarStagingRequest - 63, // 345: openshell.v1.OpenShell.GetSandbox:input_type -> openshell.v1.GetSandboxRequest - 64, // 346: openshell.v1.OpenShell.ListSandboxes:input_type -> openshell.v1.ListSandboxesRequest - 54, // 347: openshell.v1.OpenShell.CreateSandboxTemplate:input_type -> openshell.v1.CreateSandboxTemplateRequest - 55, // 348: openshell.v1.OpenShell.GetSandboxTemplate:input_type -> openshell.v1.GetSandboxTemplateRequest - 56, // 349: openshell.v1.OpenShell.ListSandboxTemplates:input_type -> openshell.v1.ListSandboxTemplatesRequest - 57, // 350: openshell.v1.OpenShell.DeleteSandboxTemplate:input_type -> openshell.v1.DeleteSandboxTemplateRequest - 65, // 351: openshell.v1.OpenShell.ListSandboxProviders:input_type -> openshell.v1.ListSandboxProvidersRequest - 66, // 352: openshell.v1.OpenShell.AttachSandboxProvider:input_type -> openshell.v1.AttachSandboxProviderRequest - 67, // 353: openshell.v1.OpenShell.DetachSandboxProvider:input_type -> openshell.v1.DetachSandboxProviderRequest - 83, // 354: openshell.v1.OpenShell.GetSandboxProviderStatus:input_type -> openshell.v1.GetSandboxProviderStatusRequest - 68, // 355: openshell.v1.OpenShell.DeleteSandbox:input_type -> openshell.v1.DeleteSandboxRequest - 69, // 356: openshell.v1.OpenShell.StopSandbox:input_type -> openshell.v1.StopSandboxRequest - 70, // 357: openshell.v1.OpenShell.StartSandbox:input_type -> openshell.v1.StartSandboxRequest - 88, // 358: openshell.v1.OpenShell.CreateSshSession:input_type -> openshell.v1.CreateSshSessionRequest - 90, // 359: openshell.v1.OpenShell.ExposeService:input_type -> openshell.v1.ExposeServiceRequest - 91, // 360: openshell.v1.OpenShell.GetService:input_type -> openshell.v1.GetServiceRequest - 92, // 361: openshell.v1.OpenShell.ListServices:input_type -> openshell.v1.ListServicesRequest - 94, // 362: openshell.v1.OpenShell.DeleteService:input_type -> openshell.v1.DeleteServiceRequest - 98, // 363: openshell.v1.OpenShell.RevokeSshSession:input_type -> openshell.v1.RevokeSshSessionRequest - 100, // 364: openshell.v1.OpenShell.ExecSandbox:input_type -> openshell.v1.ExecSandboxRequest - 106, // 365: openshell.v1.OpenShell.ForwardTcp:input_type -> openshell.v1.TcpForwardFrame - 107, // 366: openshell.v1.OpenShell.ExecSandboxInteractive:input_type -> openshell.v1.ExecSandboxInput - 114, // 367: openshell.v1.OpenShell.CreateProvider:input_type -> openshell.v1.CreateProviderRequest - 115, // 368: openshell.v1.OpenShell.GetProvider:input_type -> openshell.v1.GetProviderRequest - 116, // 369: openshell.v1.OpenShell.GetProviderCredentials:input_type -> openshell.v1.GetProviderCredentialsRequest - 119, // 370: openshell.v1.OpenShell.ListProviders:input_type -> openshell.v1.ListProvidersRequest - 124, // 371: openshell.v1.OpenShell.ListProviderProfiles:input_type -> openshell.v1.ListProviderProfilesRequest - 125, // 372: openshell.v1.OpenShell.GetProviderProfile:input_type -> openshell.v1.GetProviderProfileRequest - 149, // 373: openshell.v1.OpenShell.ImportProviderProfiles:input_type -> openshell.v1.ImportProviderProfilesRequest - 151, // 374: openshell.v1.OpenShell.UpdateProviderProfiles:input_type -> openshell.v1.UpdateProviderProfilesRequest - 153, // 375: openshell.v1.OpenShell.LintProviderProfiles:input_type -> openshell.v1.LintProviderProfilesRequest - 120, // 376: openshell.v1.OpenShell.UpdateProvider:input_type -> openshell.v1.UpdateProviderRequest - 137, // 377: openshell.v1.OpenShell.GetProviderRefreshStatus:input_type -> openshell.v1.GetProviderRefreshStatusRequest - 139, // 378: openshell.v1.OpenShell.ConfigureProviderRefresh:input_type -> openshell.v1.ConfigureProviderRefreshRequest - 141, // 379: openshell.v1.OpenShell.RotateProviderCredential:input_type -> openshell.v1.RotateProviderCredentialRequest - 143, // 380: openshell.v1.OpenShell.DeleteProviderRefresh:input_type -> openshell.v1.DeleteProviderRefreshRequest - 121, // 381: openshell.v1.OpenShell.DeleteProvider:input_type -> openshell.v1.DeleteProviderRequest - 156, // 382: openshell.v1.OpenShell.DeleteProviderProfile:input_type -> openshell.v1.DeleteProviderProfileRequest - 299, // 383: openshell.v1.OpenShell.GetSandboxConfig:input_type -> openshell.sandbox.v1.GetSandboxConfigRequest - 300, // 384: openshell.v1.OpenShell.GetGatewayConfig:input_type -> openshell.sandbox.v1.GetGatewayConfigRequest - 164, // 385: openshell.v1.OpenShell.UpdateConfig:input_type -> openshell.v1.UpdateConfigRequest - 174, // 386: openshell.v1.OpenShell.GetSandboxPolicyStatus:input_type -> openshell.v1.GetSandboxPolicyStatusRequest - 176, // 387: openshell.v1.OpenShell.ListSandboxPolicies:input_type -> openshell.v1.ListSandboxPoliciesRequest - 178, // 388: openshell.v1.OpenShell.ReportPolicyStatus:input_type -> openshell.v1.ReportPolicyStatusRequest - 252, // 389: openshell.v1.OpenShell.ReportEndpointStatus:input_type -> openshell.v1.ReportEndpointStatusRequest - 85, // 390: openshell.v1.OpenShell.ReportProviderReadiness:input_type -> openshell.v1.ReportProviderReadinessRequest - 181, // 391: openshell.v1.OpenShell.ReportSandboxConfiguration:input_type -> openshell.v1.ReportSandboxConfigurationRequest - 158, // 392: openshell.v1.OpenShell.GetSandboxProviderEnvironment:input_type -> openshell.v1.GetSandboxProviderEnvironmentRequest - 162, // 393: openshell.v1.OpenShell.ExchangeProviderSubjectToken:input_type -> openshell.v1.ExchangeProviderSubjectTokenRequest - 184, // 394: openshell.v1.OpenShell.GetSandboxLogs:input_type -> openshell.v1.GetSandboxLogsRequest - 185, // 395: openshell.v1.OpenShell.PushSandboxLogs:input_type -> openshell.v1.PushSandboxLogsRequest - 188, // 396: openshell.v1.OpenShell.ConnectSupervisor:input_type -> openshell.v1.SupervisorMessage - 196, // 397: openshell.v1.OpenShell.ReportMainProcessExit:input_type -> openshell.v1.ReportMainProcessExitRequest - 198, // 398: openshell.v1.OpenShell.FinalizeMainProcessExit:input_type -> openshell.v1.FinalizeMainProcessExitRequest - 204, // 399: openshell.v1.OpenShell.RelayStream:input_type -> openshell.v1.RelayFrame - 206, // 400: openshell.v1.OpenShell.PeerRelay:input_type -> openshell.v1.PeerRelayFrame - 85, // 401: openshell.v1.OpenShell.PeerReportProviderReadiness:input_type -> openshell.v1.ReportProviderReadinessRequest - 252, // 402: openshell.v1.OpenShell.PeerReportEndpointStatus:input_type -> openshell.v1.ReportEndpointStatusRequest - 83, // 403: openshell.v1.OpenShell.PeerGetSandboxProviderStatus:input_type -> openshell.v1.GetSandboxProviderStatusRequest - 110, // 404: openshell.v1.OpenShell.WatchSandbox:input_type -> openshell.v1.WatchSandboxRequest - 215, // 405: openshell.v1.OpenShell.SubmitPolicyAnalysis:input_type -> openshell.v1.SubmitPolicyAnalysisRequest - 217, // 406: openshell.v1.OpenShell.GetDraftPolicy:input_type -> openshell.v1.GetDraftPolicyRequest - 219, // 407: openshell.v1.OpenShell.ApproveDraftChunk:input_type -> openshell.v1.ApproveDraftChunkRequest - 221, // 408: openshell.v1.OpenShell.RejectDraftChunk:input_type -> openshell.v1.RejectDraftChunkRequest - 224, // 409: openshell.v1.OpenShell.ApproveAllDraftChunks:input_type -> openshell.v1.ApproveAllDraftChunksRequest - 226, // 410: openshell.v1.OpenShell.EditDraftChunk:input_type -> openshell.v1.EditDraftChunkRequest - 228, // 411: openshell.v1.OpenShell.UndoDraftChunk:input_type -> openshell.v1.UndoDraftChunkRequest - 230, // 412: openshell.v1.OpenShell.ClearDraftChunks:input_type -> openshell.v1.ClearDraftChunksRequest - 232, // 413: openshell.v1.OpenShell.GetDraftHistory:input_type -> openshell.v1.GetDraftHistoryRequest - 21, // 414: openshell.v1.OpenShell.IssueSandboxToken:input_type -> openshell.v1.IssueSandboxTokenRequest - 23, // 415: openshell.v1.OpenShell.RefreshSandboxToken:input_type -> openshell.v1.RefreshSandboxTokenRequest - 235, // 416: openshell.v1.OpenShell.CreateWorkspace:input_type -> openshell.v1.CreateWorkspaceRequest - 237, // 417: openshell.v1.OpenShell.GetWorkspace:input_type -> openshell.v1.GetWorkspaceRequest - 239, // 418: openshell.v1.OpenShell.ListWorkspaces:input_type -> openshell.v1.ListWorkspacesRequest - 241, // 419: openshell.v1.OpenShell.DeleteWorkspace:input_type -> openshell.v1.DeleteWorkspaceRequest - 244, // 420: openshell.v1.OpenShell.AddWorkspaceMember:input_type -> openshell.v1.AddWorkspaceMemberRequest - 246, // 421: openshell.v1.OpenShell.RemoveWorkspaceMember:input_type -> openshell.v1.RemoveWorkspaceMemberRequest - 248, // 422: openshell.v1.OpenShell.ListWorkspaceMembers:input_type -> openshell.v1.ListWorkspaceMembersRequest - 26, // 423: openshell.v1.OpenShell.Health:output_type -> openshell.v1.HealthResponse - 28, // 424: openshell.v1.OpenShell.GetCurrentUser:output_type -> openshell.v1.GetCurrentUserResponse - 30, // 425: openshell.v1.OpenShell.GetGatewayInfo:output_type -> openshell.v1.GetGatewayInfoResponse - 71, // 426: openshell.v1.OpenShell.CreateSandbox:output_type -> openshell.v1.SandboxResponse - 62, // 427: openshell.v1.OpenShell.BeginRootfsTarStaging:output_type -> openshell.v1.BeginRootfsTarStagingResponse - 71, // 428: openshell.v1.OpenShell.GetSandbox:output_type -> openshell.v1.SandboxResponse - 72, // 429: openshell.v1.OpenShell.ListSandboxes:output_type -> openshell.v1.ListSandboxesResponse - 58, // 430: openshell.v1.OpenShell.CreateSandboxTemplate:output_type -> openshell.v1.SandboxTemplateResponse - 58, // 431: openshell.v1.OpenShell.GetSandboxTemplate:output_type -> openshell.v1.SandboxTemplateResponse - 59, // 432: openshell.v1.OpenShell.ListSandboxTemplates:output_type -> openshell.v1.ListSandboxTemplatesResponse - 60, // 433: openshell.v1.OpenShell.DeleteSandboxTemplate:output_type -> openshell.v1.DeleteSandboxTemplateResponse - 73, // 434: openshell.v1.OpenShell.ListSandboxProviders:output_type -> openshell.v1.ListSandboxProvidersResponse - 74, // 435: openshell.v1.OpenShell.AttachSandboxProvider:output_type -> openshell.v1.AttachSandboxProviderResponse - 75, // 436: openshell.v1.OpenShell.DetachSandboxProvider:output_type -> openshell.v1.DetachSandboxProviderResponse - 84, // 437: openshell.v1.OpenShell.GetSandboxProviderStatus:output_type -> openshell.v1.GetSandboxProviderStatusResponse - 87, // 438: openshell.v1.OpenShell.DeleteSandbox:output_type -> openshell.v1.DeleteSandboxResponse - 71, // 439: openshell.v1.OpenShell.StopSandbox:output_type -> openshell.v1.SandboxResponse - 71, // 440: openshell.v1.OpenShell.StartSandbox:output_type -> openshell.v1.SandboxResponse - 89, // 441: openshell.v1.OpenShell.CreateSshSession:output_type -> openshell.v1.CreateSshSessionResponse - 97, // 442: openshell.v1.OpenShell.ExposeService:output_type -> openshell.v1.ServiceEndpointResponse - 97, // 443: openshell.v1.OpenShell.GetService:output_type -> openshell.v1.ServiceEndpointResponse - 93, // 444: openshell.v1.OpenShell.ListServices:output_type -> openshell.v1.ListServicesResponse - 95, // 445: openshell.v1.OpenShell.DeleteService:output_type -> openshell.v1.DeleteServiceResponse - 99, // 446: openshell.v1.OpenShell.RevokeSshSession:output_type -> openshell.v1.RevokeSshSessionResponse - 104, // 447: openshell.v1.OpenShell.ExecSandbox:output_type -> openshell.v1.ExecSandboxEvent - 106, // 448: openshell.v1.OpenShell.ForwardTcp:output_type -> openshell.v1.TcpForwardFrame - 104, // 449: openshell.v1.OpenShell.ExecSandboxInteractive:output_type -> openshell.v1.ExecSandboxEvent - 122, // 450: openshell.v1.OpenShell.CreateProvider:output_type -> openshell.v1.ProviderResponse - 122, // 451: openshell.v1.OpenShell.GetProvider:output_type -> openshell.v1.ProviderResponse - 118, // 452: openshell.v1.OpenShell.GetProviderCredentials:output_type -> openshell.v1.GetProviderCredentialsResponse - 123, // 453: openshell.v1.OpenShell.ListProviders:output_type -> openshell.v1.ListProvidersResponse - 148, // 454: openshell.v1.OpenShell.ListProviderProfiles:output_type -> openshell.v1.ListProviderProfilesResponse - 147, // 455: openshell.v1.OpenShell.GetProviderProfile:output_type -> openshell.v1.ProviderProfileResponse - 150, // 456: openshell.v1.OpenShell.ImportProviderProfiles:output_type -> openshell.v1.ImportProviderProfilesResponse - 152, // 457: openshell.v1.OpenShell.UpdateProviderProfiles:output_type -> openshell.v1.UpdateProviderProfilesResponse - 154, // 458: openshell.v1.OpenShell.LintProviderProfiles:output_type -> openshell.v1.LintProviderProfilesResponse - 122, // 459: openshell.v1.OpenShell.UpdateProvider:output_type -> openshell.v1.ProviderResponse - 138, // 460: openshell.v1.OpenShell.GetProviderRefreshStatus:output_type -> openshell.v1.GetProviderRefreshStatusResponse - 140, // 461: openshell.v1.OpenShell.ConfigureProviderRefresh:output_type -> openshell.v1.ConfigureProviderRefreshResponse - 142, // 462: openshell.v1.OpenShell.RotateProviderCredential:output_type -> openshell.v1.RotateProviderCredentialResponse - 144, // 463: openshell.v1.OpenShell.DeleteProviderRefresh:output_type -> openshell.v1.DeleteProviderRefreshResponse - 155, // 464: openshell.v1.OpenShell.DeleteProvider:output_type -> openshell.v1.DeleteProviderResponse - 157, // 465: openshell.v1.OpenShell.DeleteProviderProfile:output_type -> openshell.v1.DeleteProviderProfileResponse - 301, // 466: openshell.v1.OpenShell.GetSandboxConfig:output_type -> openshell.sandbox.v1.GetSandboxConfigResponse - 302, // 467: openshell.v1.OpenShell.GetGatewayConfig:output_type -> openshell.sandbox.v1.GetGatewayConfigResponse - 173, // 468: openshell.v1.OpenShell.UpdateConfig:output_type -> openshell.v1.UpdateConfigResponse - 175, // 469: openshell.v1.OpenShell.GetSandboxPolicyStatus:output_type -> openshell.v1.GetSandboxPolicyStatusResponse - 177, // 470: openshell.v1.OpenShell.ListSandboxPolicies:output_type -> openshell.v1.ListSandboxPoliciesResponse - 179, // 471: openshell.v1.OpenShell.ReportPolicyStatus:output_type -> openshell.v1.ReportPolicyStatusResponse - 255, // 472: openshell.v1.OpenShell.ReportEndpointStatus:output_type -> openshell.v1.ReportEndpointStatusResponse - 86, // 473: openshell.v1.OpenShell.ReportProviderReadiness:output_type -> openshell.v1.ReportProviderReadinessResponse - 182, // 474: openshell.v1.OpenShell.ReportSandboxConfiguration:output_type -> openshell.v1.ReportSandboxConfigurationResponse - 161, // 475: openshell.v1.OpenShell.GetSandboxProviderEnvironment:output_type -> openshell.v1.GetSandboxProviderEnvironmentResponse - 163, // 476: openshell.v1.OpenShell.ExchangeProviderSubjectToken:output_type -> openshell.v1.ExchangeProviderSubjectTokenResponse - 187, // 477: openshell.v1.OpenShell.GetSandboxLogs:output_type -> openshell.v1.GetSandboxLogsResponse - 186, // 478: openshell.v1.OpenShell.PushSandboxLogs:output_type -> openshell.v1.PushSandboxLogsResponse - 189, // 479: openshell.v1.OpenShell.ConnectSupervisor:output_type -> openshell.v1.GatewayMessage - 197, // 480: openshell.v1.OpenShell.ReportMainProcessExit:output_type -> openshell.v1.ReportMainProcessExitResponse - 199, // 481: openshell.v1.OpenShell.FinalizeMainProcessExit:output_type -> openshell.v1.FinalizeMainProcessExitResponse - 204, // 482: openshell.v1.OpenShell.RelayStream:output_type -> openshell.v1.RelayFrame - 206, // 483: openshell.v1.OpenShell.PeerRelay:output_type -> openshell.v1.PeerRelayFrame - 86, // 484: openshell.v1.OpenShell.PeerReportProviderReadiness:output_type -> openshell.v1.ReportProviderReadinessResponse - 255, // 485: openshell.v1.OpenShell.PeerReportEndpointStatus:output_type -> openshell.v1.ReportEndpointStatusResponse - 84, // 486: openshell.v1.OpenShell.PeerGetSandboxProviderStatus:output_type -> openshell.v1.GetSandboxProviderStatusResponse - 111, // 487: openshell.v1.OpenShell.WatchSandbox:output_type -> openshell.v1.SandboxStreamEvent - 216, // 488: openshell.v1.OpenShell.SubmitPolicyAnalysis:output_type -> openshell.v1.SubmitPolicyAnalysisResponse - 218, // 489: openshell.v1.OpenShell.GetDraftPolicy:output_type -> openshell.v1.GetDraftPolicyResponse - 220, // 490: openshell.v1.OpenShell.ApproveDraftChunk:output_type -> openshell.v1.ApproveDraftChunkResponse - 222, // 491: openshell.v1.OpenShell.RejectDraftChunk:output_type -> openshell.v1.RejectDraftChunkResponse - 225, // 492: openshell.v1.OpenShell.ApproveAllDraftChunks:output_type -> openshell.v1.ApproveAllDraftChunksResponse - 227, // 493: openshell.v1.OpenShell.EditDraftChunk:output_type -> openshell.v1.EditDraftChunkResponse - 229, // 494: openshell.v1.OpenShell.UndoDraftChunk:output_type -> openshell.v1.UndoDraftChunkResponse - 231, // 495: openshell.v1.OpenShell.ClearDraftChunks:output_type -> openshell.v1.ClearDraftChunksResponse - 234, // 496: openshell.v1.OpenShell.GetDraftHistory:output_type -> openshell.v1.GetDraftHistoryResponse - 22, // 497: openshell.v1.OpenShell.IssueSandboxToken:output_type -> openshell.v1.IssueSandboxTokenResponse - 24, // 498: openshell.v1.OpenShell.RefreshSandboxToken:output_type -> openshell.v1.RefreshSandboxTokenResponse - 236, // 499: openshell.v1.OpenShell.CreateWorkspace:output_type -> openshell.v1.CreateWorkspaceResponse - 238, // 500: openshell.v1.OpenShell.GetWorkspace:output_type -> openshell.v1.GetWorkspaceResponse - 240, // 501: openshell.v1.OpenShell.ListWorkspaces:output_type -> openshell.v1.ListWorkspacesResponse - 242, // 502: openshell.v1.OpenShell.DeleteWorkspace:output_type -> openshell.v1.DeleteWorkspaceResponse - 245, // 503: openshell.v1.OpenShell.AddWorkspaceMember:output_type -> openshell.v1.AddWorkspaceMemberResponse - 247, // 504: openshell.v1.OpenShell.RemoveWorkspaceMember:output_type -> openshell.v1.RemoveWorkspaceMemberResponse - 249, // 505: openshell.v1.OpenShell.ListWorkspaceMembers:output_type -> openshell.v1.ListWorkspaceMembersResponse - 423, // [423:506] is the sub-list for method output_type - 340, // [340:423] is the sub-list for method input_type - 340, // [340:340] is the sub-list for extension type_name - 340, // [340:340] is the sub-list for extension extendee - 0, // [0:340] is the sub-list for field type_name + 258, // 41: openshell.v1.SandboxStatus.endpoint_statuses:type_name -> openshell.v1.EndpointStatus + 182, // 42: openshell.v1.SandboxStatus.configuration_admission:type_name -> openshell.v1.SandboxConfigurationAdmission + 259, // 43: openshell.v1.SandboxStatus.provisioning:type_name -> openshell.v1.SandboxProvisioning + 286, // 44: openshell.v1.SandboxStatus.next_restart_time:type_name -> google.protobuf.Timestamp + 286, // 45: openshell.v1.SandboxStatus.main_process_started_time:type_name -> google.protobuf.Timestamp + 256, // 46: openshell.v1.SandboxStatus.last_token_grant_failure:type_name -> openshell.v1.TokenGrantFailureObservation + 51, // 47: openshell.v1.SandboxStatus.image_update:type_name -> openshell.v1.SandboxImageUpdate + 286, // 48: openshell.v1.SandboxCondition.transition_time:type_name -> google.protobuf.Timestamp + 286, // 49: openshell.v1.PlatformEvent.event_time:type_name -> google.protobuf.Timestamp + 267, // 50: openshell.v1.PlatformEvent.metadata:type_name -> openshell.v1.PlatformEvent.MetadataEntry + 291, // 51: openshell.v1.CreateSandboxRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 39, // 52: openshell.v1.CreateSandboxRequest.spec:type_name -> openshell.v1.SandboxSpec + 268, // 53: openshell.v1.CreateSandboxRequest.labels:type_name -> openshell.v1.CreateSandboxRequest.LabelsEntry + 269, // 54: openshell.v1.CreateSandboxRequest.annotations:type_name -> openshell.v1.CreateSandboxRequest.AnnotationsEntry + 260, // 55: openshell.v1.CreateSandboxRequest.service_exposures:type_name -> openshell.v1.SandboxServiceExposure + 291, // 56: openshell.v1.UpdateSandboxRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 291, // 57: openshell.v1.CreateSandboxTemplateRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 43, // 58: openshell.v1.CreateSandboxTemplateRequest.template:type_name -> openshell.v1.SandboxWorkloadTemplate + 291, // 59: openshell.v1.GetSandboxTemplateRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 291, // 60: openshell.v1.ListSandboxTemplatesRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 291, // 61: openshell.v1.DeleteSandboxTemplateRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 43, // 62: openshell.v1.SandboxTemplateResponse.template:type_name -> openshell.v1.SandboxWorkloadTemplate + 43, // 63: openshell.v1.ListSandboxTemplatesResponse.templates:type_name -> openshell.v1.SandboxWorkloadTemplate + 17, // 64: openshell.v1.DeleteSandboxTemplateResponse.outcome:type_name -> openshell.v1.DeletionOutcome + 291, // 65: openshell.v1.BeginRootfsTarStagingRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 286, // 66: openshell.v1.BeginRootfsTarStagingResponse.expiration_time:type_name -> google.protobuf.Timestamp + 291, // 67: openshell.v1.GetSandboxRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 291, // 68: openshell.v1.ListSandboxesRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 291, // 69: openshell.v1.ListSandboxProvidersRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 291, // 70: openshell.v1.AttachSandboxProviderRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 291, // 71: openshell.v1.DetachSandboxProviderRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 291, // 72: openshell.v1.DeleteSandboxRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 291, // 73: openshell.v1.StopSandboxRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 291, // 74: openshell.v1.StartSandboxRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 38, // 75: openshell.v1.SandboxResponse.sandbox:type_name -> openshell.v1.Sandbox + 270, // 76: openshell.v1.SandboxResponse.service_urls:type_name -> openshell.v1.SandboxResponse.ServiceUrlsEntry + 38, // 77: openshell.v1.ListSandboxesResponse.sandboxes:type_name -> openshell.v1.Sandbox + 292, // 78: openshell.v1.ListSandboxProvidersResponse.providers:type_name -> openshell.datamodel.v1.Provider + 38, // 79: openshell.v1.AttachSandboxProviderResponse.sandbox:type_name -> openshell.v1.Sandbox + 82, // 80: openshell.v1.AttachSandboxProviderResponse.receipt:type_name -> openshell.v1.ProviderMutationReceipt + 38, // 81: openshell.v1.DetachSandboxProviderResponse.sandbox:type_name -> openshell.v1.Sandbox + 82, // 82: openshell.v1.DetachSandboxProviderResponse.receipt:type_name -> openshell.v1.ProviderMutationReceipt + 80, // 83: openshell.v1.ConfigSnapshotRevision.sandbox_config:type_name -> openshell.v1.SandboxConfigRevision + 78, // 84: openshell.v1.ConfigSnapshotRevision.provider_target:type_name -> openshell.v1.ProviderDesiredIdentity + 293, // 85: openshell.v1.SandboxConfigRevision.policy_source:type_name -> openshell.sandbox.v1.PolicySource + 5, // 86: openshell.v1.ConfigUpdateOperation.component:type_name -> openshell.v1.ConfigComponent + 79, // 87: openshell.v1.ConfigUpdateOperation.target_revision:type_name -> openshell.v1.ConfigSnapshotRevision + 7, // 88: openshell.v1.ConfigUpdateOperation.state:type_name -> openshell.v1.ConfigUpdateOperationState + 6, // 89: openshell.v1.ConfigUpdateOperation.outcome:type_name -> openshell.v1.ConfigApplyOutcome + 286, // 90: openshell.v1.ConfigUpdateOperation.created_time:type_name -> google.protobuf.Timestamp + 286, // 91: openshell.v1.ConfigUpdateOperation.updated_time:type_name -> google.protobuf.Timestamp + 286, // 92: openshell.v1.ConfigUpdateOperation.completed_time:type_name -> google.protobuf.Timestamp + 2, // 93: openshell.v1.ProviderMutationReceipt.kind:type_name -> openshell.v1.ProviderMutationKind + 78, // 94: openshell.v1.ProviderMutationReceipt.desired:type_name -> openshell.v1.ProviderDesiredIdentity + 286, // 95: openshell.v1.ProviderMutationReceipt.persisted_time:type_name -> google.protobuf.Timestamp + 4, // 96: openshell.v1.ProviderReadinessObservation.reason:type_name -> openshell.v1.ProviderReadinessReason + 82, // 97: openshell.v1.ProviderReadinessStatus.receipt:type_name -> openshell.v1.ProviderMutationReceipt + 3, // 98: openshell.v1.ProviderReadinessStatus.state:type_name -> openshell.v1.ProviderReadinessState + 4, // 99: openshell.v1.ProviderReadinessStatus.reason:type_name -> openshell.v1.ProviderReadinessReason + 83, // 100: openshell.v1.ProviderReadinessStatus.observed:type_name -> openshell.v1.ProviderReadinessObservation + 286, // 101: openshell.v1.ProviderReadinessStatus.observed_time:type_name -> google.protobuf.Timestamp + 286, // 102: openshell.v1.ProviderReadinessStatus.evaluated_time:type_name -> google.protobuf.Timestamp + 81, // 103: openshell.v1.ProviderReadinessStatus.operation:type_name -> openshell.v1.ConfigUpdateOperation + 291, // 104: openshell.v1.GetSandboxProviderStatusRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 84, // 105: openshell.v1.GetSandboxProviderStatusResponse.status:type_name -> openshell.v1.ProviderReadinessStatus + 83, // 106: openshell.v1.ReportProviderReadinessRequest.observation:type_name -> openshell.v1.ProviderReadinessObservation + 290, // 107: openshell.v1.ReportProviderReadinessResponse.report_interval:type_name -> google.protobuf.Duration + 290, // 108: openshell.v1.ReportProviderReadinessResponse.observation_ttl:type_name -> google.protobuf.Duration + 17, // 109: openshell.v1.DeleteSandboxResponse.outcome:type_name -> openshell.v1.DeletionOutcome + 291, // 110: openshell.v1.CreateSshSessionRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 286, // 111: openshell.v1.CreateSshSessionResponse.expiration_time:type_name -> google.protobuf.Timestamp + 291, // 112: openshell.v1.ExposeServiceRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 19, // 113: openshell.v1.ExposeServiceRequest.authorization_mode:type_name -> openshell.v1.ServiceAuthorizationMode + 291, // 114: openshell.v1.GetServiceRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 291, // 115: openshell.v1.ListServicesRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 99, // 116: openshell.v1.ListServicesResponse.services:type_name -> openshell.v1.ServiceEndpointResponse + 291, // 117: openshell.v1.DeleteServiceRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 17, // 118: openshell.v1.DeleteServiceResponse.outcome:type_name -> openshell.v1.DeletionOutcome + 287, // 119: openshell.v1.ServiceEndpoint.metadata:type_name -> openshell.datamodel.v1.ObjectMeta + 19, // 120: openshell.v1.ServiceEndpoint.authorization_mode:type_name -> openshell.v1.ServiceAuthorizationMode + 98, // 121: openshell.v1.ServiceEndpointResponse.endpoint:type_name -> openshell.v1.ServiceEndpoint + 17, // 122: openshell.v1.RevokeSshSessionResponse.outcome:type_name -> openshell.v1.DeletionOutcome + 291, // 123: openshell.v1.ExecSandboxRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 271, // 124: openshell.v1.ExecSandboxRequest.environment:type_name -> openshell.v1.ExecSandboxRequest.EnvironmentEntry + 290, // 125: openshell.v1.ExecSandboxRequest.execution_timeout:type_name -> google.protobuf.Duration + 103, // 126: openshell.v1.ExecSandboxEvent.stdout:type_name -> openshell.v1.ExecSandboxStdout + 104, // 127: openshell.v1.ExecSandboxEvent.stderr:type_name -> openshell.v1.ExecSandboxStderr + 105, // 128: openshell.v1.ExecSandboxEvent.exit:type_name -> openshell.v1.ExecSandboxExit + 203, // 129: openshell.v1.TcpForwardInit.ssh:type_name -> openshell.v1.SshRelayTarget + 204, // 130: openshell.v1.TcpForwardInit.tcp:type_name -> openshell.v1.TcpRelayTarget + 107, // 131: openshell.v1.TcpForwardFrame.init:type_name -> openshell.v1.TcpForwardInit + 102, // 132: openshell.v1.ExecSandboxInput.start:type_name -> openshell.v1.ExecSandboxRequest + 110, // 133: openshell.v1.ExecSandboxInput.resize:type_name -> openshell.v1.ExecSandboxWindowResize + 287, // 134: openshell.v1.SshSession.metadata:type_name -> openshell.datamodel.v1.ObjectMeta + 286, // 135: openshell.v1.SshSession.expiration_time:type_name -> google.protobuf.Timestamp + 291, // 136: openshell.v1.WatchSandboxRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 286, // 137: openshell.v1.WatchSandboxRequest.since_time:type_name -> google.protobuf.Timestamp + 38, // 138: openshell.v1.SandboxStreamEvent.sandbox:type_name -> openshell.v1.Sandbox + 114, // 139: openshell.v1.SandboxStreamEvent.log:type_name -> openshell.v1.SandboxLogLine + 53, // 140: openshell.v1.SandboxStreamEvent.event:type_name -> openshell.v1.PlatformEvent + 115, // 141: openshell.v1.SandboxStreamEvent.warning:type_name -> openshell.v1.SandboxStreamWarning + 216, // 142: openshell.v1.SandboxStreamEvent.draft_policy_update:type_name -> openshell.v1.DraftPolicyUpdate + 286, // 143: openshell.v1.SandboxLogLine.event_time:type_name -> google.protobuf.Timestamp + 272, // 144: openshell.v1.SandboxLogLine.fields:type_name -> openshell.v1.SandboxLogLine.FieldsEntry + 291, // 145: openshell.v1.CreateProviderRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 292, // 146: openshell.v1.CreateProviderRequest.provider:type_name -> openshell.datamodel.v1.Provider + 291, // 147: openshell.v1.GetProviderRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 291, // 148: openshell.v1.GetProviderCredentialsRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 290, // 149: openshell.v1.GetProviderCredentialsRequest.minimum_remaining_lifetime:type_name -> google.protobuf.Duration + 286, // 150: openshell.v1.ProviderCredentialValue.expiration_time:type_name -> google.protobuf.Timestamp + 273, // 151: openshell.v1.GetProviderCredentialsResponse.credentials:type_name -> openshell.v1.GetProviderCredentialsResponse.CredentialsEntry + 291, // 152: openshell.v1.ListProvidersRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 291, // 153: openshell.v1.UpdateProviderRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 292, // 154: openshell.v1.UpdateProviderRequest.provider:type_name -> openshell.datamodel.v1.Provider + 274, // 155: openshell.v1.UpdateProviderRequest.credential_expiration_times:type_name -> openshell.v1.UpdateProviderRequest.CredentialExpirationTimesEntry + 291, // 156: openshell.v1.DeleteProviderRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 292, // 157: openshell.v1.ProviderResponse.provider:type_name -> openshell.datamodel.v1.Provider + 82, // 158: openshell.v1.ProviderResponse.target_receipts:type_name -> openshell.v1.ProviderMutationReceipt + 292, // 159: openshell.v1.ListProvidersResponse.providers:type_name -> openshell.datamodel.v1.Provider + 291, // 160: openshell.v1.ListProviderProfilesRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 291, // 161: openshell.v1.GetProviderProfileRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 147, // 162: openshell.v1.ProviderProfileImportItem.profile:type_name -> openshell.v1.ProviderProfile + 290, // 163: openshell.v1.ProviderCredentialTokenGrant.cache_ttl:type_name -> google.protobuf.Duration + 130, // 164: openshell.v1.ProviderCredentialTokenGrant.audience_overrides:type_name -> openshell.v1.ProviderCredentialTokenGrantAudienceOverride + 8, // 165: openshell.v1.ProviderCredentialTokenGrant.grant_type:type_name -> openshell.v1.ProviderCredentialTokenGrantType + 131, // 166: openshell.v1.ProviderCredentialTokenGrant.subject_token:type_name -> openshell.v1.ProviderCredentialTokenGrantSubjectToken + 136, // 167: openshell.v1.ProviderProfileCredential.refresh:type_name -> openshell.v1.ProviderCredentialRefresh + 132, // 168: openshell.v1.ProviderProfileCredential.token_grant:type_name -> openshell.v1.ProviderCredentialTokenGrant + 9, // 169: openshell.v1.ProviderCredentialRefresh.strategy:type_name -> openshell.v1.ProviderCredentialRefreshStrategy + 290, // 170: openshell.v1.ProviderCredentialRefresh.refresh_before:type_name -> google.protobuf.Duration + 290, // 171: openshell.v1.ProviderCredentialRefresh.max_lifetime:type_name -> google.protobuf.Duration + 134, // 172: openshell.v1.ProviderCredentialRefresh.material:type_name -> openshell.v1.ProviderCredentialRefreshMaterial + 135, // 173: openshell.v1.ProviderCredentialRefresh.additional_outputs:type_name -> openshell.v1.ProviderCredentialRefreshOutput + 9, // 174: openshell.v1.ProviderCredentialRefreshStatus.strategy:type_name -> openshell.v1.ProviderCredentialRefreshStrategy + 286, // 175: openshell.v1.ProviderCredentialRefreshStatus.expiration_time:type_name -> google.protobuf.Timestamp + 286, // 176: openshell.v1.ProviderCredentialRefreshStatus.next_refresh_time:type_name -> google.protobuf.Timestamp + 286, // 177: openshell.v1.ProviderCredentialRefreshStatus.last_refresh_time:type_name -> google.protobuf.Timestamp + 15, // 178: openshell.v1.ProviderCredentialRefreshStatus.recovery_action:type_name -> openshell.v1.ProviderCredentialRefreshRecoveryAction + 286, // 179: openshell.v1.ProviderCredentialRefreshStatus.last_error_time:type_name -> google.protobuf.Timestamp + 291, // 180: openshell.v1.GetProviderRefreshStatusRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 137, // 181: openshell.v1.GetProviderRefreshStatusResponse.credentials:type_name -> openshell.v1.ProviderCredentialRefreshStatus + 291, // 182: openshell.v1.ConfigureProviderRefreshRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 9, // 183: openshell.v1.ConfigureProviderRefreshRequest.strategy:type_name -> openshell.v1.ProviderCredentialRefreshStrategy + 275, // 184: openshell.v1.ConfigureProviderRefreshRequest.material:type_name -> openshell.v1.ConfigureProviderRefreshRequest.MaterialEntry + 286, // 185: openshell.v1.ConfigureProviderRefreshRequest.expiration_time:type_name -> google.protobuf.Timestamp + 137, // 186: openshell.v1.ConfigureProviderRefreshResponse.status:type_name -> openshell.v1.ProviderCredentialRefreshStatus + 291, // 187: openshell.v1.RotateProviderCredentialRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 137, // 188: openshell.v1.RotateProviderCredentialResponse.status:type_name -> openshell.v1.ProviderCredentialRefreshStatus + 291, // 189: openshell.v1.DeleteProviderRefreshRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 17, // 190: openshell.v1.DeleteProviderRefreshResponse.outcome:type_name -> openshell.v1.DeletionOutcome + 10, // 191: openshell.v1.ProviderProfile.category:type_name -> openshell.v1.ProviderProfileCategory + 133, // 192: openshell.v1.ProviderProfile.credentials:type_name -> openshell.v1.ProviderProfileCredential + 294, // 193: openshell.v1.ProviderProfile.endpoints:type_name -> openshell.sandbox.v1.NetworkEndpoint + 295, // 194: openshell.v1.ProviderProfile.binaries:type_name -> openshell.sandbox.v1.NetworkBinary + 138, // 195: openshell.v1.ProviderProfile.discovery:type_name -> openshell.v1.ProviderProfileDiscovery + 276, // 196: openshell.v1.ProviderProfile.annotations:type_name -> openshell.v1.ProviderProfile.AnnotationsEntry + 148, // 197: openshell.v1.ProviderProfile.files:type_name -> openshell.v1.ProviderProfileFile + 147, // 198: openshell.v1.ProviderProfileResponse.profile:type_name -> openshell.v1.ProviderProfile + 147, // 199: openshell.v1.ListProviderProfilesResponse.profiles:type_name -> openshell.v1.ProviderProfile + 291, // 200: openshell.v1.ImportProviderProfilesRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 128, // 201: openshell.v1.ImportProviderProfilesRequest.profiles:type_name -> openshell.v1.ProviderProfileImportItem + 129, // 202: openshell.v1.ImportProviderProfilesResponse.diagnostics:type_name -> openshell.v1.ProviderProfileDiagnostic + 147, // 203: openshell.v1.ImportProviderProfilesResponse.profiles:type_name -> openshell.v1.ProviderProfile + 291, // 204: openshell.v1.UpdateProviderProfilesRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 128, // 205: openshell.v1.UpdateProviderProfilesRequest.profile:type_name -> openshell.v1.ProviderProfileImportItem + 129, // 206: openshell.v1.UpdateProviderProfilesResponse.diagnostics:type_name -> openshell.v1.ProviderProfileDiagnostic + 147, // 207: openshell.v1.UpdateProviderProfilesResponse.profile:type_name -> openshell.v1.ProviderProfile + 291, // 208: openshell.v1.LintProviderProfilesRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 128, // 209: openshell.v1.LintProviderProfilesRequest.profiles:type_name -> openshell.v1.ProviderProfileImportItem + 129, // 210: openshell.v1.LintProviderProfilesResponse.diagnostics:type_name -> openshell.v1.ProviderProfileDiagnostic + 17, // 211: openshell.v1.DeleteProviderResponse.outcome:type_name -> openshell.v1.DeletionOutcome + 291, // 212: openshell.v1.DeleteProviderProfileRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 17, // 213: openshell.v1.DeleteProviderProfileResponse.outcome:type_name -> openshell.v1.DeletionOutcome + 161, // 214: openshell.v1.StaticCredentialBinding.endpoints:type_name -> openshell.v1.StaticCredentialEndpointBinding + 277, // 215: openshell.v1.GetSandboxProviderEnvironmentResponse.environment:type_name -> openshell.v1.GetSandboxProviderEnvironmentResponse.EnvironmentEntry + 278, // 216: openshell.v1.GetSandboxProviderEnvironmentResponse.credential_expiration_times:type_name -> openshell.v1.GetSandboxProviderEnvironmentResponse.CredentialExpirationTimesEntry + 279, // 217: openshell.v1.GetSandboxProviderEnvironmentResponse.dynamic_credentials:type_name -> openshell.v1.GetSandboxProviderEnvironmentResponse.DynamicCredentialsEntry + 280, // 218: openshell.v1.GetSandboxProviderEnvironmentResponse.static_credential_bindings:type_name -> openshell.v1.GetSandboxProviderEnvironmentResponse.StaticCredentialBindingsEntry + 4, // 219: openshell.v1.GetSandboxProviderEnvironmentResponse.readiness_reason:type_name -> openshell.v1.ProviderReadinessReason + 281, // 220: openshell.v1.GetSandboxProviderEnvironmentResponse.files:type_name -> openshell.v1.GetSandboxProviderEnvironmentResponse.FilesEntry + 290, // 221: openshell.v1.ExchangeProviderSubjectTokenResponse.expires_after:type_name -> google.protobuf.Duration + 291, // 222: openshell.v1.UpdateConfigRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 288, // 223: openshell.v1.UpdateConfigRequest.policy:type_name -> openshell.sandbox.v1.SandboxPolicy + 296, // 224: openshell.v1.UpdateConfigRequest.setting_value:type_name -> openshell.sandbox.v1.SettingValue + 167, // 225: openshell.v1.UpdateConfigRequest.merge_operations:type_name -> openshell.v1.PolicyMergeOperation + 282, // 226: openshell.v1.UpdateConfigRequest.annotations:type_name -> openshell.v1.UpdateConfigRequest.AnnotationsEntry + 168, // 227: openshell.v1.PolicyMergeOperation.add_rule:type_name -> openshell.v1.AddNetworkRule + 169, // 228: openshell.v1.PolicyMergeOperation.remove_endpoint:type_name -> openshell.v1.RemoveNetworkEndpoint + 170, // 229: openshell.v1.PolicyMergeOperation.remove_rule:type_name -> openshell.v1.RemoveNetworkRule + 172, // 230: openshell.v1.PolicyMergeOperation.add_deny_rules:type_name -> openshell.v1.AddDenyRules + 173, // 231: openshell.v1.PolicyMergeOperation.add_allow_rules:type_name -> openshell.v1.AddAllowRules + 174, // 232: openshell.v1.PolicyMergeOperation.remove_binary:type_name -> openshell.v1.RemoveNetworkBinary + 297, // 233: openshell.v1.AddNetworkRule.rule:type_name -> openshell.sandbox.v1.NetworkPolicyRule + 295, // 234: openshell.v1.L7RuleTarget.binaries:type_name -> openshell.sandbox.v1.NetworkBinary + 298, // 235: openshell.v1.AddDenyRules.deny_rules:type_name -> openshell.sandbox.v1.L7DenyRule + 171, // 236: openshell.v1.AddDenyRules.target:type_name -> openshell.v1.L7RuleTarget + 299, // 237: openshell.v1.AddAllowRules.rules:type_name -> openshell.sandbox.v1.L7Rule + 171, // 238: openshell.v1.AddAllowRules.target:type_name -> openshell.v1.L7RuleTarget + 283, // 239: openshell.v1.UpdateConfigResponse.annotations:type_name -> openshell.v1.UpdateConfigResponse.AnnotationsEntry + 291, // 240: openshell.v1.GetSandboxPolicyStatusRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 185, // 241: openshell.v1.GetSandboxPolicyStatusResponse.revision:type_name -> openshell.v1.SandboxPolicyRevision + 291, // 242: openshell.v1.ListSandboxPoliciesRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 185, // 243: openshell.v1.ListSandboxPoliciesResponse.revisions:type_name -> openshell.v1.SandboxPolicyRevision + 12, // 244: openshell.v1.ReportPolicyStatusRequest.status:type_name -> openshell.v1.PolicyStatus + 11, // 245: openshell.v1.SandboxConfigurationAdmission.state:type_name -> openshell.v1.ConfigurationAdmissionState + 182, // 246: openshell.v1.ReportSandboxConfigurationRequest.admission:type_name -> openshell.v1.SandboxConfigurationAdmission + 12, // 247: openshell.v1.SandboxPolicyRevision.status:type_name -> openshell.v1.PolicyStatus + 286, // 248: openshell.v1.SandboxPolicyRevision.created_time:type_name -> google.protobuf.Timestamp + 286, // 249: openshell.v1.SandboxPolicyRevision.loaded_time:type_name -> google.protobuf.Timestamp + 288, // 250: openshell.v1.SandboxPolicyRevision.policy:type_name -> openshell.sandbox.v1.SandboxPolicy + 284, // 251: openshell.v1.SandboxPolicyRevision.provenance:type_name -> openshell.v1.SandboxPolicyRevision.ProvenanceEntry + 291, // 252: openshell.v1.GetSandboxLogsRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 286, // 253: openshell.v1.GetSandboxLogsRequest.since_time:type_name -> google.protobuf.Timestamp + 114, // 254: openshell.v1.PushSandboxLogsRequest.logs:type_name -> openshell.v1.SandboxLogLine + 114, // 255: openshell.v1.GetSandboxLogsResponse.logs:type_name -> openshell.v1.SandboxLogLine + 192, // 256: openshell.v1.SupervisorMessage.hello:type_name -> openshell.v1.SupervisorHello + 196, // 257: openshell.v1.SupervisorMessage.heartbeat:type_name -> openshell.v1.SupervisorHeartbeat + 209, // 258: openshell.v1.SupervisorMessage.relay_open_result:type_name -> openshell.v1.RelayOpenResult + 210, // 259: openshell.v1.SupervisorMessage.relay_close:type_name -> openshell.v1.RelayClose + 193, // 260: openshell.v1.GatewayMessage.session_accepted:type_name -> openshell.v1.SessionAccepted + 194, // 261: openshell.v1.GatewayMessage.session_rejected:type_name -> openshell.v1.SessionRejected + 197, // 262: openshell.v1.GatewayMessage.heartbeat:type_name -> openshell.v1.GatewayHeartbeat + 202, // 263: openshell.v1.GatewayMessage.relay_open:type_name -> openshell.v1.RelayOpen + 210, // 264: openshell.v1.GatewayMessage.relay_close:type_name -> openshell.v1.RelayClose + 195, // 265: openshell.v1.GatewayMessage.session_redirect:type_name -> openshell.v1.SessionRedirect + 290, // 266: openshell.v1.SessionAccepted.heartbeat_interval:type_name -> google.protobuf.Duration + 203, // 267: openshell.v1.RelayOpen.ssh:type_name -> openshell.v1.SshRelayTarget + 204, // 268: openshell.v1.RelayOpen.tcp:type_name -> openshell.v1.TcpRelayTarget + 205, // 269: openshell.v1.RelayFrame.init:type_name -> openshell.v1.RelayInit + 202, // 270: openshell.v1.PeerRelayInit.relay_open:type_name -> openshell.v1.RelayOpen + 207, // 271: openshell.v1.PeerRelayFrame.init:type_name -> openshell.v1.PeerRelayInit + 286, // 272: openshell.v1.DenialSummary.first_seen_time:type_name -> google.protobuf.Timestamp + 286, // 273: openshell.v1.DenialSummary.last_seen_time:type_name -> google.protobuf.Timestamp + 211, // 274: openshell.v1.DenialSummary.l7_request_samples:type_name -> openshell.v1.L7RequestSample + 213, // 275: openshell.v1.NetworkActivitySummary.denials_by_group:type_name -> openshell.v1.DenialGroupCount + 297, // 276: openshell.v1.PolicyChunk.proposed_rule:type_name -> openshell.sandbox.v1.NetworkPolicyRule + 286, // 277: openshell.v1.PolicyChunk.created_time:type_name -> google.protobuf.Timestamp + 286, // 278: openshell.v1.PolicyChunk.decided_time:type_name -> google.protobuf.Timestamp + 286, // 279: openshell.v1.PolicyChunk.first_seen_time:type_name -> google.protobuf.Timestamp + 286, // 280: openshell.v1.PolicyChunk.last_seen_time:type_name -> google.protobuf.Timestamp + 288, // 281: openshell.v1.PolicyChunk.current_effective_policy:type_name -> openshell.sandbox.v1.SandboxPolicy + 288, // 282: openshell.v1.PolicyChunk.candidate_effective_policy:type_name -> openshell.sandbox.v1.SandboxPolicy + 291, // 283: openshell.v1.SubmitPolicyAnalysisRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 212, // 284: openshell.v1.SubmitPolicyAnalysisRequest.summaries:type_name -> openshell.v1.DenialSummary + 215, // 285: openshell.v1.SubmitPolicyAnalysisRequest.proposed_chunks:type_name -> openshell.v1.PolicyChunk + 214, // 286: openshell.v1.SubmitPolicyAnalysisRequest.network_activity_summaries:type_name -> openshell.v1.NetworkActivitySummary + 291, // 287: openshell.v1.GetDraftPolicyRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 215, // 288: openshell.v1.GetDraftPolicyResponse.chunks:type_name -> openshell.v1.PolicyChunk + 286, // 289: openshell.v1.GetDraftPolicyResponse.last_analyzed_time:type_name -> google.protobuf.Timestamp + 291, // 290: openshell.v1.ApproveDraftChunkRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 291, // 291: openshell.v1.RejectDraftChunkRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 291, // 292: openshell.v1.ApproveAllDraftChunksRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 225, // 293: openshell.v1.ApproveAllDraftChunksRequest.approvals:type_name -> openshell.v1.DraftChunkApproval + 291, // 294: openshell.v1.EditDraftChunkRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 297, // 295: openshell.v1.EditDraftChunkRequest.proposed_rule:type_name -> openshell.sandbox.v1.NetworkPolicyRule + 291, // 296: openshell.v1.UndoDraftChunkRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 291, // 297: openshell.v1.ClearDraftChunksRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 291, // 298: openshell.v1.GetDraftHistoryRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 286, // 299: openshell.v1.DraftHistoryEntry.event_time:type_name -> google.protobuf.Timestamp + 235, // 300: openshell.v1.GetDraftHistoryResponse.entries:type_name -> openshell.v1.DraftHistoryEntry + 285, // 301: openshell.v1.CreateWorkspaceRequest.labels:type_name -> openshell.v1.CreateWorkspaceRequest.LabelsEntry + 300, // 302: openshell.v1.CreateWorkspaceResponse.workspace:type_name -> openshell.datamodel.v1.Workspace + 300, // 303: openshell.v1.GetWorkspaceResponse.workspace:type_name -> openshell.datamodel.v1.Workspace + 300, // 304: openshell.v1.ListWorkspacesResponse.workspaces:type_name -> openshell.datamodel.v1.Workspace + 17, // 305: openshell.v1.DeleteWorkspaceResponse.outcome:type_name -> openshell.v1.DeletionOutcome + 287, // 306: openshell.v1.WorkspaceMember.metadata:type_name -> openshell.datamodel.v1.ObjectMeta + 14, // 307: openshell.v1.WorkspaceMember.role:type_name -> openshell.v1.WorkspaceRole + 291, // 308: openshell.v1.AddWorkspaceMemberRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 14, // 309: openshell.v1.AddWorkspaceMemberRequest.role:type_name -> openshell.v1.WorkspaceRole + 245, // 310: openshell.v1.AddWorkspaceMemberResponse.member:type_name -> openshell.v1.WorkspaceMember + 291, // 311: openshell.v1.RemoveWorkspaceMemberRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 17, // 312: openshell.v1.RemoveWorkspaceMemberResponse.outcome:type_name -> openshell.v1.DeletionOutcome + 291, // 313: openshell.v1.ListWorkspaceMembersRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 245, // 314: openshell.v1.ListWorkspaceMembersResponse.members:type_name -> openshell.v1.WorkspaceMember + 286, // 315: openshell.v1.ExtensionServiceCredential.expiration_time:type_name -> google.protobuf.Timestamp + 18, // 316: openshell.v1.EndpointObservation.result:type_name -> openshell.v1.EndpointResult + 261, // 317: openshell.v1.EndpointObservation.failure:type_name -> openshell.v1.EndpointFailure + 253, // 318: openshell.v1.ReportEndpointStatusRequest.observations:type_name -> openshell.v1.EndpointObservation + 255, // 319: openshell.v1.ReportEndpointStatusRequest.token_grant_status:type_name -> openshell.v1.TokenGrantStatus + 256, // 320: openshell.v1.TokenGrantStatus.last_failure:type_name -> openshell.v1.TokenGrantFailureObservation + 261, // 321: openshell.v1.TokenGrantFailureObservation.failure:type_name -> openshell.v1.EndpointFailure + 18, // 322: openshell.v1.EndpointStatus.last_result:type_name -> openshell.v1.EndpointResult + 286, // 323: openshell.v1.EndpointStatus.last_reported_time:type_name -> google.protobuf.Timestamp + 261, // 324: openshell.v1.EndpointStatus.last_failure:type_name -> openshell.v1.EndpointFailure + 286, // 325: openshell.v1.SandboxProvisioning.configuration_change_time:type_name -> google.protobuf.Timestamp + 286, // 326: openshell.v1.SandboxProvisioning.first_rejection_time:type_name -> google.protobuf.Timestamp + 286, // 327: openshell.v1.SandboxProvisioning.deadline:type_name -> google.protobuf.Timestamp + 286, // 328: openshell.v1.SandboxProvisioning.timeout_time:type_name -> google.protobuf.Timestamp + 286, // 329: openshell.v1.SandboxProvisioning.cleanup_completed_time:type_name -> google.protobuf.Timestamp + 286, // 330: openshell.v1.SandboxProvisioning.cleanup_retry_time:type_name -> google.protobuf.Timestamp + 286, // 331: openshell.v1.SandboxProvisioning.attachment_change_time:type_name -> google.protobuf.Timestamp + 286, // 332: openshell.v1.SandboxProvisioning.preparation_deadline:type_name -> google.protobuf.Timestamp + 286, // 333: openshell.v1.SandboxProvisioning.admission_start_time:type_name -> google.protobuf.Timestamp + 19, // 334: openshell.v1.SandboxServiceExposure.authorization_mode:type_name -> openshell.v1.ServiceAuthorizationMode + 20, // 335: openshell.v1.EndpointFailure.domain:type_name -> openshell.v1.EndpointFailureDomain + 15, // 336: openshell.v1.EndpointFailure.recovery_action:type_name -> openshell.v1.ProviderCredentialRefreshRecoveryAction + 119, // 337: openshell.v1.GetProviderCredentialsResponse.CredentialsEntry.value:type_name -> openshell.v1.ProviderCredentialValue + 286, // 338: openshell.v1.UpdateProviderRequest.CredentialExpirationTimesEntry.value:type_name -> google.protobuf.Timestamp + 286, // 339: openshell.v1.GetSandboxProviderEnvironmentResponse.CredentialExpirationTimesEntry.value:type_name -> google.protobuf.Timestamp + 133, // 340: openshell.v1.GetSandboxProviderEnvironmentResponse.DynamicCredentialsEntry.value:type_name -> openshell.v1.ProviderProfileCredential + 162, // 341: openshell.v1.GetSandboxProviderEnvironmentResponse.StaticCredentialBindingsEntry.value:type_name -> openshell.v1.StaticCredentialBinding + 25, // 342: openshell.v1.OpenShell.Health:input_type -> openshell.v1.HealthRequest + 27, // 343: openshell.v1.OpenShell.GetCurrentUser:input_type -> openshell.v1.GetCurrentUserRequest + 29, // 344: openshell.v1.OpenShell.GetGatewayInfo:input_type -> openshell.v1.GetGatewayInfoRequest + 54, // 345: openshell.v1.OpenShell.CreateSandbox:input_type -> openshell.v1.CreateSandboxRequest + 55, // 346: openshell.v1.OpenShell.UpdateSandbox:input_type -> openshell.v1.UpdateSandboxRequest + 63, // 347: openshell.v1.OpenShell.BeginRootfsTarStaging:input_type -> openshell.v1.BeginRootfsTarStagingRequest + 65, // 348: openshell.v1.OpenShell.GetSandbox:input_type -> openshell.v1.GetSandboxRequest + 66, // 349: openshell.v1.OpenShell.ListSandboxes:input_type -> openshell.v1.ListSandboxesRequest + 56, // 350: openshell.v1.OpenShell.CreateSandboxTemplate:input_type -> openshell.v1.CreateSandboxTemplateRequest + 57, // 351: openshell.v1.OpenShell.GetSandboxTemplate:input_type -> openshell.v1.GetSandboxTemplateRequest + 58, // 352: openshell.v1.OpenShell.ListSandboxTemplates:input_type -> openshell.v1.ListSandboxTemplatesRequest + 59, // 353: openshell.v1.OpenShell.DeleteSandboxTemplate:input_type -> openshell.v1.DeleteSandboxTemplateRequest + 67, // 354: openshell.v1.OpenShell.ListSandboxProviders:input_type -> openshell.v1.ListSandboxProvidersRequest + 68, // 355: openshell.v1.OpenShell.AttachSandboxProvider:input_type -> openshell.v1.AttachSandboxProviderRequest + 69, // 356: openshell.v1.OpenShell.DetachSandboxProvider:input_type -> openshell.v1.DetachSandboxProviderRequest + 85, // 357: openshell.v1.OpenShell.GetSandboxProviderStatus:input_type -> openshell.v1.GetSandboxProviderStatusRequest + 70, // 358: openshell.v1.OpenShell.DeleteSandbox:input_type -> openshell.v1.DeleteSandboxRequest + 71, // 359: openshell.v1.OpenShell.StopSandbox:input_type -> openshell.v1.StopSandboxRequest + 72, // 360: openshell.v1.OpenShell.StartSandbox:input_type -> openshell.v1.StartSandboxRequest + 90, // 361: openshell.v1.OpenShell.CreateSshSession:input_type -> openshell.v1.CreateSshSessionRequest + 92, // 362: openshell.v1.OpenShell.ExposeService:input_type -> openshell.v1.ExposeServiceRequest + 93, // 363: openshell.v1.OpenShell.GetService:input_type -> openshell.v1.GetServiceRequest + 94, // 364: openshell.v1.OpenShell.ListServices:input_type -> openshell.v1.ListServicesRequest + 96, // 365: openshell.v1.OpenShell.DeleteService:input_type -> openshell.v1.DeleteServiceRequest + 100, // 366: openshell.v1.OpenShell.RevokeSshSession:input_type -> openshell.v1.RevokeSshSessionRequest + 102, // 367: openshell.v1.OpenShell.ExecSandbox:input_type -> openshell.v1.ExecSandboxRequest + 108, // 368: openshell.v1.OpenShell.ForwardTcp:input_type -> openshell.v1.TcpForwardFrame + 109, // 369: openshell.v1.OpenShell.ExecSandboxInteractive:input_type -> openshell.v1.ExecSandboxInput + 116, // 370: openshell.v1.OpenShell.CreateProvider:input_type -> openshell.v1.CreateProviderRequest + 117, // 371: openshell.v1.OpenShell.GetProvider:input_type -> openshell.v1.GetProviderRequest + 118, // 372: openshell.v1.OpenShell.GetProviderCredentials:input_type -> openshell.v1.GetProviderCredentialsRequest + 121, // 373: openshell.v1.OpenShell.ListProviders:input_type -> openshell.v1.ListProvidersRequest + 126, // 374: openshell.v1.OpenShell.ListProviderProfiles:input_type -> openshell.v1.ListProviderProfilesRequest + 127, // 375: openshell.v1.OpenShell.GetProviderProfile:input_type -> openshell.v1.GetProviderProfileRequest + 151, // 376: openshell.v1.OpenShell.ImportProviderProfiles:input_type -> openshell.v1.ImportProviderProfilesRequest + 153, // 377: openshell.v1.OpenShell.UpdateProviderProfiles:input_type -> openshell.v1.UpdateProviderProfilesRequest + 155, // 378: openshell.v1.OpenShell.LintProviderProfiles:input_type -> openshell.v1.LintProviderProfilesRequest + 122, // 379: openshell.v1.OpenShell.UpdateProvider:input_type -> openshell.v1.UpdateProviderRequest + 139, // 380: openshell.v1.OpenShell.GetProviderRefreshStatus:input_type -> openshell.v1.GetProviderRefreshStatusRequest + 141, // 381: openshell.v1.OpenShell.ConfigureProviderRefresh:input_type -> openshell.v1.ConfigureProviderRefreshRequest + 143, // 382: openshell.v1.OpenShell.RotateProviderCredential:input_type -> openshell.v1.RotateProviderCredentialRequest + 145, // 383: openshell.v1.OpenShell.DeleteProviderRefresh:input_type -> openshell.v1.DeleteProviderRefreshRequest + 123, // 384: openshell.v1.OpenShell.DeleteProvider:input_type -> openshell.v1.DeleteProviderRequest + 158, // 385: openshell.v1.OpenShell.DeleteProviderProfile:input_type -> openshell.v1.DeleteProviderProfileRequest + 301, // 386: openshell.v1.OpenShell.GetSandboxConfig:input_type -> openshell.sandbox.v1.GetSandboxConfigRequest + 302, // 387: openshell.v1.OpenShell.GetGatewayConfig:input_type -> openshell.sandbox.v1.GetGatewayConfigRequest + 166, // 388: openshell.v1.OpenShell.UpdateConfig:input_type -> openshell.v1.UpdateConfigRequest + 176, // 389: openshell.v1.OpenShell.GetSandboxPolicyStatus:input_type -> openshell.v1.GetSandboxPolicyStatusRequest + 178, // 390: openshell.v1.OpenShell.ListSandboxPolicies:input_type -> openshell.v1.ListSandboxPoliciesRequest + 180, // 391: openshell.v1.OpenShell.ReportPolicyStatus:input_type -> openshell.v1.ReportPolicyStatusRequest + 254, // 392: openshell.v1.OpenShell.ReportEndpointStatus:input_type -> openshell.v1.ReportEndpointStatusRequest + 87, // 393: openshell.v1.OpenShell.ReportProviderReadiness:input_type -> openshell.v1.ReportProviderReadinessRequest + 183, // 394: openshell.v1.OpenShell.ReportSandboxConfiguration:input_type -> openshell.v1.ReportSandboxConfigurationRequest + 160, // 395: openshell.v1.OpenShell.GetSandboxProviderEnvironment:input_type -> openshell.v1.GetSandboxProviderEnvironmentRequest + 164, // 396: openshell.v1.OpenShell.ExchangeProviderSubjectToken:input_type -> openshell.v1.ExchangeProviderSubjectTokenRequest + 186, // 397: openshell.v1.OpenShell.GetSandboxLogs:input_type -> openshell.v1.GetSandboxLogsRequest + 187, // 398: openshell.v1.OpenShell.PushSandboxLogs:input_type -> openshell.v1.PushSandboxLogsRequest + 190, // 399: openshell.v1.OpenShell.ConnectSupervisor:input_type -> openshell.v1.SupervisorMessage + 198, // 400: openshell.v1.OpenShell.ReportMainProcessExit:input_type -> openshell.v1.ReportMainProcessExitRequest + 200, // 401: openshell.v1.OpenShell.FinalizeMainProcessExit:input_type -> openshell.v1.FinalizeMainProcessExitRequest + 206, // 402: openshell.v1.OpenShell.RelayStream:input_type -> openshell.v1.RelayFrame + 208, // 403: openshell.v1.OpenShell.PeerRelay:input_type -> openshell.v1.PeerRelayFrame + 87, // 404: openshell.v1.OpenShell.PeerReportProviderReadiness:input_type -> openshell.v1.ReportProviderReadinessRequest + 254, // 405: openshell.v1.OpenShell.PeerReportEndpointStatus:input_type -> openshell.v1.ReportEndpointStatusRequest + 85, // 406: openshell.v1.OpenShell.PeerGetSandboxProviderStatus:input_type -> openshell.v1.GetSandboxProviderStatusRequest + 112, // 407: openshell.v1.OpenShell.WatchSandbox:input_type -> openshell.v1.WatchSandboxRequest + 217, // 408: openshell.v1.OpenShell.SubmitPolicyAnalysis:input_type -> openshell.v1.SubmitPolicyAnalysisRequest + 219, // 409: openshell.v1.OpenShell.GetDraftPolicy:input_type -> openshell.v1.GetDraftPolicyRequest + 221, // 410: openshell.v1.OpenShell.ApproveDraftChunk:input_type -> openshell.v1.ApproveDraftChunkRequest + 223, // 411: openshell.v1.OpenShell.RejectDraftChunk:input_type -> openshell.v1.RejectDraftChunkRequest + 226, // 412: openshell.v1.OpenShell.ApproveAllDraftChunks:input_type -> openshell.v1.ApproveAllDraftChunksRequest + 228, // 413: openshell.v1.OpenShell.EditDraftChunk:input_type -> openshell.v1.EditDraftChunkRequest + 230, // 414: openshell.v1.OpenShell.UndoDraftChunk:input_type -> openshell.v1.UndoDraftChunkRequest + 232, // 415: openshell.v1.OpenShell.ClearDraftChunks:input_type -> openshell.v1.ClearDraftChunksRequest + 234, // 416: openshell.v1.OpenShell.GetDraftHistory:input_type -> openshell.v1.GetDraftHistoryRequest + 21, // 417: openshell.v1.OpenShell.IssueSandboxToken:input_type -> openshell.v1.IssueSandboxTokenRequest + 23, // 418: openshell.v1.OpenShell.RefreshSandboxToken:input_type -> openshell.v1.RefreshSandboxTokenRequest + 237, // 419: openshell.v1.OpenShell.CreateWorkspace:input_type -> openshell.v1.CreateWorkspaceRequest + 239, // 420: openshell.v1.OpenShell.GetWorkspace:input_type -> openshell.v1.GetWorkspaceRequest + 241, // 421: openshell.v1.OpenShell.ListWorkspaces:input_type -> openshell.v1.ListWorkspacesRequest + 243, // 422: openshell.v1.OpenShell.DeleteWorkspace:input_type -> openshell.v1.DeleteWorkspaceRequest + 246, // 423: openshell.v1.OpenShell.AddWorkspaceMember:input_type -> openshell.v1.AddWorkspaceMemberRequest + 248, // 424: openshell.v1.OpenShell.RemoveWorkspaceMember:input_type -> openshell.v1.RemoveWorkspaceMemberRequest + 250, // 425: openshell.v1.OpenShell.ListWorkspaceMembers:input_type -> openshell.v1.ListWorkspaceMembersRequest + 26, // 426: openshell.v1.OpenShell.Health:output_type -> openshell.v1.HealthResponse + 28, // 427: openshell.v1.OpenShell.GetCurrentUser:output_type -> openshell.v1.GetCurrentUserResponse + 30, // 428: openshell.v1.OpenShell.GetGatewayInfo:output_type -> openshell.v1.GetGatewayInfoResponse + 73, // 429: openshell.v1.OpenShell.CreateSandbox:output_type -> openshell.v1.SandboxResponse + 73, // 430: openshell.v1.OpenShell.UpdateSandbox:output_type -> openshell.v1.SandboxResponse + 64, // 431: openshell.v1.OpenShell.BeginRootfsTarStaging:output_type -> openshell.v1.BeginRootfsTarStagingResponse + 73, // 432: openshell.v1.OpenShell.GetSandbox:output_type -> openshell.v1.SandboxResponse + 74, // 433: openshell.v1.OpenShell.ListSandboxes:output_type -> openshell.v1.ListSandboxesResponse + 60, // 434: openshell.v1.OpenShell.CreateSandboxTemplate:output_type -> openshell.v1.SandboxTemplateResponse + 60, // 435: openshell.v1.OpenShell.GetSandboxTemplate:output_type -> openshell.v1.SandboxTemplateResponse + 61, // 436: openshell.v1.OpenShell.ListSandboxTemplates:output_type -> openshell.v1.ListSandboxTemplatesResponse + 62, // 437: openshell.v1.OpenShell.DeleteSandboxTemplate:output_type -> openshell.v1.DeleteSandboxTemplateResponse + 75, // 438: openshell.v1.OpenShell.ListSandboxProviders:output_type -> openshell.v1.ListSandboxProvidersResponse + 76, // 439: openshell.v1.OpenShell.AttachSandboxProvider:output_type -> openshell.v1.AttachSandboxProviderResponse + 77, // 440: openshell.v1.OpenShell.DetachSandboxProvider:output_type -> openshell.v1.DetachSandboxProviderResponse + 86, // 441: openshell.v1.OpenShell.GetSandboxProviderStatus:output_type -> openshell.v1.GetSandboxProviderStatusResponse + 89, // 442: openshell.v1.OpenShell.DeleteSandbox:output_type -> openshell.v1.DeleteSandboxResponse + 73, // 443: openshell.v1.OpenShell.StopSandbox:output_type -> openshell.v1.SandboxResponse + 73, // 444: openshell.v1.OpenShell.StartSandbox:output_type -> openshell.v1.SandboxResponse + 91, // 445: openshell.v1.OpenShell.CreateSshSession:output_type -> openshell.v1.CreateSshSessionResponse + 99, // 446: openshell.v1.OpenShell.ExposeService:output_type -> openshell.v1.ServiceEndpointResponse + 99, // 447: openshell.v1.OpenShell.GetService:output_type -> openshell.v1.ServiceEndpointResponse + 95, // 448: openshell.v1.OpenShell.ListServices:output_type -> openshell.v1.ListServicesResponse + 97, // 449: openshell.v1.OpenShell.DeleteService:output_type -> openshell.v1.DeleteServiceResponse + 101, // 450: openshell.v1.OpenShell.RevokeSshSession:output_type -> openshell.v1.RevokeSshSessionResponse + 106, // 451: openshell.v1.OpenShell.ExecSandbox:output_type -> openshell.v1.ExecSandboxEvent + 108, // 452: openshell.v1.OpenShell.ForwardTcp:output_type -> openshell.v1.TcpForwardFrame + 106, // 453: openshell.v1.OpenShell.ExecSandboxInteractive:output_type -> openshell.v1.ExecSandboxEvent + 124, // 454: openshell.v1.OpenShell.CreateProvider:output_type -> openshell.v1.ProviderResponse + 124, // 455: openshell.v1.OpenShell.GetProvider:output_type -> openshell.v1.ProviderResponse + 120, // 456: openshell.v1.OpenShell.GetProviderCredentials:output_type -> openshell.v1.GetProviderCredentialsResponse + 125, // 457: openshell.v1.OpenShell.ListProviders:output_type -> openshell.v1.ListProvidersResponse + 150, // 458: openshell.v1.OpenShell.ListProviderProfiles:output_type -> openshell.v1.ListProviderProfilesResponse + 149, // 459: openshell.v1.OpenShell.GetProviderProfile:output_type -> openshell.v1.ProviderProfileResponse + 152, // 460: openshell.v1.OpenShell.ImportProviderProfiles:output_type -> openshell.v1.ImportProviderProfilesResponse + 154, // 461: openshell.v1.OpenShell.UpdateProviderProfiles:output_type -> openshell.v1.UpdateProviderProfilesResponse + 156, // 462: openshell.v1.OpenShell.LintProviderProfiles:output_type -> openshell.v1.LintProviderProfilesResponse + 124, // 463: openshell.v1.OpenShell.UpdateProvider:output_type -> openshell.v1.ProviderResponse + 140, // 464: openshell.v1.OpenShell.GetProviderRefreshStatus:output_type -> openshell.v1.GetProviderRefreshStatusResponse + 142, // 465: openshell.v1.OpenShell.ConfigureProviderRefresh:output_type -> openshell.v1.ConfigureProviderRefreshResponse + 144, // 466: openshell.v1.OpenShell.RotateProviderCredential:output_type -> openshell.v1.RotateProviderCredentialResponse + 146, // 467: openshell.v1.OpenShell.DeleteProviderRefresh:output_type -> openshell.v1.DeleteProviderRefreshResponse + 157, // 468: openshell.v1.OpenShell.DeleteProvider:output_type -> openshell.v1.DeleteProviderResponse + 159, // 469: openshell.v1.OpenShell.DeleteProviderProfile:output_type -> openshell.v1.DeleteProviderProfileResponse + 303, // 470: openshell.v1.OpenShell.GetSandboxConfig:output_type -> openshell.sandbox.v1.GetSandboxConfigResponse + 304, // 471: openshell.v1.OpenShell.GetGatewayConfig:output_type -> openshell.sandbox.v1.GetGatewayConfigResponse + 175, // 472: openshell.v1.OpenShell.UpdateConfig:output_type -> openshell.v1.UpdateConfigResponse + 177, // 473: openshell.v1.OpenShell.GetSandboxPolicyStatus:output_type -> openshell.v1.GetSandboxPolicyStatusResponse + 179, // 474: openshell.v1.OpenShell.ListSandboxPolicies:output_type -> openshell.v1.ListSandboxPoliciesResponse + 181, // 475: openshell.v1.OpenShell.ReportPolicyStatus:output_type -> openshell.v1.ReportPolicyStatusResponse + 257, // 476: openshell.v1.OpenShell.ReportEndpointStatus:output_type -> openshell.v1.ReportEndpointStatusResponse + 88, // 477: openshell.v1.OpenShell.ReportProviderReadiness:output_type -> openshell.v1.ReportProviderReadinessResponse + 184, // 478: openshell.v1.OpenShell.ReportSandboxConfiguration:output_type -> openshell.v1.ReportSandboxConfigurationResponse + 163, // 479: openshell.v1.OpenShell.GetSandboxProviderEnvironment:output_type -> openshell.v1.GetSandboxProviderEnvironmentResponse + 165, // 480: openshell.v1.OpenShell.ExchangeProviderSubjectToken:output_type -> openshell.v1.ExchangeProviderSubjectTokenResponse + 189, // 481: openshell.v1.OpenShell.GetSandboxLogs:output_type -> openshell.v1.GetSandboxLogsResponse + 188, // 482: openshell.v1.OpenShell.PushSandboxLogs:output_type -> openshell.v1.PushSandboxLogsResponse + 191, // 483: openshell.v1.OpenShell.ConnectSupervisor:output_type -> openshell.v1.GatewayMessage + 199, // 484: openshell.v1.OpenShell.ReportMainProcessExit:output_type -> openshell.v1.ReportMainProcessExitResponse + 201, // 485: openshell.v1.OpenShell.FinalizeMainProcessExit:output_type -> openshell.v1.FinalizeMainProcessExitResponse + 206, // 486: openshell.v1.OpenShell.RelayStream:output_type -> openshell.v1.RelayFrame + 208, // 487: openshell.v1.OpenShell.PeerRelay:output_type -> openshell.v1.PeerRelayFrame + 88, // 488: openshell.v1.OpenShell.PeerReportProviderReadiness:output_type -> openshell.v1.ReportProviderReadinessResponse + 257, // 489: openshell.v1.OpenShell.PeerReportEndpointStatus:output_type -> openshell.v1.ReportEndpointStatusResponse + 86, // 490: openshell.v1.OpenShell.PeerGetSandboxProviderStatus:output_type -> openshell.v1.GetSandboxProviderStatusResponse + 113, // 491: openshell.v1.OpenShell.WatchSandbox:output_type -> openshell.v1.SandboxStreamEvent + 218, // 492: openshell.v1.OpenShell.SubmitPolicyAnalysis:output_type -> openshell.v1.SubmitPolicyAnalysisResponse + 220, // 493: openshell.v1.OpenShell.GetDraftPolicy:output_type -> openshell.v1.GetDraftPolicyResponse + 222, // 494: openshell.v1.OpenShell.ApproveDraftChunk:output_type -> openshell.v1.ApproveDraftChunkResponse + 224, // 495: openshell.v1.OpenShell.RejectDraftChunk:output_type -> openshell.v1.RejectDraftChunkResponse + 227, // 496: openshell.v1.OpenShell.ApproveAllDraftChunks:output_type -> openshell.v1.ApproveAllDraftChunksResponse + 229, // 497: openshell.v1.OpenShell.EditDraftChunk:output_type -> openshell.v1.EditDraftChunkResponse + 231, // 498: openshell.v1.OpenShell.UndoDraftChunk:output_type -> openshell.v1.UndoDraftChunkResponse + 233, // 499: openshell.v1.OpenShell.ClearDraftChunks:output_type -> openshell.v1.ClearDraftChunksResponse + 236, // 500: openshell.v1.OpenShell.GetDraftHistory:output_type -> openshell.v1.GetDraftHistoryResponse + 22, // 501: openshell.v1.OpenShell.IssueSandboxToken:output_type -> openshell.v1.IssueSandboxTokenResponse + 24, // 502: openshell.v1.OpenShell.RefreshSandboxToken:output_type -> openshell.v1.RefreshSandboxTokenResponse + 238, // 503: openshell.v1.OpenShell.CreateWorkspace:output_type -> openshell.v1.CreateWorkspaceResponse + 240, // 504: openshell.v1.OpenShell.GetWorkspace:output_type -> openshell.v1.GetWorkspaceResponse + 242, // 505: openshell.v1.OpenShell.ListWorkspaces:output_type -> openshell.v1.ListWorkspacesResponse + 244, // 506: openshell.v1.OpenShell.DeleteWorkspace:output_type -> openshell.v1.DeleteWorkspaceResponse + 247, // 507: openshell.v1.OpenShell.AddWorkspaceMember:output_type -> openshell.v1.AddWorkspaceMemberResponse + 249, // 508: openshell.v1.OpenShell.RemoveWorkspaceMember:output_type -> openshell.v1.RemoveWorkspaceMemberResponse + 251, // 509: openshell.v1.OpenShell.ListWorkspaceMembers:output_type -> openshell.v1.ListWorkspaceMembersResponse + 426, // [426:510] is the sub-list for method output_type + 342, // [342:426] is the sub-list for method input_type + 342, // [342:342] is the sub-list for extension type_name + 342, // [342:342] is the sub-list for extension extendee + 0, // [0:342] is the sub-list for field type_name } func init() { file_openshell_proto_init() } @@ -21109,37 +21304,37 @@ func file_openshell_proto_init() { file_openshell_proto_msgTypes[20].OneofWrappers = []any{} file_openshell_proto_msgTypes[21].OneofWrappers = []any{} file_openshell_proto_msgTypes[29].OneofWrappers = []any{} - file_openshell_proto_msgTypes[56].OneofWrappers = []any{ + file_openshell_proto_msgTypes[58].OneofWrappers = []any{ (*ConfigSnapshotRevision_SandboxConfig)(nil), (*ConfigSnapshotRevision_ProviderEnvironment)(nil), (*ConfigSnapshotRevision_ProviderTarget)(nil), } - file_openshell_proto_msgTypes[83].OneofWrappers = []any{ + file_openshell_proto_msgTypes[85].OneofWrappers = []any{ (*ExecSandboxEvent_Stdout)(nil), (*ExecSandboxEvent_Stderr)(nil), (*ExecSandboxEvent_Exit)(nil), } - file_openshell_proto_msgTypes[84].OneofWrappers = []any{ + file_openshell_proto_msgTypes[86].OneofWrappers = []any{ (*TcpForwardInit_Ssh)(nil), (*TcpForwardInit_Tcp)(nil), } - file_openshell_proto_msgTypes[85].OneofWrappers = []any{ + file_openshell_proto_msgTypes[87].OneofWrappers = []any{ (*TcpForwardFrame_Init)(nil), (*TcpForwardFrame_Data)(nil), } - file_openshell_proto_msgTypes[86].OneofWrappers = []any{ + file_openshell_proto_msgTypes[88].OneofWrappers = []any{ (*ExecSandboxInput_Start)(nil), (*ExecSandboxInput_Stdin)(nil), (*ExecSandboxInput_Resize)(nil), } - file_openshell_proto_msgTypes[90].OneofWrappers = []any{ + file_openshell_proto_msgTypes[92].OneofWrappers = []any{ (*SandboxStreamEvent_Sandbox)(nil), (*SandboxStreamEvent_Log)(nil), (*SandboxStreamEvent_Event)(nil), (*SandboxStreamEvent_Warning)(nil), (*SandboxStreamEvent_DraftPolicyUpdate)(nil), } - file_openshell_proto_msgTypes[144].OneofWrappers = []any{ + file_openshell_proto_msgTypes[146].OneofWrappers = []any{ (*PolicyMergeOperation_AddRule)(nil), (*PolicyMergeOperation_RemoveEndpoint)(nil), (*PolicyMergeOperation_RemoveRule)(nil), @@ -21147,14 +21342,14 @@ func file_openshell_proto_init() { (*PolicyMergeOperation_AddAllowRules)(nil), (*PolicyMergeOperation_RemoveBinary)(nil), } - file_openshell_proto_msgTypes[148].OneofWrappers = []any{} - file_openshell_proto_msgTypes[167].OneofWrappers = []any{ + file_openshell_proto_msgTypes[150].OneofWrappers = []any{} + file_openshell_proto_msgTypes[169].OneofWrappers = []any{ (*SupervisorMessage_Hello)(nil), (*SupervisorMessage_Heartbeat)(nil), (*SupervisorMessage_RelayOpenResult)(nil), (*SupervisorMessage_RelayClose)(nil), } - file_openshell_proto_msgTypes[168].OneofWrappers = []any{ + file_openshell_proto_msgTypes[170].OneofWrappers = []any{ (*GatewayMessage_SessionAccepted)(nil), (*GatewayMessage_SessionRejected)(nil), (*GatewayMessage_Heartbeat)(nil), @@ -21162,26 +21357,26 @@ func file_openshell_proto_init() { (*GatewayMessage_RelayClose)(nil), (*GatewayMessage_SessionRedirect)(nil), } - file_openshell_proto_msgTypes[179].OneofWrappers = []any{ + file_openshell_proto_msgTypes[181].OneofWrappers = []any{ (*RelayOpen_Ssh)(nil), (*RelayOpen_Tcp)(nil), } - file_openshell_proto_msgTypes[183].OneofWrappers = []any{ + file_openshell_proto_msgTypes[185].OneofWrappers = []any{ (*RelayFrame_Init)(nil), (*RelayFrame_Data)(nil), } - file_openshell_proto_msgTypes[185].OneofWrappers = []any{ + file_openshell_proto_msgTypes[187].OneofWrappers = []any{ (*PeerRelayFrame_Init)(nil), (*PeerRelayFrame_Data)(nil), } - file_openshell_proto_msgTypes[238].OneofWrappers = []any{} + file_openshell_proto_msgTypes[240].OneofWrappers = []any{} type x struct{} out := protoimpl.TypeBuilder{ File: protoimpl.DescBuilder{ GoPackagePath: reflect.TypeOf(x{}).PkgPath(), RawDescriptor: unsafe.Slice(unsafe.StringData(file_openshell_proto_rawDesc), len(file_openshell_proto_rawDesc)), NumEnums: 21, - NumMessages: 263, + NumMessages: 265, NumExtensions: 0, NumServices: 1, }, diff --git a/sdk/go/proto/openshellv1/openshell_grpc.pb.go b/sdk/go/proto/openshellv1/openshell_grpc.pb.go index 5ca018daf6..e12cba7d3f 100644 --- a/sdk/go/proto/openshellv1/openshell_grpc.pb.go +++ b/sdk/go/proto/openshellv1/openshell_grpc.pb.go @@ -27,6 +27,7 @@ const ( OpenShell_GetCurrentUser_FullMethodName = "/openshell.v1.OpenShell/GetCurrentUser" OpenShell_GetGatewayInfo_FullMethodName = "/openshell.v1.OpenShell/GetGatewayInfo" OpenShell_CreateSandbox_FullMethodName = "/openshell.v1.OpenShell/CreateSandbox" + OpenShell_UpdateSandbox_FullMethodName = "/openshell.v1.OpenShell/UpdateSandbox" OpenShell_BeginRootfsTarStaging_FullMethodName = "/openshell.v1.OpenShell/BeginRootfsTarStaging" OpenShell_GetSandbox_FullMethodName = "/openshell.v1.OpenShell/GetSandbox" OpenShell_ListSandboxes_FullMethodName = "/openshell.v1.OpenShell/ListSandboxes" @@ -129,6 +130,9 @@ type OpenShellClient interface { GetGatewayInfo(ctx context.Context, in *GetGatewayInfoRequest, opts ...grpc.CallOption) (*GetGatewayInfoResponse, error) // Create a new sandbox. CreateSandbox(ctx context.Context, in *CreateSandboxRequest, opts ...grpc.CallOption) (*SandboxResponse, error) + // Update only the workload image of a stopped sandbox without deleting its + // identity or retained storage. Requires compute-driver image-update support. + UpdateSandbox(ctx context.Context, in *UpdateSandboxRequest, opts ...grpc.CallOption) (*SandboxResponse, error) // Allocate a gateway-owned staging slot for a local rootfs tar archive. // // The gateway creates a request-scoped directory inside the compute driver's @@ -389,6 +393,16 @@ func (c *openShellClient) CreateSandbox(ctx context.Context, in *CreateSandboxRe return out, nil } +func (c *openShellClient) UpdateSandbox(ctx context.Context, in *UpdateSandboxRequest, opts ...grpc.CallOption) (*SandboxResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(SandboxResponse) + err := c.cc.Invoke(ctx, OpenShell_UpdateSandbox_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + func (c *openShellClient) BeginRootfsTarStaging(ctx context.Context, in *BeginRootfsTarStagingRequest, opts ...grpc.CallOption) (*BeginRootfsTarStagingResponse, error) { cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(BeginRootfsTarStagingResponse) @@ -1236,6 +1250,9 @@ type OpenShellServer interface { GetGatewayInfo(context.Context, *GetGatewayInfoRequest) (*GetGatewayInfoResponse, error) // Create a new sandbox. CreateSandbox(context.Context, *CreateSandboxRequest) (*SandboxResponse, error) + // Update only the workload image of a stopped sandbox without deleting its + // identity or retained storage. Requires compute-driver image-update support. + UpdateSandbox(context.Context, *UpdateSandboxRequest) (*SandboxResponse, error) // Allocate a gateway-owned staging slot for a local rootfs tar archive. // // The gateway creates a request-scoped directory inside the compute driver's @@ -1468,6 +1485,9 @@ func (UnimplementedOpenShellServer) GetGatewayInfo(context.Context, *GetGatewayI func (UnimplementedOpenShellServer) CreateSandbox(context.Context, *CreateSandboxRequest) (*SandboxResponse, error) { return nil, status.Error(codes.Unimplemented, "method CreateSandbox not implemented") } +func (UnimplementedOpenShellServer) UpdateSandbox(context.Context, *UpdateSandboxRequest) (*SandboxResponse, error) { + return nil, status.Error(codes.Unimplemented, "method UpdateSandbox not implemented") +} func (UnimplementedOpenShellServer) BeginRootfsTarStaging(context.Context, *BeginRootfsTarStagingRequest) (*BeginRootfsTarStagingResponse, error) { return nil, status.Error(codes.Unimplemented, "method BeginRootfsTarStaging not implemented") } @@ -1798,6 +1818,24 @@ func _OpenShell_CreateSandbox_Handler(srv interface{}, ctx context.Context, dec return interceptor(ctx, in, info, handler) } +func _OpenShell_UpdateSandbox_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(UpdateSandboxRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(OpenShellServer).UpdateSandbox(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: OpenShell_UpdateSandbox_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(OpenShellServer).UpdateSandbox(ctx, req.(*UpdateSandboxRequest)) + } + return interceptor(ctx, in, info, handler) +} + func _OpenShell_BeginRootfsTarStaging_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(BeginRootfsTarStagingRequest) if err := dec(in); err != nil { @@ -3163,6 +3201,10 @@ var OpenShell_ServiceDesc = grpc.ServiceDesc{ MethodName: "CreateSandbox", Handler: _OpenShell_CreateSandbox_Handler, }, + { + MethodName: "UpdateSandbox", + Handler: _OpenShell_UpdateSandbox_Handler, + }, { MethodName: "BeginRootfsTarStaging", Handler: _OpenShell_BeginRootfsTarStaging_Handler, diff --git a/skills/openshell-cli/SKILL.md b/skills/openshell-cli/SKILL.md index 8fe37fee1c..7648537c16 100644 --- a/skills/openshell-cli/SKILL.md +++ b/skills/openshell-cli/SKILL.md @@ -537,6 +537,32 @@ for verification behavior and release compatibility. For an infrastructure `Error` on a backend that supports restarting stopped sandboxes, fix the reported cause, run `sandbox stop`, and wait for it to succeed before running `sandbox start`. This retains the sandbox and persistent workspace but cannot recover deleted resources or storage. For a provisioning timeout, wait for cleanup to finish, then run `sandbox start` directly. +### Change a stopped sandbox's workload image + +Do not invent a `sandbox update` command or use delete/create to change an +existing sandbox's image. The raw `UpdateSandbox` RPC initially supports only +stopped Kubernetes sandboxes; other drivers return `UNIMPLEMENTED`. Stop and +wait for `Stopped`, read the sandbox's current resource version through +`GetSandbox`, call raw `UpdateSandbox` with the named workspace, sandbox name, +OCI image, and required nonzero `expected_resource_version`, then start after +success. There is no curated SDK update method. The sandbox identity, Kubernetes +custom resource, and persistent volume claim remain; the existing workspace is +not reseeded and trusted runtime images do not change. + +For an image that fails to start and reaches a provisioning timeout, wait for +cleanup completion and settlement of the original driver operation, then run +`sandbox stop` to obtain `Stopped` before correcting the image. This retains the +timeout diagnostic and storage and does not bypass pending cleanup. + +If raw `sandbox.status.image_update` is present after a failure, start is +blocked. Read a fresh version and retry that same pending image. An optional +`request_id` with an unresolved admission does not execute again; inspect and +reconcile state before submitting a new conditional request with a fresh +version and new ID, or no ID. Never change the payload under the original ID or +blindly switch IDs after a timeout. See the published +[image update workflow](https://docs.nvidia.com/openshell/latest/how-it-works/sandboxes/overview#update-the-image-of-a-stopped-sandbox) +and [API errors](https://docs.nvidia.com/openshell/latest/sdk/api-errors). + --- ## Workflow 4: Policy Iteration Loop diff --git a/tasks/test.toml b/tasks/test.toml index 6518bfdbe4..126fde4f5c 100644 --- a/tasks/test.toml +++ b/tasks/test.toml @@ -220,7 +220,10 @@ run = "e2e/rust/e2e-podman.sh" ["e2e:kubernetes"] description = "Run Rust CLI e2e tests against an OpenShell gateway deployed on Kubernetes via Helm (set OPENSHELL_E2E_KUBE_CONTEXT to reuse a cluster; otherwise creates a local k3d cluster when k3d is installed; set OPENSHELL_E2E_KUBE_TEST= to scope to one test)" -run = "e2e/rust/e2e-kubernetes.sh" +# The reusable CI workflow exports an empty feature input by default. Restore +# the normal Rust suite here, not in the runner: the external-driver task +# intentionally passes an empty feature set for conformance-only coverage. +run = 'OPENSHELL_E2E_KUBERNETES_FEATURES="${OPENSHELL_E2E_KUBERNETES_FEATURES:-e2e,e2e-host-gateway,e2e-kubernetes}" e2e/rust/e2e-kubernetes.sh' ["e2e:kubernetes:v1alpha1"] description = "Run Kubernetes e2e against Agent Sandbox v1alpha1" From 09cd23f146e4cb139c413da620e6bf3f5b3c7ad7 Mon Sep 17 00:00:00 2001 From: sjenning <493891+sjenning@users.noreply.github.com> Date: Thu, 15 Oct 2026 20:21:01 +0000 Subject: [PATCH 2/7] feat(gateway): add storage-preserving sandbox image updates OpenClaw-Publication: b2036b09-b697-4d65-aba9-5c96a3198f9c Signed-off-by: sjenning <493891+sjenning@users.noreply.github.com> From e00717ccd22e16b6237bc210f8443946842785e4 Mon Sep 17 00:00:00 2001 From: sjenning <493891+sjenning@users.noreply.github.com> Date: Thu, 15 Oct 2026 19:34:06 -0500 Subject: [PATCH 3/7] fix(gateway): preserve image update patch-release compatibility Move image updates to a separate authenticated service and retain the baseline public sandbox status. Persist image intent and revisions independently with atomic baseline-known lifecycle fencing and explicit post-upgrade activation. Preserve concurrent provisioning clocks, fence replaced attempts and delayed callbacks, and verify private-state transactions plus both Kubernetes controller API lanes. Signed-off-by: sjenning <493891+sjenning@users.noreply.github.com> --- .agents/skills/helm-dev-environment/SKILL.md | 18 + .../tests/ensure_providers_integration.rs | 7 - .../openshell-cli/tests/mtls_integration.rs | 7 - .../tests/provider_commands_integration.rs | 7 - .../sandbox_create_lifecycle_integration.rs | 7 - .../sandbox_exec_streaming_integration.rs | 7 - .../sandbox_name_fallback_integration.rs | 7 - crates/openshell-core/src/config.rs | 6 + .../src/routes.rs | 95 +- crates/openshell-sdk/src/client.rs | 19 +- crates/openshell-sdk/src/raw.rs | 16 +- crates/openshell-sdk/tests/client_mock.rs | 91 +- .../tests/sandbox_status_compatibility.rs | 31 + crates/openshell-server/build.rs | 4 +- .../proto/sandbox_image.proto | 25 + crates/openshell-server/src/cli.rs | 48 + .../src/compute/image_update.rs | 644 +++- crates/openshell-server/src/compute/mod.rs | 12 +- crates/openshell-server/src/config_file.rs | 3 + .../openshell-server/src/gateway_members.rs | 4 + crates/openshell-server/src/grpc/mod.rs | 17 +- .../src/grpc/mutation_replay.rs | 5 +- .../src/grpc/mutation_replay/ordinary.rs | 12 +- .../src/grpc/sandbox/image_update_tests.rs | 82 +- crates/openshell-server/src/lib.rs | 1 + crates/openshell-server/src/multiplex.rs | 64 +- .../src/persistence/image_activation.rs | 315 ++ .../openshell-server/src/persistence/mod.rs | 2 + .../src/persistence/postgres.rs | 15 +- .../src/persistence/sandbox_image.rs | 1369 ++++++++ .../src/persistence/sqlite.rs | 2 +- crates/openshell-server/src/reflection.rs | 2 +- crates/openshell-server/src/storage_proto.rs | 48 +- crates/openshell-server/tests/common/mod.rs | 7 - .../tests/supervisor_relay_integration.rs | 7 - docs/how-it-works/gateways/configuration.mdx | 40 +- docs/how-it-works/sandboxes/overview.mdx | 58 +- docs/kubernetes/high-availability.mdx | 45 + docs/sdk/api-errors.mdx | 24 +- e2e/rust/tests/kubernetes_image_update.rs | 72 +- e2e/with-kube-gateway.sh | 6 + proto/openshell.proto | 39 +- sdk/go/proto/openshellv1/openshell.pb.go | 2897 ++++++++--------- sdk/go/proto/openshellv1/openshell_grpc.pb.go | 156 +- .../proto/openshellv1/sandbox_updates_test.go | 121 + sdk/typescript/src/raw.test.ts | 49 +- sdk/typescript/src/raw.ts | 2 +- skills/debug-openshell-cluster/SKILL.md | 40 + skills/openshell-cli/SKILL.md | 21 +- 49 files changed, 4618 insertions(+), 1958 deletions(-) create mode 100644 crates/openshell-sdk/tests/sandbox_status_compatibility.rs create mode 100644 crates/openshell-server/proto/sandbox_image.proto create mode 100644 crates/openshell-server/src/persistence/image_activation.rs create mode 100644 crates/openshell-server/src/persistence/sandbox_image.rs create mode 100644 sdk/go/proto/openshellv1/sandbox_updates_test.go diff --git a/.agents/skills/helm-dev-environment/SKILL.md b/.agents/skills/helm-dev-environment/SKILL.md index 574bf2c1fd..9696bacfb9 100644 --- a/.agents/skills/helm-dev-environment/SKILL.md +++ b/.agents/skills/helm-dev-environment/SKILL.md @@ -275,6 +275,24 @@ Set `OPENSHELL_E2E_KUBE_TEST=kubernetes_image_update` to scope the Rust suite to image replacement with retained sandbox, SSH, and PVC identities. This target is included in both existing Agent Sandbox API-version lanes; unlike the Python Docker suite, it exercises the driver that supports image updates. + +Image updates default to disabled outside test fixtures. The e2e wrapper opts +in only for a fresh gateway fixture that it owns; set +`OPENSHELL_E2E_KUBE_IMAGE_UPDATES=0` to prevent that opt-in. Do not propagate +activation to an existing shared gateway or enable it during a mixed-version +rollout. For manual testing, follow the retirement and activation checklist in +`docs/kubernetes/high-availability.mdx` before setting +`gatewayConfig: {"openshell.gateway": {enable_sandbox_image_updates: true}}`. +The gateway process equivalents are `--enable-sandbox-image-updates true` and +`OPENSHELL_ENABLE_SANDBOX_IMAGE_UPDATES=true`. Retire every old process and Job, +settle outstanding driver work, prevent old binaries returning, and do not +treat PostgreSQL connection markers or membership TTL expiry as retirement +proof. SQLite testing supports one gateway process only. Image-update clients +must call the separate `SandboxUpdates` service on the existing gateway +listener, not add a method to the baseline `OpenShell` service or inspect new +public `SandboxStatus` image fields. Pending-operation recovery uses the same +requested image with a fresh version and the documented request-ID semantics. + The kube e2e wrapper creates only one port-forward, to `svc/openshell`; it no longer forwards the unauthenticated health listener or runs a `/readyz` e2e target. `/readyz` remains covered by server unit/integration tests. diff --git a/crates/openshell-cli/tests/ensure_providers_integration.rs b/crates/openshell-cli/tests/ensure_providers_integration.rs index f1339d2f88..ba5f60c6cc 100644 --- a/crates/openshell-cli/tests/ensure_providers_integration.rs +++ b/crates/openshell-cli/tests/ensure_providers_integration.rs @@ -80,13 +80,6 @@ impl TestOpenShell { #[tonic::async_trait] impl OpenShell for TestOpenShell { - async fn update_sandbox( - &self, - _request: tonic::Request, - ) -> Result, Status> { - Err(Status::unimplemented("not implemented by test service")) - } - async fn peer_report_provider_readiness( &self, _request: tonic::Request, diff --git a/crates/openshell-cli/tests/mtls_integration.rs b/crates/openshell-cli/tests/mtls_integration.rs index 11cbd909c4..4428666184 100644 --- a/crates/openshell-cli/tests/mtls_integration.rs +++ b/crates/openshell-cli/tests/mtls_integration.rs @@ -32,13 +32,6 @@ struct TestOpenShell; #[tonic::async_trait] impl OpenShell for TestOpenShell { - async fn update_sandbox( - &self, - _request: tonic::Request, - ) -> Result, Status> { - Err(Status::unimplemented("not implemented by test service")) - } - async fn peer_report_provider_readiness( &self, _request: tonic::Request, diff --git a/crates/openshell-cli/tests/provider_commands_integration.rs b/crates/openshell-cli/tests/provider_commands_integration.rs index 9905711874..538eebf060 100644 --- a/crates/openshell-cli/tests/provider_commands_integration.rs +++ b/crates/openshell-cli/tests/provider_commands_integration.rs @@ -233,13 +233,6 @@ impl TestOpenShell { #[tonic::async_trait] impl OpenShell for TestOpenShell { - async fn update_sandbox( - &self, - _request: tonic::Request, - ) -> Result, Status> { - Err(Status::unimplemented("not implemented by test service")) - } - async fn peer_report_provider_readiness( &self, _request: tonic::Request, diff --git a/crates/openshell-cli/tests/sandbox_create_lifecycle_integration.rs b/crates/openshell-cli/tests/sandbox_create_lifecycle_integration.rs index 55abb178fd..31345d6e2e 100644 --- a/crates/openshell-cli/tests/sandbox_create_lifecycle_integration.rs +++ b/crates/openshell-cli/tests/sandbox_create_lifecycle_integration.rs @@ -101,13 +101,6 @@ struct TestOpenShell { #[tonic::async_trait] impl OpenShell for TestOpenShell { - async fn update_sandbox( - &self, - _request: tonic::Request, - ) -> Result, Status> { - Err(Status::unimplemented("not implemented by test service")) - } - async fn peer_report_provider_readiness( &self, _request: tonic::Request, diff --git a/crates/openshell-cli/tests/sandbox_exec_streaming_integration.rs b/crates/openshell-cli/tests/sandbox_exec_streaming_integration.rs index 1dceab0bf1..c57e2d4ea5 100644 --- a/crates/openshell-cli/tests/sandbox_exec_streaming_integration.rs +++ b/crates/openshell-cli/tests/sandbox_exec_streaming_integration.rs @@ -163,13 +163,6 @@ macro_rules! mock_gateway { ) => { #[tonic::async_trait] impl OpenShell for MockGateway { - async fn update_sandbox( - &self, - _request: Request, - ) -> Result, Status> { - Err(Status::unimplemented("not implemented by test service")) - } - $(async fn $method(&self, _: Request<$request>) -> Result, Status> { Err(Status::unimplemented("unused test RPC")) })* diff --git a/crates/openshell-cli/tests/sandbox_name_fallback_integration.rs b/crates/openshell-cli/tests/sandbox_name_fallback_integration.rs index cfa9903605..94a185567d 100644 --- a/crates/openshell-cli/tests/sandbox_name_fallback_integration.rs +++ b/crates/openshell-cli/tests/sandbox_name_fallback_integration.rs @@ -47,13 +47,6 @@ struct TestOpenShell { #[tonic::async_trait] impl OpenShell for TestOpenShell { - async fn update_sandbox( - &self, - _request: tonic::Request, - ) -> Result, Status> { - Err(Status::unimplemented("not implemented by test service")) - } - async fn peer_report_provider_readiness( &self, _request: tonic::Request, diff --git a/crates/openshell-core/src/config.rs b/crates/openshell-core/src/config.rs index d68562398c..71a86e727e 100644 --- a/crates/openshell-core/src/config.rs +++ b/crates/openshell-core/src/config.rs @@ -222,6 +222,11 @@ pub struct Config { /// Disabled for local gateways by default. pub enable_websocket_tunnel: bool, + /// Operator activation after all gateways and outstanding legacy driver + /// operations have been drained onto the image-update-compatible protocol. + /// Disabled by default; not a license to run mixed-version writers. + pub enable_sandbox_image_updates: bool, + /// Disabled-by-default gateway interceptor service configs. pub gateway_interceptors: Vec, @@ -905,6 +910,7 @@ impl Config { oidc: None, auth: GatewayAuthConfig::default(), enable_websocket_tunnel: false, + enable_sandbox_image_updates: false, gateway_interceptors: Vec::new(), provider_profile_sources: vec![GatewayProviderProfileSourceConfig::User], mtls_auth: MtlsAuthConfig::default(), diff --git a/crates/openshell-gateway-interceptors/src/routes.rs b/crates/openshell-gateway-interceptors/src/routes.rs index c436563ef2..dcb98ec5bc 100644 --- a/crates/openshell-gateway-interceptors/src/routes.rs +++ b/crates/openshell-gateway-interceptors/src/routes.rs @@ -1,7 +1,7 @@ // SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. // SPDX-License-Identifier: Apache-2.0 -//! Interceptable `OpenShell` route classification. +//! Interceptable public gateway route classification. use std::collections::{BTreeMap, BTreeSet}; @@ -10,13 +10,16 @@ use prost_reflect::DescriptorPool; use crate::{InterceptorError, Result}; const SERVICE_OPEN_SHELL: &str = "openshell.v1.OpenShell"; +const SERVICE_SANDBOX_UPDATES: &str = "openshell.v1.SandboxUpdates"; + +/// Unary sandbox-update methods that may be targeted by gateway interceptors. +pub const INTERCEPTABLE_SANDBOX_UPDATE_METHODS: &[&str] = &["UpdateSandbox"]; /// Unary `openshell.v1.OpenShell` methods that may be targeted by gateway /// interceptors. New methods are non-interceptable until deliberately added /// here. pub const INTERCEPTABLE_METHODS: &[&str] = &[ "CreateSandbox", - "UpdateSandbox", "AttachSandboxProvider", "DetachSandboxProvider", "DeleteSandbox", @@ -59,25 +62,25 @@ impl OpenShellRouteIndex { } pub(crate) fn from_descriptor_pool(pool: &DescriptorPool) -> Result { - let service = pool - .get_service_by_name(SERVICE_OPEN_SHELL) - .ok_or_else(|| { - InterceptorError::Config(format!( - "descriptor set does not contain service '{SERVICE_OPEN_SHELL}'" - )) - })?; let mut all_methods = BTreeSet::new(); let mut unary_methods = BTreeSet::new(); let mut input_types = BTreeMap::new(); let mut output_types = BTreeMap::new(); - for method in service.methods() { - let name = method.name().to_string(); - all_methods.insert(name.clone()); - if !method.is_client_streaming() && !method.is_server_streaming() { - unary_methods.insert(name.clone()); - input_types.insert(name.clone(), method.input().full_name().to_string()); - output_types.insert(name, method.output().full_name().to_string()); + for service_name in [SERVICE_OPEN_SHELL, SERVICE_SANDBOX_UPDATES] { + let service = pool.get_service_by_name(service_name).ok_or_else(|| { + InterceptorError::Config(format!( + "descriptor set does not contain service '{service_name}'" + )) + })?; + for method in service.methods() { + let route = format!("{service_name}/{}", method.name()); + all_methods.insert(route.clone()); + if !method.is_client_streaming() && !method.is_server_streaming() { + unary_methods.insert(route.clone()); + input_types.insert(route.clone(), method.input().full_name().to_string()); + output_types.insert(route, method.output().full_name().to_string()); + } } } @@ -93,37 +96,45 @@ impl OpenShellRouteIndex { #[must_use] pub fn is_interceptable(&self, service: &str, method: &str) -> bool { - service == SERVICE_OPEN_SHELL - && self.unary_methods.contains(method) - && INTERCEPTABLE_METHODS.contains(&method) + let allowed = match service { + SERVICE_OPEN_SHELL => INTERCEPTABLE_METHODS, + SERVICE_SANDBOX_UPDATES => INTERCEPTABLE_SANDBOX_UPDATE_METHODS, + _ => return false, + }; + allowed.contains(&method) && self.unary_methods.contains(&format!("{service}/{method}")) } #[must_use] pub fn input_type(&self, service: &str, method: &str) -> Option<&str> { - if service == SERVICE_OPEN_SHELL && self.unary_methods.contains(method) { - self.input_types.get(method).map(String::as_str) - } else { - None - } + self.input_types + .get(&format!("{service}/{method}")) + .map(String::as_str) } #[must_use] pub fn output_type(&self, service: &str, method: &str) -> Option<&str> { - if service == SERVICE_OPEN_SHELL && self.unary_methods.contains(method) { - self.output_types.get(method).map(String::as_str) - } else { - None - } + self.output_types + .get(&format!("{service}/{method}")) + .map(String::as_str) } fn validate_interceptable_list(&self) -> Result<()> { let mut stale = Vec::new(); let mut streaming = Vec::new(); - for method in INTERCEPTABLE_METHODS { - if !self.all_methods.contains(*method) { - stale.push((*method).to_string()); - } else if !self.unary_methods.contains(*method) { - streaming.push((*method).to_string()); + for (service, methods) in [ + (SERVICE_OPEN_SHELL, INTERCEPTABLE_METHODS), + ( + SERVICE_SANDBOX_UPDATES, + INTERCEPTABLE_SANDBOX_UPDATE_METHODS, + ), + ] { + for method in methods { + let route = format!("{service}/{method}"); + if !self.all_methods.contains(&route) { + stale.push(route); + } else if !self.unary_methods.contains(&route) { + streaming.push(route); + } } } if !stale.is_empty() { @@ -154,6 +165,22 @@ mod tests { let index = OpenShellRouteIndex::from_descriptor_set(openshell_core::FILE_DESCRIPTOR_SET).unwrap(); assert!(index.is_interceptable("openshell.v1.OpenShell", "CreateSandbox")); + assert!(index.is_interceptable(SERVICE_SANDBOX_UPDATES, "UpdateSandbox")); + assert!(!index.is_interceptable(SERVICE_OPEN_SHELL, "UpdateSandbox")); + assert!(!index.is_interceptable(SERVICE_SANDBOX_UPDATES, "CreateSandbox")); + assert_eq!( + index.input_type(SERVICE_SANDBOX_UPDATES, "UpdateSandbox"), + Some("openshell.v1.UpdateSandboxRequest") + ); + assert_eq!( + index.output_type(SERVICE_SANDBOX_UPDATES, "UpdateSandbox"), + Some("openshell.v1.SandboxResponse") + ); + assert!( + index + .input_type(SERVICE_OPEN_SHELL, "UpdateSandbox") + .is_none() + ); assert!(index.is_interceptable("openshell.v1.OpenShell", "UpdateConfig")); assert!(index.is_interceptable("openshell.v1.OpenShell", "SubmitPolicyAnalysis")); assert!(!index.is_interceptable("openshell.v1.OpenShell", "Health")); diff --git a/crates/openshell-sdk/src/client.rs b/crates/openshell-sdk/src/client.rs index 69b75ffbd2..59f857adee 100644 --- a/crates/openshell-sdk/src/client.rs +++ b/crates/openshell-sdk/src/client.rs @@ -12,7 +12,7 @@ use crate::auth::{BearerSlot, EdgeAuthInterceptor, bearer_metadata}; use crate::config::{AuthConfig, ClientConfig}; use crate::error::{Result, SdkError}; use crate::pagination::{Page, Pager}; -use crate::raw::AuthedGrpcClient; +use crate::raw::{AuthedGrpcClient, AuthedSandboxUpdatesClient}; use crate::refresh::{RefreshedToken, TokenSource}; use crate::types::{ DeleteOptions, DeletionResult, ExecOptions, ExecResult, Health, ListOptions, SandboxPhase, @@ -116,6 +116,23 @@ impl OpenShellClient { Ok(self.raw_grpc()) } + /// Authenticated client for the optional `SandboxUpdates` service, sharing + /// this client's channel and live bearer slot. Like [`Self::raw_grpc`], this + /// does not refresh or retry OIDC credentials by itself. + pub fn raw_sandbox_updates(&self) -> AuthedSandboxUpdatesClient { + proto::sandbox_updates_client::SandboxUpdatesClient::with_interceptor( + self.channel.clone(), + self.interceptor.clone(), + ) + } + + /// Like [`Self::raw_sandbox_updates`], but refreshes the bearer token first + /// when needed. Reactive retry remains the raw caller's responsibility. + pub async fn raw_sandbox_updates_fresh(&self) -> Result { + self.ensure_fresh().await?; + Ok(self.raw_sandbox_updates()) + } + /// Force an OIDC refresh and write the new token into the live bearer /// slot, regardless of expiry. Returns `true` when a refresher is wired /// and a fresh token was minted, `false` for static auth. Use after a diff --git a/crates/openshell-sdk/src/raw.rs b/crates/openshell-sdk/src/raw.rs index 7a1d9feab3..cf25fd0b96 100644 --- a/crates/openshell-sdk/src/raw.rs +++ b/crates/openshell-sdk/src/raw.rs @@ -20,6 +20,7 @@ pub use openshell_core::proto; pub use openshell_core::proto::open_shell_client::OpenShellClient as GrpcClient; +pub use openshell_core::proto::sandbox_updates_client::SandboxUpdatesClient; pub use openshell_core::proto::{ CreateSandboxRequest, CreateSandboxTemplateRequest, CreateWorkspaceRequest, DeleteSandboxRequest, DeleteSandboxTemplateRequest, DeleteWorkspaceRequest, ExecSandboxRequest, @@ -28,9 +29,9 @@ pub use openshell_core::proto::{ ListSandboxTemplatesRequest, ListSandboxesRequest, ListWorkspacesRequest, ProviderDesiredIdentity, ProviderMutationKind, ProviderMutationReceipt, ProviderReadinessObservation, ProviderReadinessReason, ProviderReadinessState, - ProviderReadinessStatus, Sandbox, SandboxImageUpdate, SandboxPhase as ProtoSandboxPhase, - SandboxResources, SandboxServiceLevel, SandboxSpec as ProtoSandboxSpec, SandboxStartup, - SandboxTemplate, SandboxTemplateResponse, SandboxWorkloadConfig, SandboxWorkloadTemplate, + ProviderReadinessStatus, Sandbox, SandboxPhase as ProtoSandboxPhase, SandboxResources, + SandboxServiceLevel, SandboxSpec as ProtoSandboxSpec, SandboxStartup, SandboxTemplate, + SandboxTemplateResponse, SandboxWorkloadConfig, SandboxWorkloadTemplate, SandboxWorkloadTemplateProvenance, SandboxWorkloadTemplateSpec, ServiceStatus as ProtoServiceStatus, StartSandboxRequest, StopSandboxRequest, UpdateSandboxRequest, Workspace, @@ -43,3 +44,12 @@ pub type AuthedGrpcClient = GrpcClient< crate::EdgeAuthInterceptor, >, >; + +/// Sandbox-updates client using the same live auth slot and transport as the +/// main service client. +pub type AuthedSandboxUpdatesClient = SandboxUpdatesClient< + tonic::service::interceptor::InterceptedService< + tonic::transport::Channel, + crate::EdgeAuthInterceptor, + >, +>; diff --git a/crates/openshell-sdk/tests/client_mock.rs b/crates/openshell-sdk/tests/client_mock.rs index d360f45a80..db3f1fe996 100644 --- a/crates/openshell-sdk/tests/client_mock.rs +++ b/crates/openshell-sdk/tests/client_mock.rs @@ -10,6 +10,7 @@ use openshell_core::proto; use openshell_core::proto::open_shell_server::{OpenShell, OpenShellServer}; +use openshell_core::proto::sandbox_updates_server::{SandboxUpdates, SandboxUpdatesServer}; use openshell_sdk::{ AuthConfig, ClientConfig, ExecOptions, ListOptions, OpenShellClient, Refresh, RefreshError, RefreshedToken, SandboxPhase, SandboxSpec, SandboxTemplateCreateSpec, @@ -57,6 +58,7 @@ struct MockState { last_delete_workspace: Mutex>, last_stop: Mutex>, last_start: Mutex>, + last_update: Mutex>, last_list_request: Mutex>, list_requests: Mutex>, last_exec_request: Mutex>, @@ -234,13 +236,6 @@ fn workload_template_proto(name: &str, workspace: &str) -> proto::SandboxWorkloa #[tonic::async_trait] impl OpenShell for TestOpenShell { - async fn update_sandbox( - &self, - _request: tonic::Request, - ) -> Result, Status> { - Err(Status::unimplemented("not implemented by test service")) - } - async fn peer_report_provider_readiness( &self, _request: tonic::Request, @@ -1108,16 +1103,40 @@ impl OpenShell for TestOpenShell { } } +#[tonic::async_trait] +impl SandboxUpdates for TestOpenShell { + async fn update_sandbox( + &self, + request: tonic::Request, + ) -> Result, Status> { + if let Some(expected) = &self.state.require_bearer { + let got = request + .metadata() + .get("authorization") + .and_then(|value| value.to_str().ok()); + if got != Some(expected.as_str()) { + return Err(Status::unauthenticated("invalid or missing bearer token")); + } + } + *self.state.last_update.lock().await = Some(request.into_inner()); + Ok(Response::new(proto::SandboxResponse::default())) + } +} + /// Spin up the mock gateway, return its endpoint URL. async fn start_mock(state: Arc) -> String { let listener = TcpListener::bind("127.0.0.1:0").await.unwrap(); let addr = listener.local_addr().unwrap(); let endpoint = format!("http://{addr}"); let stream = TcpListenerStream::new(listener); + let updates = SandboxUpdatesServer::new(TestOpenShell { + state: state.clone(), + }); let svc = OpenShellServer::new(TestOpenShell { state }); tokio::spawn(async move { let _ = tonic::transport::Server::builder() .add_service(svc) + .add_service(updates) .serve_with_incoming(stream) .await; }); @@ -2129,6 +2148,64 @@ async fn raw_grpc_fresh_refreshes_before_raw_call() { ); } +#[tokio::test] +async fn raw_sandbox_updates_shares_transport_and_live_auth_slot() { + let state = Arc::new(MockState { + require_bearer: Some("Bearer fresh-token".to_string()), + ..Default::default() + }); + let endpoint = start_mock(state.clone()).await; + let calls = Arc::new(AtomicU32::new(0)); + let mut config = ClientConfig::new(&endpoint); + config.auth = Some(AuthConfig::Oidc { + token: "stale-token".to_string(), + expires_at: Some( + std::time::SystemTime::now() + .duration_since(std::time::UNIX_EPOCH) + .unwrap() + .as_secs() + + 5, + ), + refresh: Some(Arc::new(OneShotRefresher { + calls: calls.clone(), + })), + }); + let client = OpenShellClient::connect(config).await.unwrap(); + let mut updates = client.raw_sandbox_updates(); + let request = proto::UpdateSandboxRequest { + workspace_scope: Some(proto::workspace_selector("team")), + name: "sandbox".into(), + image: "example/workload:new".into(), + expected_resource_version: 42, + request_id: "550e8400-e29b-41d4-a716-446655440000".into(), + }; + assert_eq!( + updates + .update_sandbox(request.clone()) + .await + .unwrap_err() + .code(), + tonic::Code::Unauthenticated + ); + assert_eq!(calls.load(Ordering::SeqCst), 0); + client + .raw_sandbox_updates_fresh() + .await + .unwrap() + .update_sandbox(request.clone()) + .await + .unwrap(); + assert_eq!(calls.load(Ordering::SeqCst), 1); + // Previously created raw clients read the same refreshed bearer slot. + updates.update_sandbox(request.clone()).await.unwrap(); + client + .raw_grpc() + .health(proto::HealthRequest {}) + .await + .unwrap(); + assert_eq!(*state.last_update.lock().await, Some(request)); +} + #[tokio::test] async fn watch_logs_forwards_logs_and_warnings() { let state = Arc::new(MockState { diff --git a/crates/openshell-sdk/tests/sandbox_status_compatibility.rs b/crates/openshell-sdk/tests/sandbox_status_compatibility.rs new file mode 100644 index 0000000000..7a080a381f --- /dev/null +++ b/crates/openshell-sdk/tests/sandbox_status_compatibility.rs @@ -0,0 +1,31 @@ +// SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +// SPDX-License-Identifier: Apache-2.0 + +//! Compile-time source-compatibility fixture for the v0.1.5 public status shape. + +use openshell_sdk::raw::proto::SandboxStatus; + +#[test] +fn baseline_exhaustive_sandbox_status_literal_still_compiles() { + // Intentionally no `..Default::default()`: adding even an optional public + // field breaks existing downstream Rust exhaustive struct literals. + let status = SandboxStatus { + agent_pod: String::new(), + agent_fd: String::new(), + sandbox_fd: String::new(), + conditions: Vec::new(), + phase: 0, + current_policy_version: 0, + main_process_instance_id: String::new(), + exit_code: None, + endpoint_statuses: Vec::new(), + configuration_admission: None, + configuration_activated: None, + provisioning: None, + restart_count: 0, + next_restart_time: None, + main_process_started_time: None, + last_token_grant_failure: None, + }; + assert_eq!(status, SandboxStatus::default()); +} diff --git a/crates/openshell-server/build.rs b/crates/openshell-server/build.rs index c061cb0b6d..6230f8d259 100644 --- a/crates/openshell-server/build.rs +++ b/crates/openshell-server/build.rs @@ -30,8 +30,10 @@ fn main() -> Result<(), Box> { let storage_proto_dir = manifest_dir.join("proto"); let public_proto_dir = manifest_dir.join("../../proto"); let storage_proto = storage_proto_dir.join("storage.proto"); + let image_proto = storage_proto_dir.join("sandbox_image.proto"); println!("cargo:rerun-if-changed={}", storage_proto.display()); + println!("cargo:rerun-if-changed={}", image_proto.display()); for imported_proto in [ "datamodel.proto", "openshell.proto", @@ -71,7 +73,7 @@ fn main() -> Result<(), Box> { "::openshell_core::proto::sandbox::v1", ) .file_descriptor_set_path(&descriptor_path) - .compile_with_config(proto_config, &[storage_proto], &include_dirs)?; + .compile_with_config(proto_config, &[storage_proto, image_proto], &include_dirs)?; Ok(()) } diff --git a/crates/openshell-server/proto/sandbox_image.proto b/crates/openshell-server/proto/sandbox_image.proto new file mode 100644 index 0000000000..8d3e3f030d --- /dev/null +++ b/crates/openshell-server/proto/sandbox_image.proto @@ -0,0 +1,25 @@ +// SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +// SPDX-License-Identifier: Apache-2.0 +syntax = "proto3"; + +// A new private format; frozen openshell.storage.v1 remains unchanged. +package openshell.storage.image.v1; +import "openshell.proto"; + +// Gateway-private image mutation state. Never embed this in public SandboxStatus: +// older gateways may rewrite public protobufs without retaining unknown fields. +message StoredSandboxImageUpdate { + string operation_id = 1; + string previous_image = 2; + string image = 3; + uint64 revision = 4; +} + +message StoredSandboxImageState { + string sandbox_id = 1; + uint64 revision = 2; + StoredSandboxImageUpdate pending = 3; + // Original presence and attempt identity while the interlock is held. + // Completion preserves newer diagnostics and clock edits on the live record. + openshell.v1.SandboxProvisioning previous_provisioning = 4; +} diff --git a/crates/openshell-server/src/cli.rs b/crates/openshell-server/src/cli.rs index f7e0b31efb..f7262bb985 100644 --- a/crates/openshell-server/src/cli.rs +++ b/crates/openshell-server/src/cli.rs @@ -299,6 +299,11 @@ struct RunArgs { action = ArgAction::Set )] enable_websocket_tunnel: bool, + + /// Activate image updates only after retiring every incompatible gateway + /// and settling its outstanding driver operations. See HA upgrade guidance. + #[arg(long, env = "OPENSHELL_ENABLE_SANDBOX_IMAGE_UPDATES", default_value_t = false, action = ArgAction::Set)] + enable_sandbox_image_updates: bool, } pub fn command() -> Command { @@ -566,6 +571,7 @@ fn prepare_server_config_with_drivers( .with_server_sans(args.server_sans.clone()) .with_loopback_service_http(args.enable_loopback_service_http) .with_websocket_tunnel(args.enable_websocket_tunnel); + config.enable_sandbox_image_updates = args.enable_sandbox_image_updates; if let Some(sources) = file .as_ref() .and_then(|file| file.openshell.gateway.provider_profile_sources.clone()) @@ -1251,6 +1257,11 @@ fn merge_file_into_args(args: &mut RunArgs, file: &GatewayFileSection, matches: { args.enable_websocket_tunnel = enabled; } + if let Some(enabled) = file.enable_sandbox_image_updates + && arg_defaulted(matches, "enable_sandbox_image_updates") + { + args.enable_sandbox_image_updates = enabled; + } if let Some(mtls_auth) = &file.mtls_auth && arg_defaulted(matches, "enable_mtls_auth") { @@ -2705,6 +2716,43 @@ mod tests { toml::from_str(toml).expect("valid TOML in test fixture") } + #[test] + fn image_update_activation_defaults_off_and_file_requires_explicit_opt_in() { + Environment::new().remove("OPENSHELL_ENABLE_SANDBOX_IMAGE_UPDATES").run(|| { + let (mut args, matches) = parse_with_args(&["openshell-gateway"]); + assert!(!args.enable_sandbox_image_updates); + assert!(!openshell_core::Config::new(None).enable_sandbox_image_updates); + let file = config_file_from_toml("[openshell]\nversion = 2\n[openshell.gateway]\nenable_sandbox_image_updates = true\n"); + merge_file_into_args(&mut args, &file.openshell.gateway, &matches); + assert!(args.enable_sandbox_image_updates); + }); + } + + #[test] + fn explicit_cli_or_environment_disable_overrides_file_activation() { + let file = config_file_from_toml( + "[openshell]\nversion = 2\n[openshell.gateway]\nenable_sandbox_image_updates = true\n", + ); + Environment::new() + .remove("OPENSHELL_ENABLE_SANDBOX_IMAGE_UPDATES") + .run(|| { + let (mut args, matches) = parse_with_args(&[ + "openshell-gateway", + "--enable-sandbox-image-updates", + "false", + ]); + merge_file_into_args(&mut args, &file.openshell.gateway, &matches); + assert!(!args.enable_sandbox_image_updates); + }); + Environment::new() + .set("OPENSHELL_ENABLE_SANDBOX_IMAGE_UPDATES", "false") + .run(|| { + let (mut args, matches) = parse_with_args(&["openshell-gateway"]); + merge_file_into_args(&mut args, &file.openshell.gateway, &matches); + assert!(!args.enable_sandbox_image_updates); + }); + } + #[test] fn rejects_legacy_drivers_flag() { let error = command() diff --git a/crates/openshell-server/src/compute/image_update.rs b/crates/openshell-server/src/compute/image_update.rs index 5b48e93b87..3eb11f65f3 100644 --- a/crates/openshell-server/src/compute/image_update.rs +++ b/crates/openshell-server/src/compute/image_update.rs @@ -1,27 +1,47 @@ // SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. // SPDX-License-Identifier: Apache-2.0 -//! Stopped-only image changes. Persist intent before touching the driver so a -//! lost response cannot allow Start to run a different image than the gateway. +//! Stopped-only image changes with private durable intent and an operation +//! interlock understood by supported older gateways. -use super::{ - ComputeRuntime, START_PHASE_CAS_RETRY_LIMIT, provisioning_operation, - sandbox_compute_runtime_identity, -}; +use super::{ComputeRuntime, provisioning_operation, sandbox_compute_runtime_identity}; +use crate::storage_proto::StoredSandboxImageUpdate as SandboxImageUpdate; use openshell_core::extension_protocol::COMPUTE_UPDATE_SANDBOX_IMAGE; use openshell_core::proto::compute::v1::UpdateSandboxImageRequest; -use openshell_core::proto::{Sandbox, SandboxImageUpdate, SandboxPhase}; +use openshell_core::proto::{Sandbox, SandboxPhase}; use openshell_core::{GetResourceVersion, ObjectId, ObjectName}; use tonic::{Request, Status}; use tracing::info; impl ComputeRuntime { + pub(crate) fn with_sandbox_image_updates(mut self, enabled: bool) -> Self { + self.image_updates_enabled = enabled; + self + } + pub(crate) async fn update_sandbox_image( &self, sandbox_id: &str, image: String, expected_resource_version: u64, ) -> Result { + // Explicit operator activation follows retirement of incompatible + // gateways and their outstanding driver work. Refuse before preflight + // or durable effects; a cached placement ring is not a version proof. + if !self.image_updates_enabled { + return Err(Status::failed_precondition( + "sandbox image updates are disabled; complete the compatible deployment rollout before activating them", + )); + } + self.store + .ensure_image_update_deployment_compatible() + .await + .map_err(|error| match error { + crate::persistence::PersistenceError::Config(message) => { + Status::failed_precondition(message) + } + _ => Status::unavailable("cannot verify image-update deployment compatibility"), + })?; if !self .driver_info .negotiated_extension @@ -39,7 +59,7 @@ impl ComputeRuntime { .store .get_message::(sandbox_id) .await - .map_err(|error| Status::internal(format!("fetch sandbox failed: {error}")))? + .map_err(|_| Status::internal("fetch sandbox failed"))? .ok_or_else(|| Status::not_found("sandbox not found"))?; ensure_image_update_stopped(¤t)?; if current.get_resource_version() != expected_resource_version { @@ -50,6 +70,22 @@ impl ComputeRuntime { "update sandbox image", )); } + let state = self + .store + .get_sandbox_image_state(sandbox_id) + .await + .map_err(|_| Status::internal("fetch private sandbox image state failed"))?; + let pending = state.as_ref().and_then(|state| state.pending.clone()); + if let Some(intent) = &pending { + ensure_image_update_interlock(¤t, intent)?; + if intent.image != image { + return Err(Status::failed_precondition( + "another image update is pending; retry that image before selecting a different image", + )); + } + } else { + provisioning_operation::ensure_operation_settled(¤t)?; + } let old_image = current .spec .as_ref() @@ -57,42 +93,24 @@ impl ComputeRuntime { .map(|template| template.image.clone()) .filter(|image| !image.is_empty()) .ok_or_else(|| Status::failed_precondition("sandbox has no workload image"))?; - let pending = current - .status - .as_ref() - .and_then(|status| status.image_update.clone()); - if pending - .as_ref() - .is_some_and(|pending| pending.image != image) - { - return Err(Status::failed_precondition( - "another image update is pending; retry that image before selecting a different image", - )); - } if pending.is_none() && old_image == image { return Ok(current); } - let intent = if let Some(intent) = pending { - intent + let revision = state.as_ref().map_or(0, |state| state.revision); + let intent = pending.clone().unwrap_or_else(|| SandboxImageUpdate { + operation_id: uuid::Uuid::new_v4().to_string(), + previous_image: old_image, + image, + revision: revision.saturating_add(1), + }); + if pending.is_none() && revision == u64::MAX { + return Err(Status::resource_exhausted( + "sandbox image revision exhausted", + )); + } + let accepted = if pending.is_some() { + current } else { - let revision = current - .status - .as_ref() - .map_or(0, |status| status.image_revision) - .checked_add(1) - .ok_or_else(|| Status::resource_exhausted("sandbox image revision exhausted"))?; - SandboxImageUpdate { - operation_id: uuid::Uuid::new_v4().to_string(), - previous_image: old_image, - image: image.clone(), - revision, - } - }; - if current - .status - .as_ref() - .is_none_or(|status| status.image_update.is_none()) - { let request = image_update_driver_request(¤t, &intent, true); self.driver .call_owned( @@ -103,52 +121,32 @@ impl ComputeRuntime { }, ) .await?; - } - let pending = if current - .status - .as_ref() - .is_some_and(|status| status.image_update.is_some()) - { - current - } else { - let intent_for_write = intent.clone(); + // The private intent, desired image, and OLD-understood pending + // operation flag commit in one version-fenced transaction. self.store - .update_message_cas::( + .begin_sandbox_image_update( sandbox_id, expected_resource_version, - move |sandbox| { - sandbox - .spec - .as_mut() - .expect("validated spec") - .template - .as_mut() - .expect("validated template") - .image - .clone_from(&image); - let status = sandbox.status.get_or_insert_with(Default::default); - status.image_revision = intent_for_write.revision; - status.image_update = Some(intent_for_write.clone()); - }, + revision, + &intent, ) .await .map_err(|error| { crate::grpc::persistence_error_to_status(error, "record sandbox image update") })? }; - self.sandbox_index.update_from_sandbox(&pending); + self.sandbox_index.update_from_sandbox(&accepted); self.sandbox_watch_bus.notify(sandbox_id); drop(sandbox_guard); - - // The durable intent commits ownership. Cancellation of the public RPC - // must not release the lifecycle gate while the driver can still apply. let runtime = self.clone(); tokio::spawn(async move { let _lifecycle_guard = lifecycle_guard; - runtime.complete_image_update(pending, intent).await + runtime.complete_image_update(accepted, intent).await }) .await - .map_err(|error| Status::internal(format!("sandbox image update worker failed: {error}")))? + .map_err(|_| { + Status::internal("sandbox image update worker failed; intent remains pending") + })? } async fn complete_image_update( @@ -156,66 +154,62 @@ impl ComputeRuntime { pending: Sandbox, intent: SandboxImageUpdate, ) -> Result { + ensure_image_update_interlock(&pending, &intent)?; let request = image_update_driver_request(&pending, &intent, false); - self.driver - .call_owned(openshell_otel::rpc::UPDATE_SANDBOX_IMAGE, Some(pending.object_id()), move |driver| async move { - driver.update_sandbox_image(Request::new(request)).await - }) - .await?; - - // Watchers may have advanced the resource version. Never restore an old - // record or overwrite a concurrent deletion to acknowledge the driver. + self.driver.call_owned(openshell_otel::rpc::UPDATE_SANDBOX_IMAGE, Some(pending.object_id()), + move |driver| async move { driver.update_sandbox_image(Request::new(request)).await }).await?; let _guard = self.lock_sandbox_local(pending.object_id()).await; - for _ in 0..START_PHASE_CAS_RETRY_LIMIT { - let current = self - .store - .get_message::(pending.object_id()) - .await - .map_err(|error| Status::internal(format!("reload image update failed: {error}")))? - .ok_or_else(|| Status::not_found("sandbox was deleted"))?; - ensure_image_update_stopped(¤t)?; - if current - .status - .as_ref() - .and_then(|status| status.image_update.as_ref()) - != Some(&intent) - { - return Err(Status::aborted("sandbox image update intent changed")); - } - match self - .store - .update_message_cas::( - pending.object_id(), - current.get_resource_version(), - |sandbox| { - sandbox - .status - .as_mut() - .expect("pending status") - .image_update = None; - }, - ) - .await - { - Ok(updated) => { - self.sandbox_index.update_from_sandbox(&updated); - self.sandbox_watch_bus.notify(updated.object_id()); - info!(sandbox_id = %updated.object_id(), operation_id = %intent.operation_id, "Sandbox workload image updated; sandbox remains stopped"); - return Ok(updated); - } - Err(crate::persistence::PersistenceError::Conflict { .. }) => {} - Err(error) => { - return Err(crate::grpc::persistence_error_to_status( - error, - "complete sandbox image update", - )); - } - } + // An ambiguous error NEVER clears either the private intent or the + // public operation interlock. Only exact successful reconciliation can. + let updated = self + .store + .complete_sandbox_image_update(pending.object_id(), &intent) + .await + .map_err(|error| { + crate::grpc::persistence_error_to_status(error, "complete sandbox image update") + })?; + self.sandbox_index.update_from_sandbox(&updated); + self.sandbox_watch_bus.notify(updated.object_id()); + info!(sandbox_id = %updated.object_id(), operation_id = %intent.operation_id, + "Sandbox workload image updated; sandbox remains stopped"); + Ok(updated) + } + + pub(super) async fn ensure_no_pending_image_update( + &self, + sandbox: &Sandbox, + ) -> Result<(), Status> { + let state = self + .store + .get_sandbox_image_state(sandbox.object_id()) + .await + .map_err(|_| Status::unavailable("cannot read private sandbox image state"))?; + if state.as_ref().is_some_and(|state| state.pending.is_some()) { + return Err(Status::failed_precondition( + "sandbox image update is pending; read the current resource version and retry UpdateSandbox with the same image before starting", + )); } - Err(Status::aborted( - "sandbox changed while acknowledging image update; read and retry the pending image", - )) + Ok(()) + } +} + +fn ensure_image_update_interlock( + sandbox: &Sandbox, + intent: &SandboxImageUpdate, +) -> Result<(), Status> { + if sandbox + .status + .as_ref() + .and_then(|status| status.provisioning.as_ref()) + .is_none_or(|record| { + !record.driver_operation_pending || record.driver_operation_id != intent.operation_id + }) + { + return Err(Status::aborted( + "sandbox image-update operation interlock changed", + )); } + Ok(()) } fn image_update_driver_request( @@ -236,7 +230,6 @@ fn image_update_driver_request( } fn ensure_image_update_stopped(sandbox: &Sandbox) -> Result<(), Status> { - provisioning_operation::ensure_operation_settled(sandbox)?; if sandbox.phase() != SandboxPhase::Stopped as i32 || sandbox .metadata @@ -250,22 +243,6 @@ fn ensure_image_update_stopped(sandbox: &Sandbox) -> Result<(), Status> { Ok(()) } -/// Checked both before and after lifecycle locking by Start. A failed driver -/// response does not prove it had no effects, so only a successful retry clears -/// the durable intent. Ordinary stop and deletion never clear it. -pub(super) fn ensure_no_pending_image_update(sandbox: &Sandbox) -> Result<(), Status> { - if sandbox - .status - .as_ref() - .is_some_and(|status| status.image_update.is_some()) - { - return Err(Status::failed_precondition( - "sandbox image update is pending; read the current resource version and retry UpdateSandbox with the same image before starting", - )); - } - Ok(()) -} - #[cfg(test)] mod tests { use super::*; @@ -300,6 +277,7 @@ mod tests { ) .await .unwrap(); + runtime.image_updates_enabled = true; if supported { runtime .driver_info @@ -380,8 +358,15 @@ mod tests { original.metadata.as_ref().unwrap().labels ); assert_eq!(updated.phase(), SandboxPhase::Stopped as i32); - assert!(updated.status.as_ref().unwrap().image_update.is_none()); - assert_eq!(updated.status.as_ref().unwrap().image_revision, 1); + let state = runtime + .store + .get_sandbox_image_state(updated.object_id()) + .await + .unwrap() + .unwrap(); + assert!(state.pending.is_none()); + assert_eq!(state.revision, 1); + assert_eq!(updated.status, original.status); let calls = image_calls(&driver); assert_eq!(calls.len(), 1); assert_eq!(calls[0].expected_image, "example/workload:old"); @@ -416,7 +401,16 @@ mod tests { ) .await .unwrap(); - assert_eq!(back.status.as_ref().unwrap().image_revision, 2); + assert_eq!( + runtime + .store + .get_sandbox_image_state(back.object_id()) + .await + .unwrap() + .unwrap() + .revision, + 2 + ); assert_eq!(image_calls(&driver)[1].revision, 2); } @@ -575,6 +569,13 @@ mod tests { ) .await .unwrap(); + let upgraded_revision = runtime + .store + .get_sandbox_image_state(upgraded.object_id()) + .await + .unwrap() + .unwrap() + .revision; let starting = runtime .start_sandbox("default", original.object_name()) .await @@ -669,8 +670,14 @@ mod tests { .await .unwrap(); assert_eq!( - corrected.status.as_ref().unwrap().image_revision, - upgraded.status.as_ref().unwrap().image_revision + 1 + runtime + .store + .get_sandbox_image_state(corrected.object_id()) + .await + .unwrap() + .unwrap() + .revision, + upgraded_revision + 1 ); assert_eq!(corrected.object_id(), original.object_id()); assert_eq!( @@ -729,7 +736,16 @@ mod tests { .await .unwrap() .unwrap(); - assert!(pending.status.as_ref().unwrap().image_update.is_some()); + assert!( + runtime + .store + .get_sandbox_image_state(pending.object_id()) + .await + .unwrap() + .unwrap() + .pending + .is_some() + ); assert_eq!( runtime .start_sandbox("default", original.object_name()) @@ -759,44 +775,336 @@ mod tests { ) .await .unwrap(); - assert!(complete.status.as_ref().unwrap().image_update.is_none()); + assert!( + runtime + .store + .get_sandbox_image_state(complete.object_id()) + .await + .unwrap() + .unwrap() + .pending + .is_none() + ); let calls = image_calls(&driver); assert_eq!(calls.len(), 2); assert_eq!(calls[0], calls[1]); } - #[test] - fn image_update_intent_survives_driver_status_replacement() { - let intent = SandboxImageUpdate { - operation_id: "operation".into(), - previous_image: "old".into(), - image: "new".into(), - revision: 1, - }; + #[tokio::test] + async fn image_update_intent_survives_driver_status_replacement() { + let (runtime, driver, original) = fixture(true).await; + driver.set_image_update_error(Some(Code::Unavailable)); + runtime + .update_sandbox_image( + original.object_id(), + "example/workload:new".into(), + original.get_resource_version(), + ) + .await + .unwrap_err(); + let expected = runtime + .store + .get_sandbox_image_state(original.object_id()) + .await + .unwrap() + .unwrap(); + let mut sandbox = runtime + .store + .get_message::(original.object_id()) + .await + .unwrap() + .unwrap(); let grant_failure = Box::new(openshell_core::proto::TokenGrantFailureObservation { destination_host: "api.example.com".into(), ..Default::default() }); - let mut sandbox = Sandbox::default(); - sandbox.set_phase(SandboxPhase::Stopped as i32); - let status = sandbox.status.as_mut().unwrap(); - status.image_update = Some(intent.clone()); - status.image_revision = 1; - status.last_token_grant_failure = Some(grant_failure.clone()); + sandbox.status.as_mut().unwrap().last_token_grant_failure = Some(grant_failure.clone()); let incoming = DriverSandbox { - name: "test".into(), + id: original.object_id().into(), + name: original.object_name().into(), status: Some(DriverSandboxStatus::default()), ..Default::default() }; apply_driver_snapshot(&mut sandbox, &incoming, false, false); + runtime.store.put_message(&sandbox).await.unwrap(); assert_eq!( - sandbox.status.as_ref().unwrap().image_update.as_ref(), - Some(&intent) + runtime + .store + .get_sandbox_image_state(original.object_id()) + .await + .unwrap() + .unwrap(), + expected + ); + assert!( + sandbox + .status + .as_ref() + .unwrap() + .provisioning + .as_ref() + .unwrap() + .driver_operation_pending ); - assert_eq!(sandbox.status.as_ref().unwrap().image_revision, 1); assert_eq!( sandbox.status.as_ref().unwrap().last_token_grant_failure, Some(grant_failure) ); + assert_eq!( + runtime + .start_sandbox("default", original.object_name()) + .await + .unwrap_err() + .code(), + Code::FailedPrecondition + ); + } + + #[tokio::test] + async fn image_update_activation_is_disabled_by_default_without_effects() { + let (mut runtime, driver, original) = fixture(true).await; + runtime.image_updates_enabled = false; + assert_eq!( + runtime + .update_sandbox_image( + original.object_id(), + "example/workload:new".into(), + original.get_resource_version() + ) + .await + .unwrap_err() + .code(), + Code::FailedPrecondition + ); + assert!( + !driver + .calls() + .iter() + .any(|call| matches!(call, FakeComputeDriverCall::UpdateSandboxImage { .. })) + ); + assert_eq!( + runtime + .store + .get_message::(original.object_id()) + .await + .unwrap() + .unwrap(), + original + ); + assert!( + runtime + .store + .get_sandbox_image_state(original.object_id()) + .await + .unwrap() + .is_none() + ); + } + // These are the relevant pre-feature wire fields: no image-update fields + // exist in public status. Older readers already understand provisioning. + #[derive(Clone, PartialEq, prost::Message)] + struct LegacyStatus014 { + #[prost(int32, tag = "6")] + phase: i32, + #[prost(message, optional, tag = "13")] + provisioning: Option, + } + + #[tokio::test] + async fn legacy_status_roundtrip_cannot_erase_intent_or_bypass_lifecycle_interlock() { + use prost::Message; + let (runtime, driver, original) = fixture(true).await; + driver.set_image_update_error(Some(Code::Unavailable)); + runtime + .update_sandbox_image( + original.object_id(), + "example/workload:new".into(), + original.get_resource_version(), + ) + .await + .unwrap_err(); + let private_before = runtime + .store + .get_sandbox_image_state(original.object_id()) + .await + .unwrap() + .unwrap(); + let mut pending = runtime + .store + .get_message::(original.object_id()) + .await + .unwrap() + .unwrap(); + let legacy = + LegacyStatus014::decode(pending.status.as_ref().unwrap().encode_to_vec().as_slice()) + .unwrap(); + assert!( + legacy + .provisioning + .as_ref() + .unwrap() + .driver_operation_pending + ); + pending.status = Some( + openshell_core::proto::SandboxStatus::decode(legacy.encode_to_vec().as_slice()) + .unwrap(), + ); + runtime.store.put_message(&pending).await.unwrap(); + let rewritten = runtime + .store + .get_message::(original.object_id()) + .await + .unwrap() + .unwrap(); + assert_eq!( + runtime + .store + .get_sandbox_image_state(original.object_id()) + .await + .unwrap() + .unwrap(), + private_before + ); + // This existing guard is also present in v0.1.4, unlike our private check. + assert_eq!( + provisioning_operation::ensure_operation_settled(&rewritten) + .unwrap_err() + .code(), + Code::FailedPrecondition + ); + assert_eq!( + runtime + .start_sandbox("default", original.object_name()) + .await + .unwrap_err() + .code(), + Code::FailedPrecondition + ); + assert_eq!( + runtime + .stop_sandbox("default", original.object_name()) + .await + .unwrap_err() + .code(), + Code::FailedPrecondition + ); + assert_eq!( + runtime + .delete_sandbox("default", original.object_name()) + .await + .unwrap_err() + .code(), + Code::FailedPrecondition + ); + runtime + .recover_persisted_lifecycle_transitions() + .await + .unwrap(); + assert!(!driver.calls().iter().any(|call| matches!( + call, + FakeComputeDriverCall::StartSandbox { .. } + | FakeComputeDriverCall::StopSandbox { .. } + | FakeComputeDriverCall::DeleteSandbox { .. } + ))); + driver.set_image_update_error(None); + let complete = runtime + .update_sandbox_image( + original.object_id(), + "example/workload:new".into(), + rewritten.get_resource_version(), + ) + .await + .unwrap(); + assert!(provisioning_operation::ensure_operation_settled(&complete).is_ok()); + assert!( + runtime + .store + .get_sandbox_image_state(original.object_id()) + .await + .unwrap() + .unwrap() + .pending + .is_none() + ); + } + + #[tokio::test] + async fn stale_legacy_start_cas_loses_to_atomic_image_acceptance() { + let (runtime, driver, original) = fixture(true).await; + // Model an old Start paused after reading Stopped but before its CAS. + driver.set_image_update_error(Some(Code::Unavailable)); + runtime + .update_sandbox_image( + original.object_id(), + "example/workload:new".into(), + original.get_resource_version(), + ) + .await + .unwrap_err(); + let stale_start = runtime + .store + .update_message_cas::( + original.object_id(), + original.get_resource_version(), + |sandbox| sandbox.set_phase(SandboxPhase::Starting as i32), + ) + .await; + assert!(matches!( + stale_start, + Err(crate::persistence::PersistenceError::Conflict { .. }) + )); + let current = runtime + .store + .get_message::(original.object_id()) + .await + .unwrap() + .unwrap(); + assert!(provisioning_operation::ensure_operation_settled(¤t).is_err()); + assert!( + !driver + .calls() + .iter() + .any(|call| matches!(call, FakeComputeDriverCall::StartSandbox { .. })) + ); + } + + #[tokio::test] + async fn image_acceptance_loses_if_legacy_start_already_claimed_starting() { + let (runtime, driver, original) = fixture(true).await; + let starting = runtime + .store + .update_message_cas::( + original.object_id(), + original.get_resource_version(), + |sandbox| sandbox.set_phase(SandboxPhase::Starting as i32), + ) + .await + .unwrap(); + assert_eq!( + runtime + .update_sandbox_image( + original.object_id(), + "example/workload:new".into(), + starting.get_resource_version() + ) + .await + .unwrap_err() + .code(), + Code::FailedPrecondition + ); + assert!( + runtime + .store + .get_sandbox_image_state(original.object_id()) + .await + .unwrap() + .is_none() + ); + assert!( + !driver + .calls() + .iter() + .any(|call| matches!(call, FakeComputeDriverCall::UpdateSandboxImage { .. })) + ); } } diff --git a/crates/openshell-server/src/compute/mod.rs b/crates/openshell-server/src/compute/mod.rs index 23db3be484..3264b11c91 100644 --- a/crates/openshell-server/src/compute/mod.rs +++ b/crates/openshell-server/src/compute/mod.rs @@ -758,6 +758,7 @@ pub struct ComputeRuntime { driver_process: Option>, default_image: String, image_preparation_timeout_seconds: u32, + image_updates_enabled: bool, store: Arc, sandbox_index: SandboxIndex, sandbox_watch_bus: SandboxWatchBus, @@ -856,6 +857,7 @@ impl ComputeRuntime { driver_process, default_image, image_preparation_timeout_seconds: 1800, + image_updates_enabled: false, store, sandbox_index, sandbox_watch_bus, @@ -2002,7 +2004,7 @@ impl ComputeRuntime { self.validate_launch_signer_configured(authority.is_some())?; } provisioning_operation::ensure_operation_settled(&candidate)?; - image_update::ensure_no_pending_image_update(&candidate)?; + self.ensure_no_pending_image_update(&candidate).await?; if provisioning_deadline::timed_out(&candidate) && candidate .status @@ -2040,7 +2042,7 @@ impl ComputeRuntime { let mut attempts = 0; let (previous, starting, launch_authentication) = loop { provisioning_operation::ensure_operation_settled(¤t)?; - image_update::ensure_no_pending_image_update(¤t)?; + self.ensure_no_pending_image_update(¤t).await?; let phase = SandboxPhase::try_from(current.phase()).unwrap_or(SandboxPhase::Unknown); if phase == SandboxPhase::Ready { return Ok(current); @@ -6833,8 +6835,6 @@ fn public_status_from_driver( next_restart_time: None, main_process_started_time: None, last_token_grant_failure: None, - image_update: None, - image_revision: 0, } } @@ -6910,8 +6910,6 @@ fn apply_driver_snapshot( new_status.restart_count = old_status.restart_count; new_status.next_restart_time = old_status.next_restart_time; new_status.main_process_started_time = old_status.main_process_started_time; - new_status.image_update.clone_from(&old_status.image_update); - new_status.image_revision = old_status.image_revision; } phase = match old_phase { @@ -7752,6 +7750,7 @@ pub fn new_test_runtime_with_driver( driver_process: None, default_image: "openshell/sandbox:test".to_string(), image_preparation_timeout_seconds: 1800, + image_updates_enabled: false, store, sandbox_index: SandboxIndex::new(), sandbox_watch_bus: SandboxWatchBus::new(), @@ -8895,6 +8894,7 @@ mod tests { driver_process: None, default_image: "openshell/sandbox:test".to_string(), image_preparation_timeout_seconds: 1800, + image_updates_enabled: false, store, sandbox_index: SandboxIndex::new(), sandbox_watch_bus: SandboxWatchBus::new(), diff --git a/crates/openshell-server/src/config_file.rs b/crates/openshell-server/src/config_file.rs index bce0500a67..f3d5323369 100644 --- a/crates/openshell-server/src/config_file.rs +++ b/crates/openshell-server/src/config_file.rs @@ -140,6 +140,9 @@ pub struct GatewayFileSection { /// Absolute preparation budget for new attempts; existing deadlines persist. #[serde(default)] pub image_preparation_timeout_seconds: Option, + /// Explicit activation only after the compatible deployment rollout ends. + #[serde(default)] + pub enable_sandbox_image_updates: Option, #[serde(default)] pub grpc_rate_limit_requests: Option, #[serde(default)] diff --git a/crates/openshell-server/src/gateway_members.rs b/crates/openshell-server/src/gateway_members.rs index 33d68414df..6c122ded29 100644 --- a/crates/openshell-server/src/gateway_members.rs +++ b/crates/openshell-server/src/gateway_members.rs @@ -43,6 +43,9 @@ fn member_object_id(replica_id: &str) -> String { struct MemberPayload { replica_id: String, peer_endpoint: String, + /// Binary capability, not feature activation. Missing denotes old replicas. + #[serde(default)] + image_update_protocol: u32, } /// A gateway replica that was alive as of its last refresh. @@ -71,6 +74,7 @@ impl GatewayMemberIndex { let payload = MemberPayload { replica_id: replica_id.to_string(), peer_endpoint: peer_endpoint.to_string(), + image_update_protocol: 1, }; let bytes = serde_json::to_vec(&payload) .map_err(|err| PersistenceError::Encode(err.to_string()))?; diff --git a/crates/openshell-server/src/grpc/mod.rs b/crates/openshell-server/src/grpc/mod.rs index 134b5c183a..086a466585 100644 --- a/crates/openshell-server/src/grpc/mod.rs +++ b/crates/openshell-server/src/grpc/mod.rs @@ -240,6 +240,16 @@ impl OpenShellService { // Trait impl — thin delegation to submodules // --------------------------------------------------------------------------- +#[tonic::async_trait] +impl openshell_core::proto::sandbox_updates_server::SandboxUpdates for OpenShellService { + async fn update_sandbox( + &self, + request: Request, + ) -> Result, Status> { + mutation_replay::run(&self.state, request).await + } +} + #[tonic::async_trait] impl OpenShell for OpenShellService { async fn health( @@ -320,13 +330,6 @@ impl OpenShell for OpenShellService { mutation_replay::run(&self.state, request).await } - async fn update_sandbox( - &self, - request: Request, - ) -> Result, Status> { - mutation_replay::run(&self.state, request).await - } - async fn begin_rootfs_tar_staging( &self, request: Request, diff --git a/crates/openshell-server/src/grpc/mutation_replay.rs b/crates/openshell-server/src/grpc/mutation_replay.rs index eafbbd00ca..f67004e906 100644 --- a/crates/openshell-server/src/grpc/mutation_replay.rs +++ b/crates/openshell-server/src/grpc/mutation_replay.rs @@ -102,6 +102,9 @@ struct AuthorizationBarrier { pub(super) trait Mutation: Message + Default + Send + Sync + 'static { type Output: Send + 'static; const METHOD: &'static str; + /// Preserve legacy replay keys while allowing independent services to use + /// fully qualified identities for newly introduced methods. + const REPLAY_METHOD: &'static str = Self::METHOD; const PROTECTED: bool = false; // Streaming producers, not returned stream handles, confirm completion. const DEFERRED: bool = false; @@ -215,7 +218,7 @@ pub(super) async fn run( let bucket = format!("_mutation/{caller}"); let key = hash_json(&serde_json::json!([ caller, - M::METHOD, + M::REPLAY_METHOD, scope.name, request_id ]))?; diff --git a/crates/openshell-server/src/grpc/mutation_replay/ordinary.rs b/crates/openshell-server/src/grpc/mutation_replay/ordinary.rs index c0a5887728..a88c6abb9d 100644 --- a/crates/openshell-server/src/grpc/mutation_replay/ordinary.rs +++ b/crates/openshell-server/src/grpc/mutation_replay/ordinary.rs @@ -335,10 +335,11 @@ async fn profile_scope( } macro_rules! mutation { - ($req:ty, $resp:ty, $method:literal, $handler:path, $auth:expr, $capture:expr, $restore:expr) => { + ($req:ty, $resp:ty, $method:literal, $handler:path, $auth:expr, $capture:expr, $restore:expr $(, $replay_method:literal)?) => { impl Mutation for $req { type Output = $resp; const METHOD: &'static str = $method; + $(const REPLAY_METHOD: &'static str = $replay_method;)? const PROTECTED: bool = true; fn request_id(&self) -> &str { &self.request_id @@ -389,7 +390,7 @@ macro_rules! scoped_mutation { } macro_rules! sandbox_scoped_mutation { - ($req:ty, $resp:ty, $method:literal, $handler:path, $role:ident, $capture:expr, $restore:expr) => { + ($req:ty, $resp:ty, $method:literal, $handler:path, $role:ident, $capture:expr, $restore:expr $(, $replay_method:literal)?) => { mutation!( $req, $resp, @@ -406,6 +407,7 @@ macro_rules! sandbox_scoped_mutation { }, $capture, $restore + $(, $replay_method)? ); }; } @@ -423,7 +425,7 @@ fn sandbox_receipt( } macro_rules! sandbox_mutation { - ($req:ty, $method:literal, $handler:path) => { + ($req:ty, $method:literal, $handler:path $(, $replay_method:literal)?) => { sandbox_scoped_mutation!( $req, SandboxResponse, @@ -444,6 +446,7 @@ macro_rules! sandbox_mutation { service_urls: HashMap::new(), }) } + $(, $replay_method)? ); }; } @@ -474,7 +477,8 @@ scoped_mutation!( sandbox_mutation!( openshell_core::proto::UpdateSandboxRequest, "UpdateSandbox", - sandbox::handle_update_sandbox + sandbox::handle_update_sandbox, + "/openshell.v1.SandboxUpdates/UpdateSandbox" ); sandbox_mutation!( StartSandboxRequest, diff --git a/crates/openshell-server/src/grpc/sandbox/image_update_tests.rs b/crates/openshell-server/src/grpc/sandbox/image_update_tests.rs index b45259c88b..a4dc0a7dcf 100644 --- a/crates/openshell-server/src/grpc/sandbox/image_update_tests.rs +++ b/crates/openshell-server/src/grpc/sandbox/image_update_tests.rs @@ -7,8 +7,65 @@ use crate::test_support::{FakeComputeDriver, FakeComputeDriverCall}; use openshell_core::proto::UpdateSandboxRequest; use openshell_core::proto::compute::v1::GetCapabilitiesResponse; use openshell_core::proto::datamodel::v1::ObjectMeta; +use openshell_core::proto::sandbox_updates_client::SandboxUpdatesClient; use tonic::Code; +struct RunningService(tokio::task::JoinHandle<()>); + +impl Drop for RunningService { + fn drop(&mut self) { + self.0.abort(); + } +} + +async fn wire_client( + state: Arc, +) -> ( + SandboxUpdatesClient, + RunningService, +) { + use crate::multiplex::MultiplexService; + use openshell_core::proto::open_shell_client::OpenShellClient; + + let listener = TcpListener::bind("127.0.0.1:0").await.unwrap(); + let address = listener.local_addr().unwrap(); + // Use the production gateway multiplexer, not a standalone tonic server: + // this proves registration, routing and principal injection on the same + // listener as the unchanged OpenShell service. + let server = RunningService(tokio::spawn(async move { + let mut connections = tokio::task::JoinSet::new(); + loop { + let (stream, _) = listener.accept().await.unwrap(); + let service = MultiplexService::new(state.clone()); + connections.spawn(async move { service.serve(stream).await.unwrap() }); + } + })); + let channel = tonic::transport::Endpoint::from_shared(format!("http://{address}")) + .unwrap() + .connect() + .await + .unwrap(); + OpenShellClient::new(channel.clone()) + .health(openshell_core::proto::HealthRequest {}) + .await + .unwrap(); + (SandboxUpdatesClient::new(channel), server) +} + +#[test] +fn image_updates_have_their_own_authenticated_workspace_scoped_service() { + use crate::auth::method_authz::{AuthMode, lookup}; + use crate::grpc::mutation_replay::Mutation; + + let path = "/openshell.v1.SandboxUpdates/UpdateSandbox"; + let authorization = lookup(path).expect("new service must participate in gateway auth"); + assert_eq!(authorization.auth_mode, AuthMode::Bearer); + assert_eq!(authorization.scope.as_deref(), Some("sandbox:write")); + assert_eq!(authorization.workspace_role.as_deref(), Some("user")); + assert!(lookup("/openshell.v1.OpenShell/UpdateSandbox").is_none()); + assert_eq!(::REPLAY_METHOD, path); +} + fn request() -> UpdateSandboxRequest { UpdateSandboxRequest { workspace_scope: Some(openshell_core::proto::workspace_selector("default")), @@ -59,6 +116,10 @@ fn image_only_request_requires_target_image_and_conditional_version() { async fn state() -> (Arc, Arc, Sandbox) { let mut state = test_server_state().await; + Arc::get_mut(&mut state) + .unwrap() + .config + .enable_sandbox_image_updates = true; let driver = Arc::new( FakeComputeDriver::new().with_capabilities(GetCapabilitiesResponse { driver_name: "image-test".into(), @@ -83,7 +144,8 @@ async fn state() -> (Arc, Arc, Sandbox) { Arc::new(crate::supervisor_session::SupervisorSessionRegistry::new()), ) .await - .unwrap(); + .unwrap() + .with_sandbox_image_updates(true); Arc::get_mut(&mut state).unwrap().compute = compute; let mut sandbox = Sandbox { metadata: Some(ObjectMeta { @@ -156,12 +218,14 @@ async fn public_image_update_replays_without_reapplying_or_touching_same_name_re gateway_id: "test".into(), ttl_secs: None, }); + let (mut client, _server) = wire_client(state.clone()).await; let req = UpdateSandboxRequest { expected_resource_version: sandbox.get_resource_version(), request_id: uuid::Uuid::new_v4().to_string(), ..request() }; - let updated = super::super::mutation_replay::run(&state, authed_request(req.clone())) + let updated = client + .update_sandbox(req.clone()) .await .unwrap() .into_inner() @@ -179,9 +243,7 @@ async fn public_image_update_replays_without_reapplying_or_touching_same_name_re .image, req.image ); - let replay = super::super::mutation_replay::run(&state, authed_request(req.clone())) - .await - .unwrap(); + let replay = client.update_sandbox(req.clone()).await.unwrap(); assert_eq!(replay.metadata().get("openshell-replayed").unwrap(), "true"); assert_eq!(replay.get_ref().sandbox.as_ref().unwrap(), &updated); assert_eq!(driver.calls().iter().filter(|call| matches!(call, FakeComputeDriverCall::UpdateSandboxImage { request } if !request.validate_only)).count(), 1); @@ -190,10 +252,7 @@ async fn public_image_update_replays_without_reapplying_or_touching_same_name_re ..req.clone() }; assert_eq!( - super::super::mutation_replay::run(&state, authed_request(changed)) - .await - .unwrap_err() - .code(), + client.update_sandbox(changed).await.unwrap_err().code(), Code::FailedPrecondition ); state @@ -207,10 +266,7 @@ async fn public_image_update_replays_without_reapplying_or_touching_same_name_re metadata.resource_version = 0; state.store.put_message(&replacement).await.unwrap(); assert_eq!( - super::super::mutation_replay::run(&state, authed_request(req)) - .await - .unwrap_err() - .code(), + client.update_sandbox(req).await.unwrap_err().code(), Code::FailedPrecondition ); let replacement = state diff --git a/crates/openshell-server/src/lib.rs b/crates/openshell-server/src/lib.rs index 2fbaf63881..1e30be417f 100644 --- a/crates/openshell-server/src/lib.rs +++ b/crates/openshell-server/src/lib.rs @@ -421,6 +421,7 @@ impl ServerState { credentials: credentials::CredentialRuntime, ) -> Self { let replica_id = compute::lease::replica_id(); + let compute = compute.with_sandbox_image_updates(config.enable_sandbox_image_updates); compute.configure_ssh_identities(credentials.clone()); let peer_endpoint = derive_peer_endpoint(&config); let grpc_rate_limiter = multiplex::GrpcRateLimiter::from_config(&config); diff --git a/crates/openshell-server/src/multiplex.rs b/crates/openshell-server/src/multiplex.rs index 881b44fc80..7d3b30be48 100644 --- a/crates/openshell-server/src/multiplex.rs +++ b/crates/openshell-server/src/multiplex.rs @@ -18,6 +18,7 @@ use hyper_util::{ }; use metrics::{counter, histogram}; use openshell_core::proto::open_shell_server::OpenShellServer; +use openshell_core::proto::sandbox_updates_server::SandboxUpdatesServer; use openshell_core::{ Config, proto::{Provider, UpdateProviderRequest}, @@ -289,6 +290,13 @@ impl MultiplexService { Some(self.state.clone()), ); let reflection = self.state.reflection_service.clone(); + let sandbox_updates = SandboxUpdatesServer::new(OpenShellService::new(self.state.clone())) + .max_decoding_message_size(MAX_GRPC_DECODE_SIZE); + let sandbox_updates = GatewayInterceptorGrpcService::new( + sandbox_updates, + self.state.gateway_interceptors.clone(), + Some(self.state.clone()), + ); let authz_policy = self.state.config.oidc.as_ref().map(|oidc| AuthzPolicy { admin_role: oidc.admin_role.clone(), user_role: oidc.user_role.clone(), @@ -296,7 +304,7 @@ impl MultiplexService { }); let authenticator_chain = build_authenticator_chain(&self.state); let grpc_service = AuthGrpcRouter::with_peer_identity( - GrpcRouter::new(openshell, reflection), + GrpcRouter::new(openshell, reflection).with_sandbox_updates(sandbox_updates), authenticator_chain, authz_policy, self.state @@ -912,11 +920,12 @@ where } } -/// Combined gRPC service that routes between `OpenShell` and reflection. +/// Combined gRPC service for public gateway services and reflection. #[derive(Clone)] -pub struct GrpcRouter { +pub struct GrpcRouter { openshell: N, reflection: R, + sandbox_updates: Option, } impl GrpcRouter { @@ -924,13 +933,22 @@ impl GrpcRouter { Self { openshell, reflection, + sandbox_updates: None, + } + } + + fn with_sandbox_updates(self, sandbox_updates: U) -> GrpcRouter { + GrpcRouter { + openshell: self.openshell, + reflection: self.reflection, + sandbox_updates: Some(sandbox_updates), } } } pub const REFLECTION_PATH_PREFIX: &str = "/grpc.reflection.v1."; -impl tower::Service> for GrpcRouter +impl tower::Service> for GrpcRouter where N: tower::Service> + Clone + Send + 'static, N::Response: Send, @@ -941,6 +959,11 @@ where + Send + 'static, R::Future: Send, + U: tower::Service, Response = N::Response, Error = N::Error> + + Clone + + Send + + 'static, + U::Future: Send, B: Send + 'static, { type Response = N::Response; @@ -955,6 +978,13 @@ where if req.uri().path().starts_with(REFLECTION_PATH_PREFIX) { let mut svc = self.reflection.clone(); Box::pin(async move { svc.ready().await?.call(req).await }) + } else if req + .uri() + .path() + .starts_with("/openshell.v1.SandboxUpdates/") + && let Some(mut svc) = self.sandbox_updates.clone() + { + Box::pin(async move { svc.ready().await?.call(req).await }) } else { let mut svc = self.openshell.clone(); Box::pin(async move { svc.ready().await?.call(req).await }) @@ -2678,6 +2708,13 @@ mod tests { otel_span_name(&http::Method::POST, "/openshell.v1.OpenShell/CreateSandbox"), "openshell.v1.OpenShell/CreateSandbox" ); + assert_eq!( + otel_span_name( + &http::Method::POST, + "/openshell.v1.SandboxUpdates/UpdateSandbox" + ), + "openshell.v1.SandboxUpdates/UpdateSandbox" + ); } /// Non-RPC paths use a low-cardinality method-only name because sandbox @@ -2747,10 +2784,12 @@ mod tests { name, calls: calls.clone(), }; - let mut router = GrpcRouter::new(service("openshell"), service("reflection")); + let mut router = GrpcRouter::new(service("openshell"), service("reflection")) + .with_sandbox_updates(service("sandbox_updates")); for path in [ "/openshell.v1.OpenShell/Health", + "/openshell.v1.SandboxUpdates/UpdateSandbox", "/grpc.reflection.v1.ServerReflection/ServerReflectionInfo", ] { router @@ -2764,7 +2803,10 @@ mod tests { .unwrap(); } - assert_eq!(*calls.lock().unwrap(), vec!["openshell", "reflection"]); + assert_eq!( + *calls.lock().unwrap(), + vec!["openshell", "sandbox_updates", "reflection"] + ); } #[tokio::test] @@ -2856,7 +2898,10 @@ mod tests { .collect(); names.sort(); - assert_eq!(names, vec!["openshell.v1.OpenShell"]); + assert_eq!( + names, + vec!["openshell.v1.OpenShell", "openshell.v1.SandboxUpdates"] + ); let descriptor_response = responses.message().await.unwrap().unwrap(); let Some(MessageResponse::FileDescriptorResponse(response)) = @@ -2876,6 +2921,11 @@ mod tests { .is_some(), "a fresh descriptor pool must resolve the advertised service" ); + assert!( + reflected_pool + .get_service_by_name("openshell.v1.SandboxUpdates") + .is_some() + ); assert!( reflected_pool .get_message_by_name("openshell.v1.HealthRequest") diff --git a/crates/openshell-server/src/persistence/image_activation.rs b/crates/openshell-server/src/persistence/image_activation.rs new file mode 100644 index 0000000000..badbc0eb3f --- /dev/null +++ b/crates/openshell-server/src/persistence/image_activation.rs @@ -0,0 +1,315 @@ +// SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +// SPDX-License-Identifier: Apache-2.0 + +//! Additional, fail-closed deployment checks for operator-activated image updates. +//! +//! These snapshots are not a durable fence or proof that old processes have +//! stopped. Membership can expire, gateways need not advertise peer endpoints, +//! and a backend can connect after the check. The explicit operator activation +//! must attest that incompatible gateways have been drained and retired. The +//! old-understood pending-operation interlock, not these observations, protects +//! an accepted image mutation from a subsequent legacy Start. + +use super::{ObjectRecord, PersistenceError, PersistenceResult, Store, map_db_error}; +use crate::gateway_members::MEMBER_TTL; +use openshell_core::time::now_ms; + +/// Compatibility marker advertised by both gateway `PostgreSQL` connection pools. +/// +/// This marker describes a protocol, not an exact build version. It is neither +/// authentication nor a security boundary: database clients can set it too. +pub(super) const IMAGE_UPDATE_APPLICATION_NAME: &str = "openshell-image-update-v1"; + +const MEMBER_OBJECT_TYPE: &str = "gateway_member"; +const MEMBER_LIMIT: u32 = 1024; + +impl Store { + /// Reject observable incompatible or unknown gateway deployment participants. + /// + /// The caller separately enforces the default-off operator activation flag. + /// `SQLite` returns success under its supported single-gateway deployment + /// contract; this does not enforce process exclusion for a shared file. + /// `PostgreSQL` checks every client backend in this database, not merely + /// registered peers, and then strictly checks all fresh membership records. + /// Administrative clients without the marker also prevent activation. Any + /// database read failure propagates rather than granting compatibility. + pub async fn ensure_image_update_deployment_compatible(&self) -> PersistenceResult<()> { + let Self::Postgres(store) = self else { + return Ok(()); + }; + + let incompatible_backend: bool = sqlx::query_scalar( + r" +SELECT EXISTS ( + SELECT 1 FROM pg_stat_activity + WHERE datname = current_database() + AND (backend_type = 'client backend' OR backend_type IS NULL) + AND application_name IS DISTINCT FROM $1 +) +", + ) + .bind(IMAGE_UPDATE_APPLICATION_NAME) + .fetch_one(&store.pool) + .await + .map_err(|error| map_db_error(&error))?; + if incompatible_backend { + return Err(PersistenceError::Config( + "sandbox image updates require a uniformly compatible gateway deployment; \ + a PostgreSQL client backend has an unknown or legacy image-update protocol" + .into(), + )); + } + + // One extra row distinguishes a complete bounded snapshot from a + // truncated listing. Never silently treat uninspected rows as compatible. + let records = self + .list_by_type(MEMBER_OBJECT_TYPE, MEMBER_LIMIT + 1, 0) + .await?; + ensure_live_members_compatible(&records, now_ms()) + } +} + +fn ensure_live_members_compatible(records: &[ObjectRecord], now: i64) -> PersistenceResult<()> { + if records.len() > MEMBER_LIMIT as usize { + return Err(PersistenceError::Config( + "cannot establish image-update deployment compatibility: gateway membership listing exceeds its limit" + .into(), + )); + } + let ttl_ms = i64::try_from(MEMBER_TTL.as_millis()).unwrap_or(i64::MAX); + for record in records { + // Match membership liveness semantics, including clock-skew clamping. + // Ignoring expired records is not evidence that their processes stopped. + let age_ms = now.saturating_sub(record.updated_at_ms).max(0); + if age_ms >= ttl_ms { + continue; + } + let member: serde_json::Map = + serde_json::from_slice(&record.payload).map_err(|_| { + PersistenceError::Config( + "cannot establish image-update deployment compatibility: a live gateway membership record is not a valid JSON object" + .into(), + ) + })?; + let replica_id = member.get("replica_id").and_then(serde_json::Value::as_str); + let protocol = member + .get("image_update_protocol") + .and_then(serde_json::Value::as_u64); + if replica_id.is_none_or(|id| id.trim().is_empty()) || protocol != Some(1) { + return Err(PersistenceError::Config( + "sandbox image updates require every live gateway membership record to advertise image-update protocol 1 and a nonempty replica id" + .into(), + )); + } + } + Ok(()) +} + +#[cfg(test)] +mod tests { + use super::*; + + fn record(payload: &[u8], updated_at_ms: i64) -> ObjectRecord { + ObjectRecord { + object_type: MEMBER_OBJECT_TYPE.into(), + id: "gateway-member:gw-0".into(), + name: "gw-0".into(), + workspace: String::new(), + payload: payload.to_vec(), + created_at_ms: updated_at_ms, + updated_at_ms, + labels: None, + resource_version: 1, + } + } + + #[tokio::test] + async fn sqlite_uses_the_supported_single_gateway_contract() { + let store = super::super::test_store().await; + store + .ensure_image_update_deployment_compatible() + .await + .unwrap(); + } + + #[tokio::test] + #[ignore = "requires a disposable PostgreSQL database and CREATEDB privileges in OPENSHELL_TEST_POSTGRES_URL; run mise run test:rust:postgres"] + async fn postgres_image_activation_checks_client_backends_and_live_members() { + use super::super::test_postgres::TEST_POSTGRES_URL_ENV; + use super::super::{MutationLockSet, WriteCondition}; + use sqlx::postgres::{PgConnectOptions, PgPoolOptions}; + use std::time::Duration; + + // This check intentionally includes every backend in a database. A + // disposable schema would share unmarked test-control/other-test + // sessions and make its positive assertions dependent on test order. + // Keep the unmarked control pool in the original database instead. + let base = std::env::var(TEST_POSTGRES_URL_ENV) + .expect("OPENSHELL_TEST_POSTGRES_URL must name a disposable PostgreSQL database"); + let admin = PgPoolOptions::new() + .max_connections(1) + .connect(&base) + .await + .expect("connect to the test-control database"); + let database = format!("image_activation_{}", uuid::Uuid::new_v4().simple()); + sqlx::query(sqlx::AssertSqlSafe(format!("CREATE DATABASE {database}"))) + .execute(&admin) + .await + .expect("create a dedicated activation-test database (requires CREATEDB)"); + let mut url = url::Url::parse(&base).expect("parse the test PostgreSQL URL"); + url.set_path(&format!("/{database}")); + let first = Store::connect(url.as_str()).await.unwrap(); + let second = Store::connect(url.as_str()).await.unwrap(); + + // Exercise both data pools and a lazily opened mutation-lock pool. + let guard = second + .acquire_distributed_mutation_guard( + &MutationLockSet::sandbox_lifecycle("activation-test-sandbox"), + tokio::time::Instant::now() + Duration::from_secs(10), + ) + .await + .unwrap(); + first + .ensure_image_update_deployment_compatible() + .await + .expect("compatible data and lock pools must pass despite the other database's control pool"); + drop(guard); + + // No membership record is needed to detect an old or administrative + // client. Do not weaken the production filter to exempt this session. + let legacy_options = url + .as_str() + .parse::() + .unwrap() + .application_name("legacy-image-activation-test"); + let legacy = PgPoolOptions::new() + .max_connections(1) + .connect_with(legacy_options) + .await + .unwrap(); + assert!(matches!( + first.ensure_image_update_deployment_compatible().await, + Err(PersistenceError::Config(_)) + )); + legacy.close().await; + + // SQLx closing its socket can precede the server removing the backend. + // Bound this wait instead of depending on a fixed scheduling delay. + tokio::time::timeout(Duration::from_secs(5), async { + loop { + match first.ensure_image_update_deployment_compatible().await { + Ok(()) => break, + Err(PersistenceError::Config(_)) => { + tokio::time::sleep(Duration::from_millis(20)).await; + } + Err(error) => panic!("compatibility read failed: {error}"), + } + } + }) + .await + .expect("closed legacy backend must disappear from pg_stat_activity"); + + let member = first + .put_if( + MEMBER_OBJECT_TYPE, + "gateway-member:legacy", + "legacy", + "", + br#"{"replica_id":"legacy"}"#, + None, + WriteCondition::MustCreate, + ) + .await + .unwrap(); + assert!(matches!( + first.ensure_image_update_deployment_compatible().await, + Err(PersistenceError::Config(_)) + )); + first + .put_if( + MEMBER_OBJECT_TYPE, + "gateway-member:legacy", + "legacy", + "", + br#"{"replica_id":"legacy","image_update_protocol":1}"#, + None, + WriteCondition::MatchResourceVersion(member.resource_version), + ) + .await + .unwrap(); + first + .ensure_image_update_deployment_compatible() + .await + .unwrap(); + + first.close().await; + assert!(matches!( + first.ensure_image_update_deployment_compatible().await, + Err(PersistenceError::Database(_)) + )); + second.close().await; + sqlx::query(sqlx::AssertSqlSafe(format!( + "DROP DATABASE {database} WITH (FORCE)" + ))) + .execute(&admin) + .await + .expect("drop the isolated activation-test database"); + admin.close().await; + } + + #[test] + fn compatible_live_members_and_empty_snapshot_pass() { + assert!(ensure_live_members_compatible(&[], 100).is_ok()); + let member = record( + br#"{"replica_id":"gw-0","peer_endpoint":"https://gw-0:8443","image_update_protocol":1}"#, + 100, + ); + assert!(ensure_live_members_compatible(&[member], 100).is_ok()); + } + + #[test] + fn malformed_missing_unknown_or_ill_typed_protocols_fail_closed() { + let invalid: &[&[u8]] = &[ + b"not JSON", + br"[]", + br#"["gw-0",1]"#, + br"null", + br#"{"replica_id":"gw-0"}"#, + br#"{"replica_id":"gw-0","image_update_protocol":0}"#, + br#"{"replica_id":"gw-0","image_update_protocol":2}"#, + br#"{"replica_id":"gw-0","image_update_protocol":"1"}"#, + br#"{"replica_id":"gw-0","image_update_protocol":true}"#, + br#"{"replica_id":"gw-0","image_update_protocol":1.0}"#, + br#"{"image_update_protocol":1}"#, + br#"{"replica_id":"","image_update_protocol":1}"#, + br#"{"replica_id":" ","image_update_protocol":1}"#, + ]; + for payload in invalid { + assert!(ensure_live_members_compatible(&[record(payload, 100)], 100).is_err()); + } + } + + #[test] + fn expired_records_are_not_considered_live_but_future_timestamps_are() { + let ttl_ms = i64::try_from(MEMBER_TTL.as_millis()).unwrap(); + assert!(ensure_live_members_compatible(&[record(b"legacy", 100)], 100 + ttl_ms).is_ok()); + assert!( + ensure_live_members_compatible(&[record(b"legacy", 100)], 100 + ttl_ms - 1).is_err() + ); + assert!(ensure_live_members_compatible(&[record(b"legacy", 200)], 100).is_err()); + } + + #[test] + fn any_incompatible_live_member_rejects_the_snapshot() { + let compatible = record(br#"{"replica_id":"gw-0","image_update_protocol":1}"#, 100); + let legacy = record(br#"{"replica_id":"gw-1"}"#, 100); + assert!(ensure_live_members_compatible(&[compatible, legacy], 100).is_err()); + } + + #[test] + fn listing_truncation_fails_closed_even_when_extra_rows_are_expired() { + let records = vec![record(b"legacy", 0); MEMBER_LIMIT as usize + 1]; + let now = i64::try_from(MEMBER_TTL.as_millis()).unwrap(); + assert!(ensure_live_members_compatible(&records, now).is_err()); + } +} diff --git a/crates/openshell-server/src/persistence/mod.rs b/crates/openshell-server/src/persistence/mod.rs index faa6fdb444..0afcd6993d 100644 --- a/crates/openshell-server/src/persistence/mod.rs +++ b/crates/openshell-server/src/persistence/mod.rs @@ -3,12 +3,14 @@ //! Persistence layer for `OpenShell` Server. +mod image_activation; mod legacy_time_wire; pub mod lock_order; pub mod mutation_lock; mod postgres; #[cfg(test)] mod refresh_lock_tests; +mod sandbox_image; mod sqlite; pub use crate::storage_proto::{ diff --git a/crates/openshell-server/src/persistence/postgres.rs b/crates/openshell-server/src/persistence/postgres.rs index 64142e05b5..28380f2e9c 100644 --- a/crates/openshell-server/src/persistence/postgres.rs +++ b/crates/openshell-server/src/persistence/postgres.rs @@ -20,7 +20,7 @@ use openshell_core::SetResourceVersion; use openshell_core::proto::Sandbox; use prost::Message; use sqlx::pool::PoolConnection; -use sqlx::postgres::PgPoolOptions; +use sqlx::postgres::{PgConnection, PgPoolOptions}; use sqlx::{Connection, PgPool, Postgres, QueryBuilder, Row}; use std::sync::Arc; use std::sync::atomic::{AtomicU32, AtomicU64, Ordering}; @@ -28,6 +28,15 @@ use std::time::Duration; static POSTGRES_MIGRATOR: sqlx::migrate::Migrator = sqlx::migrate!("./migrations/postgres"); +/// A protocol capability, not an exact build version or an authorization +/// credential. Identify every pool connection, including after reconnect. +async fn identify_image_update_writer(connection: &mut PgConnection) -> Result<(), sqlx::Error> { + sqlx::query("SELECT set_config('application_name', 'openshell-image-update-v1', false)") + .execute(connection) + .await?; + Ok(()) +} + #[cfg(test)] pub(super) fn embedded_migration_sql(version: i64) -> Option<&'static str> { POSTGRES_MIGRATOR @@ -40,7 +49,7 @@ use super::{DELETE_MANY_BATCH_SIZE, DRAFT_CHUNK_OBJECT_TYPE, POLICY_OBJECT_TYPE} #[derive(Debug, Clone)] pub struct PostgresStore { - pool: PgPool, + pub(super) pool: PgPool, /// Dedicated connections for session-level mutation advisory locks. lock_pool: PgPool, /// How acquisitions and guards use the lock pool's connections. @@ -304,6 +313,7 @@ impl PostgresStore { ); let pool = PgPoolOptions::new() .max_connections(max_connections) + .after_connect(|connection, _| Box::pin(identify_image_update_writer(connection))) .connect(url) .await .map_err(|e| map_db_error(&e))?; @@ -320,6 +330,7 @@ impl PostgresStore { .bind(MUTATION_LOCK_TIMEOUT_SETTING) .execute(&mut *connection) .await?; + identify_image_update_writer(connection).await?; Ok(()) }) }) diff --git a/crates/openshell-server/src/persistence/sandbox_image.rs b/crates/openshell-server/src/persistence/sandbox_image.rs new file mode 100644 index 0000000000..88a2bc7d32 --- /dev/null +++ b/crates/openshell-server/src/persistence/sandbox_image.rs @@ -0,0 +1,1369 @@ +// SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +// SPDX-License-Identifier: Apache-2.0 + +//! Private, atomic image-update intent storage. +//! +//! The intent is deliberately not part of `Sandbox`: an older gateway decoding +//! and rewriting that public message must not erase an accepted update. Every +//! transaction locks the sandbox first, then its independent image-state row. + +use super::{PersistenceError, PersistenceResult, Store, current_time_ms, map_db_error}; +use crate::storage_proto::{StoredSandboxImageState, StoredSandboxImageUpdate}; +use openshell_core::SetResourceVersion; +use openshell_core::proto::{Sandbox, SandboxPhase, SandboxProvisioning}; +use prost::Message; +use sqlx::{Postgres, Sqlite, Transaction}; + +const IMAGE_STATE_OBJECT_TYPE: &str = "sandbox_image_state"; + +fn state_id(sandbox_id: &str) -> String { + format!("sandbox-image-state:{sandbox_id}") +} + +fn conflict(current_resource_version: Option) -> PersistenceError { + PersistenceError::Conflict { + current_resource_version, + } +} + +fn decode_state(sandbox_id: &str, payload: &[u8]) -> PersistenceResult { + let state = StoredSandboxImageState::decode(payload) + .map_err(|error| PersistenceError::Decode(error.to_string()))?; + if state.sandbox_id != sandbox_id + || state + .pending + .as_ref() + .is_some_and(|pending| pending.revision == 0 || pending.revision != state.revision) + || (state.pending.is_none() && state.previous_provisioning.is_some()) + || state + .previous_provisioning + .as_ref() + .is_some_and(|previous| previous.driver_operation_pending) + { + return Err(PersistenceError::Database( + "inconsistent stored sandbox image state".into(), + )); + } + Ok(state) +} + +fn decode_sandbox( + sandbox_id: &str, + payload: &[u8], + resource_version: i64, +) -> PersistenceResult { + if resource_version < 1 { + return Err(PersistenceError::Database( + "invalid sandbox resource version".into(), + )); + } + let payload = super::legacy_time_wire::migrate("sandbox", payload)?; + let mut sandbox = Sandbox::decode(payload.as_slice()) + .map_err(|error| PersistenceError::Decode(error.to_string()))?; + if sandbox + .metadata + .as_ref() + .is_none_or(|meta| meta.id != sandbox_id) + { + return Err(PersistenceError::Database( + "inconsistent stored sandbox identity".into(), + )); + } + // The SQL column, not a possibly stale protobuf field, is authoritative. + sandbox.set_resource_version(resource_version.cast_unsigned()); + Ok(sandbox) +} + +fn resource_version(sandbox: &Sandbox) -> u64 { + sandbox + .metadata + .as_ref() + .map_or(0, |meta| meta.resource_version) +} + +fn require_stopped(sandbox: &Sandbox) -> PersistenceResult<()> { + if sandbox + .metadata + .as_ref() + .is_none_or(|meta| meta.deletion_time.is_some()) + || sandbox + .status + .as_ref() + .is_none_or(|status| status.phase != SandboxPhase::Stopped as i32) + { + return Err(conflict(Some(resource_version(sandbox)))); + } + Ok(()) +} + +fn validate_intent(intent: &StoredSandboxImageUpdate) -> PersistenceResult<()> { + if intent.operation_id.is_empty() + || intent.previous_image.is_empty() + || intent.image.is_empty() + || intent.revision == 0 + { + return Err(PersistenceError::Encode( + "image update requires an operation id, both images, and a nonzero revision".into(), + )); + } + Ok(()) +} + +fn bump_resource_version(sandbox: &mut Sandbox) -> PersistenceResult<()> { + let next = resource_version(sandbox) + .checked_add(1) + .filter(|next| i64::try_from(*next).is_ok()) + .ok_or_else(|| PersistenceError::Encode("sandbox resource version exhausted".into()))?; + sandbox.set_resource_version(next); + Ok(()) +} + +/// Pure projection: all acceptance checks happen before either row is written. +fn project_begin( + mut sandbox: Sandbox, + state: Option, + expected_sandbox_resource_version: u64, + expected_revision: u64, + intent: &StoredSandboxImageUpdate, +) -> PersistenceResult<(Sandbox, StoredSandboxImageState)> { + let current_version = resource_version(&sandbox); + if expected_sandbox_resource_version == 0 + || expected_sandbox_resource_version != current_version + { + return Err(conflict(Some(current_version))); + } + require_stopped(&sandbox)?; + validate_intent(intent)?; + let mut state = state.unwrap_or_else(|| StoredSandboxImageState { + sandbox_id: sandbox + .metadata + .as_ref() + .map_or_else(String::new, |meta| meta.id.clone()), + revision: 0, + pending: None, + previous_provisioning: None, + }); + if state.revision != expected_revision || state.pending.is_some() { + return Err(conflict(Some(current_version))); + } + let next_revision = expected_revision + .checked_add(1) + .ok_or_else(|| PersistenceError::Encode("sandbox image revision exhausted".into()))?; + if intent.revision != next_revision { + return Err(conflict(Some(current_version))); + } + let previous_provisioning = sandbox + .status + .as_ref() + .and_then(|status| status.provisioning.clone()); + if previous_provisioning + .as_ref() + .is_some_and(|previous| previous.driver_operation_pending) + { + return Err(conflict(Some(current_version))); + } + let template = sandbox + .spec + .as_mut() + .and_then(|spec| spec.template.as_mut()) + .ok_or_else(|| conflict(Some(current_version)))?; + if template.image != intent.previous_image { + return Err(conflict(Some(current_version))); + } + template.image.clone_from(&intent.image); + state.revision = next_revision; + state.pending = Some(intent.clone()); + state.previous_provisioning = previous_provisioning; + let status = sandbox + .status + .as_mut() + .ok_or_else(|| conflict(Some(current_version)))?; + let operation = status + .provisioning + .get_or_insert_with(|| SandboxProvisioning { + attempt_id: format!("image-update:{}", intent.operation_id), + ..Default::default() + }); + // This is an existing, baseline-known lifecycle interlock. Old gateways + // retain it on ordinary status writes and refuse Start/Stop/Delete while + // it is pending. Do not settle it on an ambiguous driver error. + operation.driver_operation_pending = true; + operation + .driver_operation_id + .clone_from(&intent.operation_id); + bump_resource_version(&mut sandbox)?; + Ok((sandbox, state)) +} + +fn project_complete( + mut sandbox: Sandbox, + state: Option, + intent: &StoredSandboxImageUpdate, +) -> PersistenceResult<(Sandbox, StoredSandboxImageState)> { + let current_version = resource_version(&sandbox); + require_stopped(&sandbox)?; + validate_intent(intent)?; + let mut state = state.ok_or_else(|| conflict(Some(current_version)))?; + if state.revision != intent.revision || state.pending.as_ref() != Some(intent) { + return Err(conflict(Some(current_version))); + } + if sandbox + .spec + .as_ref() + .and_then(|spec| spec.template.as_ref()) + .is_none_or(|template| template.image != intent.image) + { + return Err(conflict(Some(current_version))); + } + let status = sandbox + .status + .as_mut() + .ok_or_else(|| conflict(Some(current_version)))?; + let expected_attempt = state.previous_provisioning.as_ref().map_or_else( + || format!("image-update:{}", intent.operation_id), + |previous| previous.attempt_id.clone(), + ); + let operation = status + .provisioning + .as_mut() + .ok_or_else(|| conflict(Some(current_version)))?; + if !operation.driver_operation_pending + || operation.driver_operation_id != intent.operation_id + || operation.attempt_id != expected_attempt + { + return Err(conflict(Some(current_version))); + } + // Retire only our flag on the CURRENT record. Restoring a saved snapshot + // would erase a concurrent provider attachment's accepted clock edit. + // Keep the newest operation ID to reject delayed older callbacks (ABA). + let unchanged_legacy_record = state.previous_provisioning.is_none() + && *operation + == SandboxProvisioning { + attempt_id: expected_attempt, + driver_operation_id: intent.operation_id.clone(), + driver_operation_pending: true, + ..Default::default() + }; + if unchanged_legacy_record { + status.provisioning = None; + } else { + operation.driver_operation_pending = false; + } + state.previous_provisioning = None; + state.pending = None; + // Completing an intent invalidates any Start CAS based on pending state. + bump_resource_version(&mut sandbox)?; + Ok((sandbox, state)) +} + +impl Store { + /// Read gateway-private image state by immutable sandbox identity. + pub async fn get_sandbox_image_state( + &self, + sandbox_id: &str, + ) -> PersistenceResult> { + let id = state_id(sandbox_id); + let payload = match self { + Self::Sqlite(store) => { + sqlx::query_scalar::<_, Vec>( + r#"SELECT "payload" FROM "objects" WHERE "object_type" = ?1 AND "id" = ?2"#, + ) + .bind(IMAGE_STATE_OBJECT_TYPE) + .bind(&id) + .fetch_optional(&store.pool) + .await + } + Self::Postgres(store) => { + sqlx::query_scalar::<_, Vec>( + "SELECT payload FROM objects WHERE object_type = $1 AND id = $2", + ) + .bind(IMAGE_STATE_OBJECT_TYPE) + .bind(&id) + .fetch_optional(&store.pool) + .await + } + } + .map_err(|error| map_db_error(&error))?; + payload + .map(|payload| decode_state(sandbox_id, &payload)) + .transpose() + } + + /// Atomically accept a stopped-sandbox image change and its private intent. + pub async fn begin_sandbox_image_update( + &self, + sandbox_id: &str, + expected_sandbox_resource_version: u64, + expected_revision: u64, + intent: &StoredSandboxImageUpdate, + ) -> PersistenceResult { + let mut tx = ImageTransaction::begin(self).await?; + let sandbox = tx.lock_sandbox(sandbox_id).await?; + let state = tx.lock_state(sandbox_id).await?; + let previous_version = resource_version(&sandbox); + let (sandbox, state) = project_begin( + sandbox, + state, + expected_sandbox_resource_version, + expected_revision, + intent, + )?; + tx.write_projection(sandbox_id, previous_version, &sandbox, &state) + .await?; + tx.commit().await?; + Ok(sandbox) + } + + /// Retire only the exact pending intent, retaining its monotonic revision. + pub async fn complete_sandbox_image_update( + &self, + sandbox_id: &str, + intent: &StoredSandboxImageUpdate, + ) -> PersistenceResult { + let mut tx = ImageTransaction::begin(self).await?; + let sandbox = tx.lock_sandbox(sandbox_id).await?; + let state = tx.lock_state(sandbox_id).await?; + let previous_version = resource_version(&sandbox); + let (sandbox, state) = project_complete(sandbox, state, intent)?; + tx.write_projection(sandbox_id, previous_version, &sandbox, &state) + .await?; + tx.commit().await?; + Ok(sandbox) + } +} + +/// Dropping an unfinished `SQLx` transaction rolls back both projections. +enum ImageTransaction { + Sqlite(Transaction<'static, Sqlite>), + Postgres(Transaction<'static, Postgres>), +} + +impl ImageTransaction { + async fn begin(store: &Store) -> PersistenceResult { + match store { + Store::Sqlite(store) => store + .pool + .begin_with("BEGIN IMMEDIATE") + .await + .map(Self::Sqlite), + Store::Postgres(store) => store.pool.begin().await.map(Self::Postgres), + } + .map_err(|error| map_db_error(&error)) + } + + async fn lock_sandbox(&mut self, sandbox_id: &str) -> PersistenceResult { + let row = match self { + Self::Sqlite(tx) => { + sqlx::query_as::<_, (Vec, i64)>( + r#"SELECT "payload", "resource_version" FROM "objects" +WHERE "object_type" = 'sandbox' AND "id" = ?1"#, + ) + .bind(sandbox_id) + .fetch_optional(&mut **tx) + .await + } + Self::Postgres(tx) => { + sqlx::query_as::<_, (Vec, i64)>( + "SELECT payload, resource_version FROM objects +WHERE object_type = 'sandbox' AND id = $1 FOR UPDATE", + ) + .bind(sandbox_id) + .fetch_optional(&mut **tx) + .await + } + } + .map_err(|error| map_db_error(&error))? + .ok_or_else(|| conflict(None))?; + decode_sandbox(sandbox_id, &row.0, row.1) + } + + async fn lock_state( + &mut self, + sandbox_id: &str, + ) -> PersistenceResult> { + let id = state_id(sandbox_id); + let payload = match self { + Self::Sqlite(tx) => { + sqlx::query_scalar::<_, Vec>( + r#"SELECT "payload" FROM "objects" WHERE "object_type" = ?1 AND "id" = ?2"#, + ) + .bind(IMAGE_STATE_OBJECT_TYPE) + .bind(&id) + .fetch_optional(&mut **tx) + .await + } + Self::Postgres(tx) => { + sqlx::query_scalar::<_, Vec>( + "SELECT payload FROM objects WHERE object_type = $1 AND id = $2 FOR UPDATE", + ) + .bind(IMAGE_STATE_OBJECT_TYPE) + .bind(&id) + .fetch_optional(&mut **tx) + .await + } + } + .map_err(|error| map_db_error(&error))?; + payload + .map(|payload| decode_state(sandbox_id, &payload)) + .transpose() + } + + async fn write_projection( + &mut self, + sandbox_id: &str, + previous_version: u64, + sandbox: &Sandbox, + state: &StoredSandboxImageState, + ) -> PersistenceResult<()> { + let previous_version_sql = i64::try_from(previous_version).map_err(|_| { + PersistenceError::Encode("sandbox resource version exceeds database range".into()) + })?; + let now_ms = current_time_ms(); + let sandbox_payload = sandbox.encode_to_vec(); + let affected = match self { + Self::Sqlite(tx) => sqlx::query( + r#"UPDATE "objects" +SET "payload" = ?2, "updated_at_ms" = ?3, "resource_version" = "resource_version" + 1 +WHERE "object_type" = 'sandbox' AND "id" = ?1 AND "resource_version" = ?4"#, + ) + .bind(sandbox_id) + .bind(&sandbox_payload) + .bind(now_ms) + .bind(previous_version_sql) + .execute(&mut **tx) + .await + .map(|result| result.rows_affected()), + Self::Postgres(tx) => sqlx::query( + "UPDATE objects +SET payload = $2, updated_at_ms = $3, resource_version = resource_version + 1 +WHERE object_type = 'sandbox' AND id = $1 AND resource_version = $4", + ) + .bind(sandbox_id) + .bind(&sandbox_payload) + .bind(now_ms) + .bind(previous_version_sql) + .execute(&mut **tx) + .await + .map(|result| result.rows_affected()), + } + .map_err(|error| map_db_error(&error))?; + if affected != 1 { + return Err(conflict(Some(previous_version))); + } + + let id = state_id(sandbox_id); + let state_payload = state.encode_to_vec(); + let affected = match self { + Self::Sqlite(tx) => sqlx::query( + r#"INSERT INTO "objects" ( + "object_type", "id", "name", "workspace", "payload", "created_at_ms", "updated_at_ms" +) VALUES (?1, ?2, NULL, '', ?3, ?4, ?4) +ON CONFLICT ("id") DO UPDATE +SET "payload" = excluded."payload", "updated_at_ms" = excluded."updated_at_ms", + "resource_version" = "objects"."resource_version" + 1 +WHERE "objects"."object_type" = ?1 AND "objects"."name" IS NULL AND "objects"."workspace" = ''"#, + ) + .bind(IMAGE_STATE_OBJECT_TYPE) + .bind(&id) + .bind(&state_payload) + .bind(now_ms) + .execute(&mut **tx) + .await + .map(|result| result.rows_affected()), + Self::Postgres(tx) => sqlx::query( + "INSERT INTO objects ( + object_type, id, name, workspace, payload, created_at_ms, updated_at_ms +) VALUES ($1, $2, NULL, '', $3, $4, $4) +ON CONFLICT (id) DO UPDATE +SET payload = EXCLUDED.payload, updated_at_ms = EXCLUDED.updated_at_ms, + resource_version = objects.resource_version + 1 +WHERE objects.object_type = $1 AND objects.name IS NULL AND objects.workspace = ''", + ) + .bind(IMAGE_STATE_OBJECT_TYPE) + .bind(&id) + .bind(&state_payload) + .bind(now_ms) + .execute(&mut **tx) + .await + .map(|result| result.rows_affected()), + } + .map_err(|error| map_db_error(&error))?; + if affected != 1 { + return Err(PersistenceError::Database( + "sandbox image state identity is already occupied".into(), + )); + } + Ok(()) + } + + async fn commit(self) -> PersistenceResult<()> { + match self { + Self::Sqlite(tx) => tx.commit().await, + Self::Postgres(tx) => tx.commit().await, + } + .map_err(|error| map_db_error(&error)) + } +} + +#[cfg(test)] +mod tests { + use super::*; + use openshell_core::proto::{ObjectMeta, SandboxSpec, SandboxStatus, SandboxTemplate}; + + fn sandbox() -> Sandbox { + Sandbox { + metadata: Some(ObjectMeta { + id: "sandbox-id".into(), + name: "sandbox-name".into(), + workspace: "default".into(), + resource_version: 5, + ..Default::default() + }), + spec: Some(SandboxSpec { + template: Some(SandboxTemplate { + image: "old-image".into(), + ..Default::default() + }), + ..Default::default() + }), + status: Some(SandboxStatus { + phase: SandboxPhase::Stopped as i32, + ..Default::default() + }), + ..Default::default() + } + } + + fn intent() -> StoredSandboxImageUpdate { + StoredSandboxImageUpdate { + operation_id: "operation-id".into(), + previous_image: "old-image".into(), + image: "new-image".into(), + revision: 1, + } + } + + fn image(sandbox: &Sandbox) -> &str { + &sandbox + .spec + .as_ref() + .unwrap() + .template + .as_ref() + .unwrap() + .image + } + + #[test] + fn begin_and_complete_project_image_and_baseline_known_interlock() { + let original = sandbox(); + let (accepted, state) = project_begin(original.clone(), None, 5, 0, &intent()).unwrap(); + assert_eq!(image(&accepted), "new-image"); + assert_eq!(resource_version(&accepted), 6); + let operation = accepted + .status + .as_ref() + .unwrap() + .provisioning + .as_ref() + .unwrap(); + assert!(operation.driver_operation_pending); + assert_eq!(operation.driver_operation_id, intent().operation_id); + assert_eq!(operation.attempt_id, "image-update:operation-id"); + assert!(operation.deadline.is_none()); + assert!(operation.preparation_deadline.is_none()); + assert!(state.previous_provisioning.is_none()); + assert_eq!(state.pending, Some(intent())); + let (completed, state) = project_complete(accepted, Some(state), &intent()).unwrap(); + assert_eq!(resource_version(&completed), 7); + assert_eq!(completed.status, original.status); + assert_eq!(state.revision, 1); + assert!(state.pending.is_none()); + assert!(state.previous_provisioning.is_none()); + } + + #[test] + fn completion_restores_existing_provisioning_except_last_operation_identity() { + let mut original = sandbox(); + let previous = SandboxProvisioning { + attempt_id: "previous-attempt".into(), + driver_operation_id: "previous-settled-operation".into(), + timeout_time: Some(prost_types::Timestamp { + seconds: 123, + nanos: 456, + }), + cleanup_completed_time: Some(prost_types::Timestamp { + seconds: 124, + nanos: 0, + }), + cleanup_error: "retained diagnostic".into(), + ..Default::default() + }; + original.status.as_mut().unwrap().provisioning = Some(previous.clone()); + let (accepted, state) = project_begin(original.clone(), None, 5, 0, &intent()).unwrap(); + assert_eq!(state.previous_provisioning, Some(previous)); + let (completed, cleared) = project_complete(accepted, Some(state), &intent()).unwrap(); + original + .status + .as_mut() + .unwrap() + .provisioning + .as_mut() + .unwrap() + .driver_operation_id = intent().operation_id; + assert_eq!(completed.status, original.status); + assert!(cleared.previous_provisioning.is_none()); + assert!(cleared.pending.is_none()); + assert_eq!(cleared.revision, 1); + } + + #[test] + fn delayed_previous_operation_cannot_match_completed_image_operation() { + let mut original = sandbox(); + let previous = SandboxProvisioning { + attempt_id: "retained-attempt".into(), + driver_operation_id: "delayed-operation".into(), + timeout_time: Some(prost_types::Timestamp { + seconds: 456, + nanos: 0, + }), + cleanup_completed_time: Some(prost_types::Timestamp { + seconds: 457, + nanos: 0, + }), + ..Default::default() + }; + original.status.as_mut().unwrap().provisioning = Some(previous.clone()); + let (accepted, state) = project_begin(original, None, 5, 0, &intent()).unwrap(); + let (completed, _) = project_complete(accepted, Some(state), &intent()).unwrap(); + let current = completed + .status + .as_ref() + .unwrap() + .provisioning + .as_ref() + .unwrap(); + // Baseline same_operation compares this pair. Preserve the attempt and + // timeout provenance without resurrecting the old callback's identity. + assert_ne!( + (¤t.attempt_id, ¤t.driver_operation_id), + (&previous.attempt_id, &previous.driver_operation_id) + ); + assert_eq!(current.attempt_id, previous.attempt_id); + assert_eq!(current.driver_operation_id, intent().operation_id); + assert!(!current.driver_operation_pending); + assert_eq!(current.timeout_time, previous.timeout_time); + assert_eq!( + current.cleanup_completed_time, + previous.cleanup_completed_time + ); + } + + #[test] + fn image_completion_preserves_concurrent_attachment_clock_edits() { + let mut original = sandbox(); + let mut previous = crate::compute::provisioning_deadline::new_preparation_record(0, 1800); + previous.driver_operation_id = "prior-operation".into(); + previous.attachment_change_id = "before-attachment".into(); + original.status.as_mut().unwrap().provisioning = Some(previous); + let (mut accepted, state) = project_begin(original, None, 5, 0, &intent()).unwrap(); + crate::compute::provisioning_deadline::attachments_changed(&mut accepted, 2_000); + let mut expected = accepted + .status + .as_ref() + .unwrap() + .provisioning + .as_ref() + .unwrap() + .clone(); + assert_ne!(expected.attachment_change_id, "before-attachment"); + expected.driver_operation_pending = false; + let (completed, state) = project_complete(accepted, Some(state), &intent()).unwrap(); + assert_eq!(completed.status.unwrap().provisioning, Some(expected)); + assert!(state.previous_provisioning.is_none()); + } + + #[test] + fn image_completion_cannot_settle_a_replaced_provisioning_attempt() { + let (mut accepted, state) = project_begin(sandbox(), None, 5, 0, &intent()).unwrap(); + accepted + .status + .as_mut() + .unwrap() + .provisioning + .as_mut() + .unwrap() + .attempt_id = "replacement-attempt".into(); + assert!(matches!( + project_complete(accepted, Some(state), &intent()), + Err(PersistenceError::Conflict { .. }) + )); + } + + #[test] + fn pending_driver_operation_is_not_overwritten_and_completion_requires_its_fence() { + let mut occupied = sandbox(); + occupied.status.as_mut().unwrap().provisioning = Some(SandboxProvisioning { + attempt_id: "other-attempt".into(), + driver_operation_pending: true, + driver_operation_id: "other-operation".into(), + ..Default::default() + }); + assert!(project_begin(occupied, None, 5, 0, &intent()).is_err()); + let (accepted, state) = project_begin(sandbox(), None, 5, 0, &intent()).unwrap(); + let mut missing = accepted.clone(); + missing.status.as_mut().unwrap().provisioning = None; + assert!(project_complete(missing, Some(state.clone()), &intent()).is_err()); + let mut cleared = accepted.clone(); + cleared + .status + .as_mut() + .unwrap() + .provisioning + .as_mut() + .unwrap() + .driver_operation_pending = false; + assert!(project_complete(cleared, Some(state.clone()), &intent()).is_err()); + let mut other = accepted; + other + .status + .as_mut() + .unwrap() + .provisioning + .as_mut() + .unwrap() + .driver_operation_id = "other".into(); + assert!(project_complete(other, Some(state), &intent()).is_err()); + } + + #[test] + fn begin_rejects_stale_versions_revisions_and_pending_updates() { + for version in [0, 4, 6] { + assert!(matches!( + project_begin(sandbox(), None, version, 0, &intent()), + Err(PersistenceError::Conflict { .. }) + )); + } + assert!(project_begin(sandbox(), None, 5, 1, &intent()).is_err()); + let mut wrong = intent(); + wrong.revision = 2; + assert!(project_begin(sandbox(), None, 5, 0, &wrong).is_err()); + let (accepted, state) = project_begin(sandbox(), None, 5, 0, &intent()).unwrap(); + let next = StoredSandboxImageUpdate { + operation_id: "next-operation".into(), + previous_image: "new-image".into(), + image: "newer-image".into(), + revision: 2, + }; + assert!(project_begin(accepted, Some(state), 6, 1, &next).is_err()); + } + + #[test] + fn lifecycle_and_image_checks_apply_at_acceptance_and_completion() { + let mut running = sandbox(); + running.status.as_mut().unwrap().phase = SandboxPhase::Ready as i32; + assert!(project_begin(running, None, 5, 0, &intent()).is_err()); + let mut deleting = sandbox(); + deleting.metadata.as_mut().unwrap().deletion_time = Some(prost_types::Timestamp::default()); + assert!(project_begin(deleting, None, 5, 0, &intent()).is_err()); + let mut wrong_image = sandbox(); + wrong_image + .spec + .as_mut() + .unwrap() + .template + .as_mut() + .unwrap() + .image = "other".into(); + assert!(project_begin(wrong_image, None, 5, 0, &intent()).is_err()); + let (accepted, state) = project_begin(sandbox(), None, 5, 0, &intent()).unwrap(); + let mut stale_intent = intent(); + stale_intent.operation_id = "other-operation".into(); + assert!(project_complete(accepted.clone(), Some(state.clone()), &stale_intent).is_err()); + let mut changed = accepted.clone(); + changed + .spec + .as_mut() + .unwrap() + .template + .as_mut() + .unwrap() + .image = "other".into(); + assert!(project_complete(changed, Some(state.clone()), &intent()).is_err()); + let mut running = accepted.clone(); + running.status.as_mut().unwrap().phase = SandboxPhase::Starting as i32; + assert!(project_complete(running, Some(state.clone()), &intent()).is_err()); + let mut deleting = accepted.clone(); + deleting.metadata.as_mut().unwrap().deletion_time = Some(prost_types::Timestamp::default()); + assert!(project_complete(deleting, Some(state.clone()), &intent()).is_err()); + let mut wrong_revision = state; + wrong_revision.revision = 2; + assert!(project_complete(accepted.clone(), Some(wrong_revision), &intent()).is_err()); + assert!(project_complete(accepted, None, &intent()).is_err()); + } + + #[test] + fn sandbox_decode_uses_authoritative_column_and_rejects_invalid_identity() { + let original = sandbox(); + let decoded = decode_sandbox("sandbox-id", &original.encode_to_vec(), 12).unwrap(); + assert_eq!(resource_version(&decoded), 12); + assert!(decode_sandbox("other-id", &original.encode_to_vec(), 12).is_err()); + assert!(decode_sandbox("sandbox-id", &original.encode_to_vec(), 0).is_err()); + } + + #[test] + fn resource_version_overflow_and_invalid_intents_do_not_project() { + let mut exhausted = sandbox(); + exhausted.set_resource_version(i64::MAX.cast_unsigned()); + assert!(matches!( + project_begin(exhausted, None, i64::MAX.cast_unsigned(), 0, &intent()), + Err(PersistenceError::Encode(_)) + )); + let mut invalid = intent(); + invalid.operation_id.clear(); + assert!(matches!( + project_begin(sandbox(), None, 5, 0, &invalid), + Err(PersistenceError::Encode(_)) + )); + } + + async fn fixture() -> (Store, Sandbox) { + let store = super::super::test_store().await; + store.put_message(&sandbox()).await.unwrap(); + let stored = store + .get_message::("sandbox-id") + .await + .unwrap() + .unwrap(); + (store, stored) + } + + #[tokio::test] + async fn sqlite_accept_complete_and_legacy_rewrite_preserve_independent_state() { + let (store, original) = fixture().await; + let version = resource_version(&original); + let accepted = store + .begin_sandbox_image_update("sandbox-id", version, 0, &intent()) + .await + .unwrap(); + assert_eq!(resource_version(&accepted), version + 1); + assert_eq!(image(&accepted), "new-image"); + let pending = store + .get_sandbox_image_state("sandbox-id") + .await + .unwrap() + .unwrap(); + assert_eq!(pending.pending, Some(intent())); + // Generic Sandbox decode/reencode cannot remove the separate intent. + let decoded = Sandbox::decode(accepted.encode_to_vec().as_slice()).unwrap(); + assert!( + decoded + .status + .as_ref() + .unwrap() + .provisioning + .as_ref() + .unwrap() + .driver_operation_pending + ); + assert_eq!( + decoded + .status + .as_ref() + .unwrap() + .provisioning + .as_ref() + .unwrap() + .driver_operation_id, + intent().operation_id + ); + store.put_message(&decoded).await.unwrap(); + assert_eq!( + store.get_sandbox_image_state("sandbox-id").await.unwrap(), + Some(pending) + ); + let before_complete = store + .get_message::("sandbox-id") + .await + .unwrap() + .unwrap(); + let completed = store + .complete_sandbox_image_update("sandbox-id", &intent()) + .await + .unwrap(); + assert_eq!( + resource_version(&completed), + resource_version(&before_complete) + 1 + ); + let retained = store + .get_sandbox_image_state("sandbox-id") + .await + .unwrap() + .unwrap(); + assert_eq!(retained.revision, 1); + assert!(retained.pending.is_none()); + assert!(retained.previous_provisioning.is_none()); + assert_eq!(completed.status, original.status); + // A Start based on any pre-completion snapshot must lose its CAS. + let mut stale_start = before_complete.clone(); + stale_start.status.as_mut().unwrap().phase = SandboxPhase::Starting as i32; + assert!(matches!( + store + .put_if( + "sandbox", + "sandbox-id", + "sandbox-name", + "default", + &stale_start.encode_to_vec(), + None, + super::super::WriteCondition::MatchResourceVersion(resource_version( + &before_complete + )), + ) + .await, + Err(PersistenceError::Conflict { .. }) + )); + // Neither a completed operation nor an older generation can be replayed. + assert!( + store + .complete_sandbox_image_update("sandbox-id", &intent()) + .await + .is_err() + ); + let next = StoredSandboxImageUpdate { + operation_id: "next-operation".into(), + previous_image: "new-image".into(), + image: "newer-image".into(), + revision: 2, + }; + store + .begin_sandbox_image_update("sandbox-id", resource_version(&completed), 1, &next) + .await + .unwrap(); + assert!( + store + .complete_sandbox_image_update("sandbox-id", &intent()) + .await + .is_err() + ); + assert_eq!( + store + .get_sandbox_image_state("sandbox-id") + .await + .unwrap() + .unwrap() + .pending, + Some(next) + ); + } + + #[tokio::test] + async fn sqlite_restores_prior_provisioning_and_wrong_completion_keeps_fence() { + let (store, mut original) = fixture().await; + let previous = SandboxProvisioning { + attempt_id: "timed-out-attempt".into(), + driver_operation_id: "settled-driver-operation".into(), + timeout_time: Some(prost_types::Timestamp { + seconds: 123, + nanos: 0, + }), + cleanup_completed_time: Some(prost_types::Timestamp { + seconds: 124, + nanos: 0, + }), + ..Default::default() + }; + original.status.as_mut().unwrap().provisioning = Some(previous.clone()); + store.put_message(&original).await.unwrap(); + let mut original = store + .get_message::("sandbox-id") + .await + .unwrap() + .unwrap(); + let accepted = store + .begin_sandbox_image_update("sandbox-id", resource_version(&original), 0, &intent()) + .await + .unwrap(); + let mut wrong = intent(); + wrong.operation_id = "stale-operation".into(); + assert!( + store + .complete_sandbox_image_update("sandbox-id", &wrong) + .await + .is_err() + ); + assert_eq!( + store + .get_message::("sandbox-id") + .await + .unwrap() + .unwrap(), + accepted + ); + let state = store + .get_sandbox_image_state("sandbox-id") + .await + .unwrap() + .unwrap(); + assert_eq!(state.pending, Some(intent())); + assert_eq!(state.previous_provisioning, Some(previous.clone())); + let completed = store + .complete_sandbox_image_update("sandbox-id", &intent()) + .await + .unwrap(); + let mut expected = previous; + expected.driver_operation_id = intent().operation_id; + assert_eq!( + completed.status.as_ref().unwrap().provisioning, + Some(expected.clone()) + ); + original.status.as_mut().unwrap().provisioning = Some(expected); + assert_eq!(completed.status, original.status); + assert!( + store + .get_sandbox_image_state("sandbox-id") + .await + .unwrap() + .unwrap() + .previous_provisioning + .is_none() + ); + } + + #[tokio::test] + async fn sqlite_failed_cas_has_no_private_write() { + let (store, original) = fixture().await; + for version in [0, resource_version(&original) + 1] { + assert!(matches!( + store + .begin_sandbox_image_update("sandbox-id", version, 0, &intent()) + .await, + Err(PersistenceError::Conflict { .. }) + )); + } + assert!( + store + .get_sandbox_image_state("sandbox-id") + .await + .unwrap() + .is_none() + ); + assert_eq!( + store + .get_message::("sandbox-id") + .await + .unwrap() + .unwrap(), + original + ); + } + + #[tokio::test] + async fn sqlite_private_write_failure_rolls_back_sandbox_and_completion() { + let (store, original) = fixture().await; + let Store::Sqlite(sqlite) = &store else { + unreachable!() + }; + sqlx::query( + "CREATE TRIGGER fail_image_insert BEFORE INSERT ON objects +WHEN NEW.object_type = 'sandbox_image_state' +BEGIN SELECT RAISE(ABORT, 'injected image state write failure'); END", + ) + .execute(&sqlite.pool) + .await + .unwrap(); + assert!( + store + .begin_sandbox_image_update("sandbox-id", resource_version(&original), 0, &intent()) + .await + .is_err() + ); + assert_eq!( + store + .get_message::("sandbox-id") + .await + .unwrap() + .unwrap(), + original + ); + assert!( + store + .get_sandbox_image_state("sandbox-id") + .await + .unwrap() + .is_none() + ); + sqlx::query("DROP TRIGGER fail_image_insert") + .execute(&sqlite.pool) + .await + .unwrap(); + let accepted = store + .begin_sandbox_image_update("sandbox-id", resource_version(&original), 0, &intent()) + .await + .unwrap(); + let pending = store.get_sandbox_image_state("sandbox-id").await.unwrap(); + sqlx::query( + "CREATE TRIGGER fail_image_update BEFORE UPDATE ON objects +WHEN NEW.object_type = 'sandbox_image_state' +BEGIN SELECT RAISE(ABORT, 'injected image state write failure'); END", + ) + .execute(&sqlite.pool) + .await + .unwrap(); + assert!( + store + .complete_sandbox_image_update("sandbox-id", &intent()) + .await + .is_err() + ); + assert_eq!( + store + .get_message::("sandbox-id") + .await + .unwrap() + .unwrap(), + accepted + ); + assert_eq!( + store.get_sandbox_image_state("sandbox-id").await.unwrap(), + pending + ); + } + + #[tokio::test] + #[ignore = "requires a disposable PostgreSQL database in OPENSHELL_TEST_POSTGRES_URL; run mise run test:rust:postgres"] + async fn postgres_sandbox_image_state_survives_legacy_writes_and_fences_concurrent_updates() { + use super::super::{WriteCondition, test_postgres::TestSchema}; + + let schema = TestSchema::create("sandbox_image").await; + let first = schema.connect_store().await; + let second = schema.connect_store().await; + crate::ensure_default_workspace(&first).await.unwrap(); + first.put_message(&sandbox()).await.unwrap(); + let original = second + .get_message::("sandbox-id") + .await + .unwrap() + .unwrap(); + let version = resource_version(&original); + let left = intent(); + let right = StoredSandboxImageUpdate { + operation_id: "competing-operation".into(), + image: "competing-image".into(), + ..intent() + }; + + // Independent pools contend on the same sandbox row; exactly one + // transaction may publish revision 1 and its matching operation fence. + let (left_result, right_result) = tokio::join!( + first.begin_sandbox_image_update("sandbox-id", version, 0, &left), + second.begin_sandbox_image_update("sandbox-id", version, 0, &right), + ); + let (accepted, winning_intent) = match (left_result, right_result) { + (Ok(accepted), Err(PersistenceError::Conflict { .. })) => (accepted, left), + (Err(PersistenceError::Conflict { .. }), Ok(accepted)) => (accepted, right), + results => panic!("expected one accepted image update and one conflict: {results:?}"), + }; + let visible = second + .get_message::("sandbox-id") + .await + .unwrap() + .unwrap(); + assert_eq!(visible, accepted); + assert_eq!(resource_version(&visible), version + 1); + assert_eq!(image(&visible), winning_intent.image); + let pending = second + .get_sandbox_image_state("sandbox-id") + .await + .unwrap() + .unwrap(); + assert_eq!(pending.revision, 1); + assert_eq!(pending.pending, Some(winning_intent.clone())); + let operation = visible + .status + .as_ref() + .unwrap() + .provisioning + .as_ref() + .unwrap(); + assert!(operation.driver_operation_pending); + assert_eq!(operation.driver_operation_id, winning_intent.operation_id); + + let mut stale_start = original; + stale_start.status.as_mut().unwrap().phase = SandboxPhase::Starting as i32; + assert!(matches!( + second + .put_if( + "sandbox", + "sandbox-id", + "sandbox-name", + "default", + &stale_start.encode_to_vec(), + None, + WriteCondition::MatchResourceVersion(version), + ) + .await, + Err(PersistenceError::Conflict { .. }) + )); + + // Model an old gateway's ordinary unrelated Sandbox-only SQL rewrite. + // All provisioning fields used here are baseline-known. The private + // state has no public Sandbox field for this roundtrip to overwrite. + let mut legacy_rewrite = Sandbox::decode(visible.encode_to_vec().as_slice()).unwrap(); + legacy_rewrite + .metadata + .as_mut() + .unwrap() + .annotations + .insert( + "test.openshell.dev/legacy-write".into(), + "unrelated-edit".into(), + ); + let Store::Postgres(legacy_store) = &second else { + unreachable!() + }; + let rewritten = sqlx::query( + "UPDATE objects SET payload = $2, resource_version = resource_version + 1, +updated_at_ms = $3 WHERE object_type = 'sandbox' AND id = $1 AND resource_version = $4", + ) + .bind("sandbox-id") + .bind(legacy_rewrite.encode_to_vec()) + .bind(current_time_ms()) + .bind(i64::try_from(resource_version(&visible)).unwrap()) + .execute(&legacy_store.pool) + .await + .unwrap(); + assert_eq!(rewritten.rows_affected(), 1); + assert_eq!( + first.get_sandbox_image_state("sandbox-id").await.unwrap(), + Some(pending) + ); + let rewritten = first + .get_message::("sandbox-id") + .await + .unwrap() + .unwrap(); + assert_eq!(resource_version(&rewritten), resource_version(&visible) + 1); + let operation = rewritten + .status + .as_ref() + .unwrap() + .provisioning + .as_ref() + .unwrap(); + assert!(operation.driver_operation_pending); + assert_eq!(operation.driver_operation_id, winning_intent.operation_id); + let private_identity = sqlx::query_as::<_, (Option, String)>( + "SELECT name, workspace FROM objects WHERE object_type = $1 AND id = $2", + ) + .bind(IMAGE_STATE_OBJECT_TYPE) + .bind(state_id("sandbox-id")) + .fetch_one(&legacy_store.pool) + .await + .unwrap(); + assert_eq!(private_identity, (None, String::new())); + + let completed = first + .complete_sandbox_image_update("sandbox-id", &winning_intent) + .await + .unwrap(); + assert_eq!( + resource_version(&completed), + resource_version(&rewritten) + 1 + ); + assert!(completed.status.as_ref().unwrap().provisioning.is_none()); + let retained = second + .get_sandbox_image_state("sandbox-id") + .await + .unwrap() + .unwrap(); + assert_eq!(retained.revision, 1); + assert!(retained.pending.is_none()); + assert!(retained.previous_provisioning.is_none()); + + let next = StoredSandboxImageUpdate { + operation_id: "next-generation-operation".into(), + previous_image: winning_intent.image.clone(), + image: "next-generation-image".into(), + revision: 2, + }; + let accepted_next = second + .begin_sandbox_image_update("sandbox-id", resource_version(&completed), 1, &next) + .await + .unwrap(); + assert_eq!(image(&accepted_next), next.image); + assert!(matches!( + first + .complete_sandbox_image_update("sandbox-id", &winning_intent) + .await, + Err(PersistenceError::Conflict { .. }) + )); + let still_pending = first + .get_sandbox_image_state("sandbox-id") + .await + .unwrap() + .unwrap(); + assert_eq!(still_pending.revision, 2); + assert_eq!(still_pending.pending, Some(next.clone())); + assert_eq!( + first + .get_message::("sandbox-id") + .await + .unwrap() + .unwrap(), + accepted_next + ); + + let final_sandbox = first + .complete_sandbox_image_update("sandbox-id", &next) + .await + .unwrap(); + assert_eq!( + resource_version(&final_sandbox), + resource_version(&accepted_next) + 1 + ); + assert!( + final_sandbox + .status + .as_ref() + .unwrap() + .provisioning + .is_none() + ); + assert_eq!( + second + .get_message::("sandbox-id") + .await + .unwrap() + .unwrap(), + final_sandbox + ); + let retained = second + .get_sandbox_image_state("sandbox-id") + .await + .unwrap() + .unwrap(); + assert_eq!(retained.revision, 2); + assert!(retained.pending.is_none()); + assert!(retained.previous_provisioning.is_none()); + // Completion also invalidates a Start CAS based on the pending snapshot. + assert!(matches!( + second + .put_if( + "sandbox", + "sandbox-id", + "sandbox-name", + "default", + &accepted_next.encode_to_vec(), + None, + WriteCondition::MatchResourceVersion(resource_version(&accepted_next)), + ) + .await, + Err(PersistenceError::Conflict { .. }) + )); + + first.close().await; + second.close().await; + schema.drop_schema().await; + } +} diff --git a/crates/openshell-server/src/persistence/sqlite.rs b/crates/openshell-server/src/persistence/sqlite.rs index 77b13434e4..23eb9a7b95 100644 --- a/crates/openshell-server/src/persistence/sqlite.rs +++ b/crates/openshell-server/src/persistence/sqlite.rs @@ -48,7 +48,7 @@ pub const DEFAULT_MAX_CONNECTIONS: u32 = 5; #[derive(Debug, Clone)] pub struct SqliteStore { - pool: SqlitePool, + pub(super) pool: SqlitePool, /// Pool for writes whose loss after a crash is harmless; see /// [`SqliteStore::create_relaxed`]. On-disk stores open it with /// `synchronous=NORMAL`; in-memory stores share `pool`. diff --git a/crates/openshell-server/src/reflection.rs b/crates/openshell-server/src/reflection.rs index 140b53659e..d8eb12482e 100644 --- a/crates/openshell-server/src/reflection.rs +++ b/crates/openshell-server/src/reflection.rs @@ -28,7 +28,7 @@ use openshell_core::Config; use crate::multiplex::GrpcRateLimiter; const REFLECTED_PROTO_ROOTS: &[&str] = &["openshell.proto"]; -const ADVERTISED_SERVICES: &[&str] = &["openshell.v1.OpenShell"]; +const ADVERTISED_SERVICES: &[&str] = &["openshell.v1.OpenShell", "openshell.v1.SandboxUpdates"]; pub type GatewayReflectionServer = ServerReflectionServer; diff --git a/crates/openshell-server/src/storage_proto.rs b/crates/openshell-server/src/storage_proto.rs index 90ad3a443c..7b1f9d0773 100644 --- a/crates/openshell-server/src/storage_proto.rs +++ b/crates/openshell-server/src/storage_proto.rs @@ -15,6 +15,11 @@ include!(concat!(env!("OUT_DIR"), "/openshell.storage.v1.rs")); +mod sandbox_image { + include!(concat!(env!("OUT_DIR"), "/openshell.storage.image.v1.rs")); +} +pub(crate) use sandbox_image::{StoredSandboxImageState, StoredSandboxImageUpdate}; + pub(crate) const STORAGE_FILE_DESCRIPTOR_SET: &[u8] = include_bytes!(concat!(env!("OUT_DIR"), "/storage_descriptor.bin")); @@ -154,16 +159,15 @@ mod tests { // Sandbox-wide grant reporting adds TokenGrantFailureObservation to both // closures and TokenGrantStatus to public reports. Older rows have no grant // record; absent report extensions retain compatibility without a rewrite. - // Image updates add a public-only request and a durable optional pending - // intent plus monotonic image revision. Their new fields follow the existing - // token-grant observation without reusing its wire tag. Legacy sandboxes - // decode absent/zero; revisions fence delayed driver retries after success. + // Image updates add a separate public service/request and a new private + // image-state format. Existing public status and frozen storage.v1 stay + // unchanged; only the private durable closure grows. const PUBLIC_RPC_SCHEMA_SHA256: &str = - "2d82067143395b08928e848832111370d56fa4c6e3691f0fa1d2dc32928832aa"; + "bd5e8f61deb90301db8a6fdc93cb8d74d0c53093997113207c9e49fd5e479635"; const DURABLE_SCHEMA_SHA256: &str = - "f435fc91632084aef0eb17958fc963f4a90f2f0b54f4de67042b33bb9cbfd135"; + "7d37474cd3c516f109cc448249abd8a583d1e1b3d5a584e34394e394e639af14"; const PUBLIC_DURABLE_OVERLAP_SHA256: &str = - "9997e51420f29542cefd99d394e211a8e5a21967f4f0fb9ac94aaf598a821b11"; + "ac1ffc4b5b81467de27270a4e33f6db1e31eeb2c52f79750dbaaf19515eadbb2"; // Encoded with the schema that omitted stable_placeholder. Keep these // bytes fixed so the current encoder cannot hide a compatibility change. const LEGACY_STATIC_PROFILE: &str = "0a240a116c65676163792d70726f66696c652d6964120d6c65676163792d737461746963280712510a0d6c65676163792d73746174696312184c6567616379207374617469632063726564656e7469616c2a260a076170695f6b65791a1153594e5448455449435f4150495f4b455920012a06626561726572"; @@ -221,6 +225,7 @@ mod tests { ".openshell.storage.v1.StoredConfigUpdateOperation", ".openshell.storage.v1.StoredProviderCredentialRefreshStateV2", ".openshell.storage.v1.StoredProviderProfile", + ".openshell.storage.image.v1.StoredSandboxImageState", ".openshell.v1.Sandbox", ".openshell.v1.SandboxWorkloadTemplate", ".openshell.v1.ServiceEndpoint", @@ -463,7 +468,12 @@ mod tests { let public = FileDescriptorSet::decode(openshell_core::FILE_DESCRIPTOR_SET) .expect("public descriptor set must decode"); for file in public.file { - assert_ne!(file.package.as_deref(), Some("openshell.storage.v1")); + assert!( + !file + .package + .as_deref() + .is_some_and(|package| package.starts_with("openshell.storage.")) + ); for message in file.message_type { let name = message.name.expect("message name"); assert!( @@ -559,7 +569,8 @@ mod tests { } if !matches!( (package, service_name), - ("openshell.v1", "OpenShell") | ("openshell.inference.v1", "Inference") + ("openshell.v1", "OpenShell" | "SandboxUpdates") + | ("openshell.inference.v1", "Inference") ) { continue; } @@ -623,7 +634,7 @@ mod tests { .iter() .filter(|method| method.starts_with("openshell.v1.OpenShell/")) .count(), - 79 + PROVIDER_READINESS_RPC_SIGNATURES.len() + PEER_OWNER_RPC_SIGNATURES.len() + 78 + PROVIDER_READINESS_RPC_SIGNATURES.len() + PEER_OWNER_RPC_SIGNATURES.len() ); assert!(methods.iter().all(|method| !method.contains(".storage."))); @@ -667,9 +678,9 @@ mod tests { overlap_hash.as_str(), ), ( - (316, 28), - (96, 22), - (84, 22), + (315, 28), + (97, 22), + (83, 22), PUBLIC_RPC_SCHEMA_SHA256, DURABLE_SCHEMA_SHA256, PUBLIC_DURABLE_OVERLAP_SHA256 @@ -678,17 +689,6 @@ mod tests { ); } - #[test] - fn pre_image_update_sandbox_has_no_pending_image_intent() { - let sandbox = openshell_core::proto::Sandbox::decode( - legacy_bytes(SANDBOX_WITHOUT_ENDPOINT_STATUS).as_slice(), - ) - .expect("legacy sandbox must remain decodable"); - let status = sandbox.status.unwrap(); - assert!(status.image_update.is_none()); - assert_eq!(status.image_revision, 0); - } - #[test] fn service_endpoint_without_authorization_mode_decodes_as_strip() { use openshell_core::proto::{ServiceAuthorizationMode, ServiceEndpoint}; diff --git a/crates/openshell-server/tests/common/mod.rs b/crates/openshell-server/tests/common/mod.rs index 8de7e9c848..146169d7ba 100644 --- a/crates/openshell-server/tests/common/mod.rs +++ b/crates/openshell-server/tests/common/mod.rs @@ -53,13 +53,6 @@ pub struct TestOpenShell; #[tonic::async_trait] impl OpenShell for TestOpenShell { - async fn update_sandbox( - &self, - _request: tonic::Request, - ) -> Result, Status> { - Err(Status::unimplemented("not implemented by test service")) - } - async fn peer_report_provider_readiness( &self, _request: tonic::Request, diff --git a/crates/openshell-server/tests/supervisor_relay_integration.rs b/crates/openshell-server/tests/supervisor_relay_integration.rs index 824b7b9595..dfb89f18c3 100644 --- a/crates/openshell-server/tests/supervisor_relay_integration.rs +++ b/crates/openshell-server/tests/supervisor_relay_integration.rs @@ -50,13 +50,6 @@ struct RelayGateway { #[tonic::async_trait] impl OpenShell for RelayGateway { - async fn update_sandbox( - &self, - _request: tonic::Request, - ) -> Result, Status> { - Err(Status::unimplemented("not implemented by test service")) - } - async fn peer_report_provider_readiness( &self, _request: tonic::Request, diff --git a/docs/how-it-works/gateways/configuration.mdx b/docs/how-it-works/gateways/configuration.mdx index aab1204eb5..d5c7a7f854 100644 --- a/docs/how-it-works/gateways/configuration.mdx +++ b/docs/how-it-works/gateways/configuration.mdx @@ -163,6 +163,9 @@ metrics_bind_address = "0.0.0.0:9090" log_level = "info" +# Activate only after retiring incompatible gateways and outstanding driver work. +enable_sandbox_image_updates = false + # Connection ceiling for the gateway's database pool. Omit to use the backend # default: 10 for Postgres, 5 for on-disk SQLite. database_max_connections = 10 @@ -336,6 +339,41 @@ External compute drivers declare this requirement by adding `openshell.compute.l `[openshell.gateway.auth] allow_unauthenticated_users = true` is an unsafe local-development and trusted-proxy escape hatch. It accepts user-facing CLI/API calls without OIDC or mTLS credentials while sandbox supervisors still authenticate with gateway-minted sandbox JWTs. Leave it false for shared and production gateways. +## Sandbox Image Updates + +`[openshell.gateway] enable_sandbox_image_updates` defaults to `false`. It gates +the separate `openshell.v1.SandboxUpdates/UpdateSandbox` RPC on the existing +gateway listener. The equivalent gateway process flag and environment variable +are `--enable-sandbox-image-updates true` and +`OPENSHELL_ENABLE_SANDBOX_IMAGE_UPDATES=true`. + +Enable it only after completing the +[activation checklist](/kubernetes/high-availability#activate-sandbox-image-updates). +Setting it to `true` attests that every gateway that can write the database is +compatible and incompatible gateways cannot return. Keep it false throughout a +rolling upgrade, including while outstanding operations from retired gateways +settle. Database and membership checks fail closed but do not prove retirement. + +For a schema-v2 file, set: + +```toml +[openshell.gateway] +enable_sandbox_image_updates = true +``` + +The canonical Helm values form uses a dotted table key: + +```yaml +gatewayConfig: + "openshell.gateway": + enable_sandbox_image_updates: true +``` + +This is not an automatic mixed-version migration switch. Do not downgrade while +an image update is pending or retained sandboxes require the private image +revision protocol. SQLite supports one gateway process only; activation attests +that the previous process has stopped, not that sharing a SQLite file enables HA. + ## Database Pool `[openshell.gateway] database_max_connections` sets the connection ceiling for the gateway's database pool. One pool is shared by every database-backed RPC, so this value is also the gateway's ceiling on concurrent database work. When the pool is saturated, callers queue on connection acquisition and sqlx logs that the time to acquire a connection exceeded its slow threshold. The background readiness monitor draws from the same pool, so sustained saturation can push its database ping past the check timeout and flip `/readyz` to not-ready while the gateway is otherwise serving. @@ -1458,7 +1496,7 @@ compute_driver = "kyma" socket_path = "/run/openshell/kyma-compute-driver.sock" ``` -## Preflight package configuration {#gateway-config-preflight} +

Preflight package configuration

Before starting a package-managed gateway, validate the selected file without changing it: diff --git a/docs/how-it-works/sandboxes/overview.mdx b/docs/how-it-works/sandboxes/overview.mdx index 8fe0518604..bb19b39f3f 100644 --- a/docs/how-it-works/sandboxes/overview.mdx +++ b/docs/how-it-works/sandboxes/overview.mdx @@ -1005,17 +1005,24 @@ For a provisioning timeout, wait for cleanup to finish, then run `sandbox start` ### Update the Image of a Stopped Sandbox -Use the raw `UpdateSandbox` RPC to change only a stopped sandbox's workload -image. This operation initially supports the Kubernetes compute driver only; -other drivers return `UNIMPLEMENTED`. There is no `sandbox update` CLI command -or curated SDK update method. +Use `openshell.v1.SandboxUpdates/UpdateSandbox` to change only a stopped +sandbox's workload image. This separate service uses the same gateway listener +and authentication as `OpenShell`; it requires `sandbox:write` and workspace +user access. This operation initially supports the Kubernetes compute driver +only; other drivers return `UNIMPLEMENTED` after activation. There is no +`sandbox update` CLI command or curated SDK update method. + +Image updates default to disabled. Ask the operator to complete the +[compatible deployment rollout](/kubernetes/high-availability#activate-sandbox-image-updates) +before enabling `enable_sandbox_image_updates` in the +[gateway configuration](/how-it-works/gateways/configuration#sandbox-image-updates). The update preserves the sandbox ID, Kubernetes custom resource, and persistent volume claim. It does not delete and recreate the sandbox, reseed its existing workspace from the new image, or change the trusted supervisor and sandbox -runtime images. Other create-time configuration remains unchanged. Submitting the -same image reference is a no-op; use a different tag or an immutable digest to -select new image content. +runtime images. Other create-time configuration remains unchanged. Without a +pending update, submitting the same image reference is a no-op. Use a different +tag or an immutable digest to select new image content. Follow this sequence through the CLI and a generated/raw RPC client. @@ -1028,6 +1035,25 @@ Follow this sequence through the CLI and a generated/raw RPC client. 4. After the update succeeds, run `openshell sandbox start my-sandbox` to launch the new image. +With an authenticated Rust SDK `OpenShellClient`, use the separate raw client +and the `current_resource_version` read in step 2: + +```rust +use openshell_sdk::raw::{UpdateSandboxRequest, proto}; + +let mut updates = client.raw_sandbox_updates_fresh().await?; +let response = updates.update_sandbox(UpdateSandboxRequest { + workspace_scope: Some(proto::workspace_selector("default")), + name: "my-sandbox".into(), + image: "registry.example.com/agents/my-agent:2.0".into(), + expected_resource_version: current_resource_version, + request_id: String::new(), +}).await?; +``` + +The helper shares the main client's transport and live authentication slot. +Generated clients use the `SandboxUpdates` service, not `OpenShell`. + If the new image fails to start and provisioning times out, wait until `provisioning.cleanup_completed_time` is present and `provisioning.driver_operation_pending` is false. Run `sandbox stop` to move the @@ -1037,17 +1063,21 @@ compute again. Cleanup that is still pending cannot be bypassed. An `ABORTED` version conflict requires another read before you construct a new conditional request. An update failure or disconnected response can leave a -persistent `sandbox.status.image_update` intent, even when -`sandbox.spec.template.image` already names the target image. While that intent -exists, start is blocked. Read the current version and retry `UpdateSandbox` -with the intent's same `image`; do not select a different image or delete the -sandbox to bypass reconciliation. Only a successful retry clears the intent. +pending operation, even when `sandbox.spec.template.image` already names the +target image. Start, stop, provisioning retry, and delete reject the pending +operation. +The public `SandboxStatus` shape is unchanged; image intent and revision remain +private. Use the operation-pending error to guide recovery, not a status image +field. Read the current version and retry `UpdateSandbox` with the same image +you originally requested. Do not select another image or delete the sandbox to +bypass reconciliation. Only a successful retry clears the pending operation. The optional `request_id` uses [durable request admission](/sdk/api-errors#durable-request-admission). A retry with the same ID must keep the original payload, including its expected version. An unresolved admission returns `REQUEST_OUTCOME_UNCERTAIN` rather than -executing again. Reconcile the sandbox and pending target first, then submit a -new conditional same-image request with a fresh version and a new ID, or no ID. +executing again. Reconcile against the sandbox state and your original requested +image, then submit a new conditional same-image request with a fresh version +and a new ID, or no ID. Do not change the expected version under the original ID or blindly switch IDs after a timeout. diff --git a/docs/kubernetes/high-availability.mdx b/docs/kubernetes/high-availability.mdx index 8b4d467b4e..7f83534049 100644 --- a/docs/kubernetes/high-availability.mdx +++ b/docs/kubernetes/high-availability.mdx @@ -504,6 +504,51 @@ during the upgrade, the older replicas serialize every mutation across the fleet. Mutations can be slower and can briefly fail under load until the rollout finishes. +### Activate Sandbox Image Updates + +Sandbox image updates default to disabled. Setting +`[openshell.gateway] enable_sandbox_image_updates = true` is an operator +attestation that the deployment uniformly supports the image-update protocol. +Use this sequence before activating the +[separate update service](/how-it-works/sandboxes/overview#update-the-image-of-a-stopped-sandbox). + +1. Keep the setting false throughout the rolling upgrade. Drain and retire + every incompatible gateway, including unregistered processes and Jobs, and + settle all outstanding driver operations they started. A completed + Kubernetes rollout alone does not establish this. +2. Prevent incompatible gateways from returning. Pin compatible images and + retire old rollback targets, Jobs, and other launch configurations that could + reconnect to the database. +3. Check all PostgreSQL client backends in the same database. The new binary + sets `application_name` to `openshell-image-update-v1` on every data-pool and + lock-pool connection. Any unmarked client backend, including an + administrative session, blocks image updates. Close those sessions or use a + dedicated database. Do not relabel an old process to bypass this check. +4. Confirm live gateway membership records advertise image-update protocol 1. + Missing or incompatible capabilities, malformed records, and truncated + membership reads reject updates. These observations are not durable proof + of fleet compatibility. Expiry or absence of a membership record does not + prove that its process and driver work have stopped. +5. Activate the flag only after completing retirement and preventing old + gateways from returning. See the exact + [TOML, environment, process flag, and Helm forms](/how-it-works/gateways/configuration#sandbox-image-updates). + +A pending image update atomically sets the existing +`provisioning.driver_operation_pending` and `provisioning.driver_operation_id` +fields alongside private image intent. Baseline start, stop, delete, and +provisioning-retry paths honor this per-sandbox barrier, including after a +legacy public record round-trip. Successful reconciliation preserves current +provisioning diagnostics and clocks, clears the pending flag, and retains the +new operation ID to fence delayed callbacks. Previously absent provisioning +remains absent unless concurrent writes added diagnostics or clocks. This +barrier does not replace the deployment activation checklist. +Image intent and revision are not new public `SandboxStatus` fields. + +Do not downgrade while updates are pending or retained sandboxes require the +private revision protocol. SQLite supports one gateway process only. For a +SQLite gateway, activation attests that the old process has stopped; a shared +SQLite file is not an HA deployment. + ## Next Steps - To expose the gateway through a highly available data path, refer to diff --git a/docs/sdk/api-errors.mdx b/docs/sdk/api-errors.mdx index 592cebbe2f..6efc52650b 100644 --- a/docs/sdk/api-errors.mdx +++ b/docs/sdk/api-errors.mdx @@ -105,6 +105,10 @@ Thirty-one user-callable unary RPCs accept an optional `request_id` in their pro | Provider profile | `ImportProviderProfiles`, `UpdateProviderProfiles`, `DeleteProviderProfile` | | Policy and config | `UpdateConfig`, `ApproveDraftChunk`, `RejectDraftChunk`, `EditDraftChunk`, `UndoDraftChunk`, `ApproveAllDraftChunks`, `ClearDraftChunks` | +`UpdateSandbox` belongs to the separate `openshell.v1.SandboxUpdates` service +on the same authenticated gateway listener. The other RPCs above remain on +`openshell.v1.OpenShell`. + Use a nonzero, hyphenated UUID of exactly 36 characters. Uppercase and lowercase forms identify the same request. An empty ID preserves the existing behavior without deduplication. This ID is separate from transport correlation metadata. @@ -194,23 +198,27 @@ before relying on IDs; older protobuf servers can silently ignore unknown fields ### Sandbox image update recovery -`UpdateSandbox` is an image-only conditional mutation for stopped Kubernetes -sandboxes. Other compute drivers return `UNIMPLEMENTED`. Supply a named +`SandboxUpdates.UpdateSandbox` is an image-only conditional mutation for stopped +Kubernetes sandboxes. It defaults to disabled and returns `FAILED_PRECONDITION` +until the operator [activates a compatible deployment](/kubernetes/high-availability#activate-sandbox-image-updates). +After activation, other compute drivers return `UNIMPLEMENTED`. Supply a named `workspace_scope`, sandbox `name`, nonempty OCI `image`, and a required nonzero `expected_resource_version` read from `sandbox.metadata.resource_version`. A stale version returns `ABORTED`; read fresh state before constructing another conditional request. The operation does not start compute. -A failed or interrupted update can leave durable `sandbox.status.image_update` -state. The desired spec image alone does not prove driver reconciliation -completed. Start returns `FAILED_PRECONDITION` until you successfully retry the -same pending image using the current resource version. A different target image -cannot replace a pending update. +A failed or interrupted update can leave a pending operation. The desired spec +image alone does not prove driver reconciliation completed. Start, stop, +provisioning retry, and delete return `FAILED_PRECONDITION` while that operation remains. +Image intent and revision are private; the public `SandboxStatus` shape does not +change. On an operation-pending error, read a fresh resource version and retry +the same image originally requested. A different target image cannot replace a +pending update. If the original request supplied `request_id`, an error leaves its admission unresolved. Reusing that ID with the original payload returns `REQUEST_OUTCOME_UNCERTAIN`; changing its expected version returns -`REQUEST_ID_PAYLOAD_MISMATCH`. Inspect and reconcile the pending image first, +`REQUEST_ID_PAYLOAD_MISMATCH`. Reconcile against the original requested image, then make a new conditional same-image request with the fresh version and a new ID, or without an ID. This is explicit recovery, not permission to blindly repeat uncertain mutations. A replay of a confirmed success returns the diff --git a/e2e/rust/tests/kubernetes_image_update.rs b/e2e/rust/tests/kubernetes_image_update.rs index 9077e66761..d04f42ff0e 100644 --- a/e2e/rust/tests/kubernetes_image_update.rs +++ b/e2e/rust/tests/kubernetes_image_update.rs @@ -13,7 +13,7 @@ use std::time::Duration; use openshell_bootstrap::{load_active_gateway, load_gateway_metadata}; use openshell_e2e::harness::cli::{run_cli, wait_for_sandbox_phase}; use openshell_e2e::harness::sandbox::SandboxGuard; -use openshell_sdk::raw::{AuthedGrpcClient, proto}; +use openshell_sdk::raw::{AuthedGrpcClient, AuthedSandboxUpdatesClient, proto}; use openshell_sdk::{ClientConfig, EdgeAuthInterceptor, OpenShellClient}; use serde_json::Value; use tonic::transport::{Certificate, ClientTlsConfig, Endpoint, Identity}; @@ -26,14 +26,14 @@ const SENTINEL_PATH: &str = "/sandbox/.image-update-sentinel"; /// Reuse the wrapper's registered endpoint (including its isolated XDG config). /// The SDK owns plaintext transport; the `OpenShift` wrapper registers an mTLS /// gateway, for which we attach its existing client bundle to a tonic channel. -async fn gateway_client() -> AuthedGrpcClient { +async fn gateway_client() -> OpenShellClient { let name = std::env::var("OPENSHELL_GATEWAY") .ok() .filter(|name| !name.trim().is_empty()) .or_else(load_active_gateway) .expect("Kubernetes E2E wrapper must register a gateway"); let metadata = load_gateway_metadata(&name).expect("load E2E gateway metadata"); - let client = if metadata.gateway_endpoint.starts_with("http://") { + if metadata.gateway_endpoint.starts_with("http://") { OpenShellClient::connect(ClientConfig::new(metadata.gateway_endpoint)) .await .expect("connect to E2E gateway") @@ -65,8 +65,7 @@ async fn gateway_client() -> AuthedGrpcClient { .await .expect("connect to E2E gateway over mTLS"); OpenShellClient::from_parts(channel, EdgeAuthInterceptor::noop()) - }; - client.raw_grpc() + } } fn request_id() -> String { @@ -248,8 +247,11 @@ fn assert_update_completed(original: &proto::Sandbox, updated: &proto::Sandbox) let status = updated.status.as_ref().expect("updated status"); assert_eq!(status.phase, proto::SandboxPhase::Stopped as i32); assert!( - status.image_update.is_none(), - "successful update must clear pending intent" + status + .provisioning + .as_ref() + .is_none_or(|record| !record.driver_operation_pending), + "successful image update must settle the old-understood operation interlock" ); assert_eq!( updated @@ -265,13 +267,28 @@ fn assert_update_completed(original: &proto::Sandbox, updated: &proto::Sandbox) } async fn assert_replay( - client: &mut AuthedGrpcClient, + client: &mut AuthedSandboxUpdatesClient, update: proto::UpdateSandboxRequest, updated: &proto::Sandbox, ) { - // Replay the exact old resource-version request. Sandbox replay returns its - // current state: ordinary watch observations may have advanced metadata and - // status since the original response, without applying the image again. + // Replay restores current resource state, not a captured transient status. + // Use retained driver evidence to prove that no new image operation ran. + let id = &updated.metadata.as_ref().expect("updated metadata").id; + let before = sandbox_resource(id).await; + let evidence = before["metadata"]["annotations"]["openshell.ai/sandbox-image-update"].clone(); + let operation: Value = + serde_json::from_str(evidence.as_str().expect("image operation evidence")) + .expect("parse image operation evidence"); + assert!( + operation["revision"] + .as_u64() + .is_some_and(|revision| revision > 0) + ); + assert!( + operation["operation_id"] + .as_str() + .is_some_and(|id| !id.is_empty()) + ); let replay = client .update_sandbox(rpc(update)) .await @@ -286,18 +303,11 @@ async fn assert_replay( let replayed = replay.into_inner().sandbox.expect("replayed Sandbox"); assert_update_completed(updated, &replayed); assert_eq!(replayed.spec, updated.spec); + let after = sandbox_resource(id).await; + assert_eq!(after["metadata"]["uid"], before["metadata"]["uid"]); assert_eq!( - replayed - .status - .as_ref() - .expect("replayed status") - .image_revision, - updated - .status - .as_ref() - .expect("updated status") - .image_revision, - "replay must not admit another image operation" + after["metadata"]["annotations"]["openshell.ai/sandbox-image-update"], evidence, + "replay must retain the exact driver operation identity and revision" ); assert!( replayed @@ -313,9 +323,7 @@ async fn assert_replay( ); } -#[tokio::test] -async fn image_update_retains_workspace_and_identity() { - let mut client = gateway_client().await; +async fn assert_image_update_supported(client: &mut AuthedGrpcClient) { // This test is Kubernetes-only: missing support is a regression, not a skip. let info = client .get_gateway_info(rpc(proto::GetGatewayInfoRequest {})) @@ -328,6 +336,14 @@ async fn image_update_retains_workspace_and_identity() { .iter() .any(|capability| capability == "openshell.compute.update-sandbox-image") })); +} + +#[tokio::test] +async fn image_update_retains_workspace_and_identity() { + let gateway = gateway_client().await; + let mut client = gateway.raw_grpc(); + let mut image_client = gateway.raw_sandbox_updates(); + assert_image_update_supported(&mut client).await; let mut sandbox = SandboxGuard::create(&["--from", ORIGINAL_IMAGE, "--no-auto-providers"]) .await @@ -363,7 +379,7 @@ async fn image_update_retains_workspace_and_identity() { .resource_version, request_id: String::new(), }; - let error = client + let error = image_client .update_sandbox(rpc(running_update.clone())) .await .expect_err("running update must be rejected"); @@ -385,7 +401,7 @@ async fn image_update_retains_workspace_and_identity() { request_id: request_id(), ..running_update }; - let updated = client + let updated = image_client .update_sandbox(rpc(update.clone())) .await .expect("update stopped sandbox image") @@ -395,7 +411,7 @@ async fn image_update_retains_workspace_and_identity() { assert_update_completed(&original, &updated); assert_resource_retained(&before, &sandbox_resource(id).await, UPDATED_IMAGE); - assert_replay(&mut client, update, &updated).await; + assert_replay(&mut image_client, update, &updated).await; let (output, code) = run_cli(&["sandbox", "start", &sandbox.name]).await; assert_eq!(code, 0, "sandbox start: {output}"); diff --git a/e2e/with-kube-gateway.sh b/e2e/with-kube-gateway.sh index ee755b8760..ad2efb3615 100755 --- a/e2e/with-kube-gateway.sh +++ b/e2e/with-kube-gateway.sh @@ -1234,6 +1234,12 @@ helm_extra_args=() helm_post_renderer_args=() helm_extra_args+=(--set "server.telemetryEnabled=${OPENSHELL_TELEMETRY_ENABLED}") helm_extra_args+=(--set supervisor.sandboxRuntime.networkPolicyEnforced=true) +# This wrapper installs an isolated, uniformly built test gateway, not a +# production rolling upgrade. Explicitly activate the image-update scenario; +# callers can keep activation disabled for negative coverage. +if [ "${OPENSHELL_E2E_KUBE_IMAGE_UPDATES:-1}" = "1" ]; then + helm_extra_args+=(--set 'gatewayConfig.openshell\.gateway.enable_sandbox_image_updates=true') +fi if [ "${OPENSHELL_E2E_EXTERNAL_COMPUTE_DRIVER:-0}" = "1" ]; then if [ "${OPENSHELL_E2E_KUBE_BUILD_IMAGES}" != "1" ]; then echo "ERROR: external Kubernetes driver e2e requires OPENSHELL_E2E_KUBE_BUILD_IMAGES=1." >&2 diff --git a/proto/openshell.proto b/proto/openshell.proto index 3a7dcad9bf..05d1d6dcad 100644 --- a/proto/openshell.proto +++ b/proto/openshell.proto @@ -53,16 +53,6 @@ service OpenShell { }; } - // Update only the workload image of a stopped sandbox without deleting its - // identity or retained storage. Requires compute-driver image-update support. - rpc UpdateSandbox(UpdateSandboxRequest) returns (SandboxResponse) { - option (openshell.options.v1.authorization) = { - auth_mode: "bearer" - scope: "sandbox:write" - workspace_role: "user" - }; - } - // Allocate a gateway-owned staging slot for a local rootfs tar archive. // // The gateway creates a request-scoped directory inside the compute driver's @@ -833,6 +823,21 @@ service OpenShell { } } +// Optional sandbox mutations are separate from OpenShell so existing generated +// OpenShell server implementations remain source-compatible. +service SandboxUpdates { + // Update only the workload image of a stopped sandbox without deleting its + // identity or retained storage. Requires compute-driver image-update support + // and explicit gateway activation of sandbox image updates. + rpc UpdateSandbox(UpdateSandboxRequest) returns (SandboxResponse) { + option (openshell.options.v1.authorization) = { + auth_mode: "bearer" + scope: "sandbox:write" + workspace_role: "user" + }; + } +} + // IssueSandboxToken request. Empty body; identity is established by the // authentication credentials carried in the request headers (a projected // Kubernetes ServiceAccount JWT in the K8s driver path). @@ -1217,20 +1222,6 @@ message SandboxStatus { // failures before a configured endpoint or credential could be selected. // Matching grant success or a policy, provider, or supervisor reset clears it. TokenGrantFailureObservation last_token_grant_failure = 17; - // Durable pending image change. Start is blocked until the same image update - // is retried successfully. Absence means no image update is pending. - SandboxImageUpdate image_update = 18; - // Monotonic gateway-owned image intent revision. Never reset by restart. - uint64 image_revision = 19; -} - -// Gateway-owned intent retained across interrupted driver operations. -message SandboxImageUpdate { - string operation_id = 1; - string previous_image = 2; - string image = 3; - // Fences delayed operations, including image changes that return to an old tag. - uint64 revision = 4; } // User-facing sandbox condition derived from platform or gateway observations. diff --git a/sdk/go/proto/openshellv1/openshell.pb.go b/sdk/go/proto/openshellv1/openshell.pb.go index 27e43ca541..75f7e91c01 100644 --- a/sdk/go/proto/openshellv1/openshell.pb.go +++ b/sdk/go/proto/openshellv1/openshell.pb.go @@ -3194,13 +3194,8 @@ type SandboxStatus struct { // failures before a configured endpoint or credential could be selected. // Matching grant success or a policy, provider, or supervisor reset clears it. LastTokenGrantFailure *TokenGrantFailureObservation `protobuf:"bytes,17,opt,name=last_token_grant_failure,json=lastTokenGrantFailure,proto3" json:"last_token_grant_failure,omitempty"` - // Durable pending image change. Start is blocked until the same image update - // is retried successfully. Absence means no image update is pending. - ImageUpdate *SandboxImageUpdate `protobuf:"bytes,18,opt,name=image_update,json=imageUpdate,proto3" json:"image_update,omitempty"` - // Monotonic gateway-owned image intent revision. Never reset by restart. - ImageRevision uint64 `protobuf:"varint,19,opt,name=image_revision,json=imageRevision,proto3" json:"image_revision,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *SandboxStatus) Reset() { @@ -3345,90 +3340,6 @@ func (x *SandboxStatus) GetLastTokenGrantFailure() *TokenGrantFailureObservation return nil } -func (x *SandboxStatus) GetImageUpdate() *SandboxImageUpdate { - if x != nil { - return x.ImageUpdate - } - return nil -} - -func (x *SandboxStatus) GetImageRevision() uint64 { - if x != nil { - return x.ImageRevision - } - return 0 -} - -// Gateway-owned intent retained across interrupted driver operations. -type SandboxImageUpdate struct { - state protoimpl.MessageState `protogen:"open.v1"` - OperationId string `protobuf:"bytes,1,opt,name=operation_id,json=operationId,proto3" json:"operation_id,omitempty"` - PreviousImage string `protobuf:"bytes,2,opt,name=previous_image,json=previousImage,proto3" json:"previous_image,omitempty"` - Image string `protobuf:"bytes,3,opt,name=image,proto3" json:"image,omitempty"` - // Fences delayed operations, including image changes that return to an old tag. - Revision uint64 `protobuf:"varint,4,opt,name=revision,proto3" json:"revision,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *SandboxImageUpdate) Reset() { - *x = SandboxImageUpdate{} - mi := &file_openshell_proto_msgTypes[30] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *SandboxImageUpdate) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*SandboxImageUpdate) ProtoMessage() {} - -func (x *SandboxImageUpdate) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[30] - 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 SandboxImageUpdate.ProtoReflect.Descriptor instead. -func (*SandboxImageUpdate) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{30} -} - -func (x *SandboxImageUpdate) GetOperationId() string { - if x != nil { - return x.OperationId - } - return "" -} - -func (x *SandboxImageUpdate) GetPreviousImage() string { - if x != nil { - return x.PreviousImage - } - return "" -} - -func (x *SandboxImageUpdate) GetImage() string { - if x != nil { - return x.Image - } - return "" -} - -func (x *SandboxImageUpdate) GetRevision() uint64 { - if x != nil { - return x.Revision - } - return 0 -} - // User-facing sandbox condition derived from platform or gateway observations. type SandboxCondition struct { state protoimpl.MessageState `protogen:"open.v1"` @@ -3448,7 +3359,7 @@ type SandboxCondition struct { func (x *SandboxCondition) Reset() { *x = SandboxCondition{} - mi := &file_openshell_proto_msgTypes[31] + mi := &file_openshell_proto_msgTypes[30] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3460,7 +3371,7 @@ func (x *SandboxCondition) String() string { func (*SandboxCondition) ProtoMessage() {} func (x *SandboxCondition) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[31] + mi := &file_openshell_proto_msgTypes[30] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3473,7 +3384,7 @@ func (x *SandboxCondition) ProtoReflect() protoreflect.Message { // Deprecated: Use SandboxCondition.ProtoReflect.Descriptor instead. func (*SandboxCondition) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{31} + return file_openshell_proto_rawDescGZIP(), []int{30} } func (x *SandboxCondition) GetType() string { @@ -3532,7 +3443,7 @@ type PlatformEvent struct { func (x *PlatformEvent) Reset() { *x = PlatformEvent{} - mi := &file_openshell_proto_msgTypes[32] + mi := &file_openshell_proto_msgTypes[31] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3544,7 +3455,7 @@ func (x *PlatformEvent) String() string { func (*PlatformEvent) ProtoMessage() {} func (x *PlatformEvent) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[32] + mi := &file_openshell_proto_msgTypes[31] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3557,7 +3468,7 @@ func (x *PlatformEvent) ProtoReflect() protoreflect.Message { // Deprecated: Use PlatformEvent.ProtoReflect.Descriptor instead. func (*PlatformEvent) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{32} + return file_openshell_proto_rawDescGZIP(), []int{31} } func (x *PlatformEvent) GetEventTime() *timestamppb.Timestamp { @@ -3633,7 +3544,7 @@ type CreateSandboxRequest struct { func (x *CreateSandboxRequest) Reset() { *x = CreateSandboxRequest{} - mi := &file_openshell_proto_msgTypes[33] + mi := &file_openshell_proto_msgTypes[32] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3645,7 +3556,7 @@ func (x *CreateSandboxRequest) String() string { func (*CreateSandboxRequest) ProtoMessage() {} func (x *CreateSandboxRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[33] + mi := &file_openshell_proto_msgTypes[32] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3658,7 +3569,7 @@ func (x *CreateSandboxRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use CreateSandboxRequest.ProtoReflect.Descriptor instead. func (*CreateSandboxRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{33} + return file_openshell_proto_rawDescGZIP(), []int{32} } func (x *CreateSandboxRequest) GetWorkspaceScope() *datamodelv1.WorkspaceSelector { @@ -3745,7 +3656,7 @@ type UpdateSandboxRequest struct { func (x *UpdateSandboxRequest) Reset() { *x = UpdateSandboxRequest{} - mi := &file_openshell_proto_msgTypes[34] + mi := &file_openshell_proto_msgTypes[33] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3757,7 +3668,7 @@ func (x *UpdateSandboxRequest) String() string { func (*UpdateSandboxRequest) ProtoMessage() {} func (x *UpdateSandboxRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[34] + mi := &file_openshell_proto_msgTypes[33] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3770,7 +3681,7 @@ func (x *UpdateSandboxRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use UpdateSandboxRequest.ProtoReflect.Descriptor instead. func (*UpdateSandboxRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{34} + return file_openshell_proto_rawDescGZIP(), []int{33} } func (x *UpdateSandboxRequest) GetWorkspaceScope() *datamodelv1.WorkspaceSelector { @@ -3822,7 +3733,7 @@ type CreateSandboxTemplateRequest struct { func (x *CreateSandboxTemplateRequest) Reset() { *x = CreateSandboxTemplateRequest{} - mi := &file_openshell_proto_msgTypes[35] + mi := &file_openshell_proto_msgTypes[34] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3834,7 +3745,7 @@ func (x *CreateSandboxTemplateRequest) String() string { func (*CreateSandboxTemplateRequest) ProtoMessage() {} func (x *CreateSandboxTemplateRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[35] + mi := &file_openshell_proto_msgTypes[34] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3847,7 +3758,7 @@ func (x *CreateSandboxTemplateRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use CreateSandboxTemplateRequest.ProtoReflect.Descriptor instead. func (*CreateSandboxTemplateRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{35} + return file_openshell_proto_rawDescGZIP(), []int{34} } func (x *CreateSandboxTemplateRequest) GetWorkspaceScope() *datamodelv1.WorkspaceSelector { @@ -3882,7 +3793,7 @@ type GetSandboxTemplateRequest struct { func (x *GetSandboxTemplateRequest) Reset() { *x = GetSandboxTemplateRequest{} - mi := &file_openshell_proto_msgTypes[36] + mi := &file_openshell_proto_msgTypes[35] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3894,7 +3805,7 @@ func (x *GetSandboxTemplateRequest) String() string { func (*GetSandboxTemplateRequest) ProtoMessage() {} func (x *GetSandboxTemplateRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[36] + mi := &file_openshell_proto_msgTypes[35] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3907,7 +3818,7 @@ func (x *GetSandboxTemplateRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetSandboxTemplateRequest.ProtoReflect.Descriptor instead. func (*GetSandboxTemplateRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{36} + return file_openshell_proto_rawDescGZIP(), []int{35} } func (x *GetSandboxTemplateRequest) GetWorkspaceScope() *datamodelv1.WorkspaceSelector { @@ -3942,7 +3853,7 @@ type ListSandboxTemplatesRequest struct { func (x *ListSandboxTemplatesRequest) Reset() { *x = ListSandboxTemplatesRequest{} - mi := &file_openshell_proto_msgTypes[37] + mi := &file_openshell_proto_msgTypes[36] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3954,7 +3865,7 @@ func (x *ListSandboxTemplatesRequest) String() string { func (*ListSandboxTemplatesRequest) ProtoMessage() {} func (x *ListSandboxTemplatesRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[37] + mi := &file_openshell_proto_msgTypes[36] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3967,7 +3878,7 @@ func (x *ListSandboxTemplatesRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListSandboxTemplatesRequest.ProtoReflect.Descriptor instead. func (*ListSandboxTemplatesRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{37} + return file_openshell_proto_rawDescGZIP(), []int{36} } func (x *ListSandboxTemplatesRequest) GetWorkspaceScope() *datamodelv1.WorkspaceSelector { @@ -4014,7 +3925,7 @@ type DeleteSandboxTemplateRequest struct { func (x *DeleteSandboxTemplateRequest) Reset() { *x = DeleteSandboxTemplateRequest{} - mi := &file_openshell_proto_msgTypes[38] + mi := &file_openshell_proto_msgTypes[37] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4026,7 +3937,7 @@ func (x *DeleteSandboxTemplateRequest) String() string { func (*DeleteSandboxTemplateRequest) ProtoMessage() {} func (x *DeleteSandboxTemplateRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[38] + mi := &file_openshell_proto_msgTypes[37] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4039,7 +3950,7 @@ func (x *DeleteSandboxTemplateRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteSandboxTemplateRequest.ProtoReflect.Descriptor instead. func (*DeleteSandboxTemplateRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{38} + return file_openshell_proto_rawDescGZIP(), []int{37} } func (x *DeleteSandboxTemplateRequest) GetWorkspaceScope() *datamodelv1.WorkspaceSelector { @@ -4079,7 +3990,7 @@ type SandboxTemplateResponse struct { func (x *SandboxTemplateResponse) Reset() { *x = SandboxTemplateResponse{} - mi := &file_openshell_proto_msgTypes[39] + mi := &file_openshell_proto_msgTypes[38] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4091,7 +4002,7 @@ func (x *SandboxTemplateResponse) String() string { func (*SandboxTemplateResponse) ProtoMessage() {} func (x *SandboxTemplateResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[39] + mi := &file_openshell_proto_msgTypes[38] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4104,7 +4015,7 @@ func (x *SandboxTemplateResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use SandboxTemplateResponse.ProtoReflect.Descriptor instead. func (*SandboxTemplateResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{39} + return file_openshell_proto_rawDescGZIP(), []int{38} } func (x *SandboxTemplateResponse) GetTemplate() *SandboxWorkloadTemplate { @@ -4125,7 +4036,7 @@ type ListSandboxTemplatesResponse struct { func (x *ListSandboxTemplatesResponse) Reset() { *x = ListSandboxTemplatesResponse{} - mi := &file_openshell_proto_msgTypes[40] + mi := &file_openshell_proto_msgTypes[39] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4137,7 +4048,7 @@ func (x *ListSandboxTemplatesResponse) String() string { func (*ListSandboxTemplatesResponse) ProtoMessage() {} func (x *ListSandboxTemplatesResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[40] + mi := &file_openshell_proto_msgTypes[39] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4150,7 +4061,7 @@ func (x *ListSandboxTemplatesResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListSandboxTemplatesResponse.ProtoReflect.Descriptor instead. func (*ListSandboxTemplatesResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{40} + return file_openshell_proto_rawDescGZIP(), []int{39} } func (x *ListSandboxTemplatesResponse) GetTemplates() []*SandboxWorkloadTemplate { @@ -4176,7 +4087,7 @@ type DeleteSandboxTemplateResponse struct { func (x *DeleteSandboxTemplateResponse) Reset() { *x = DeleteSandboxTemplateResponse{} - mi := &file_openshell_proto_msgTypes[41] + mi := &file_openshell_proto_msgTypes[40] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4188,7 +4099,7 @@ func (x *DeleteSandboxTemplateResponse) String() string { func (*DeleteSandboxTemplateResponse) ProtoMessage() {} func (x *DeleteSandboxTemplateResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[41] + mi := &file_openshell_proto_msgTypes[40] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4201,7 +4112,7 @@ func (x *DeleteSandboxTemplateResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteSandboxTemplateResponse.ProtoReflect.Descriptor instead. func (*DeleteSandboxTemplateResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{41} + return file_openshell_proto_rawDescGZIP(), []int{40} } func (x *DeleteSandboxTemplateResponse) GetOutcome() DeletionOutcome { @@ -4228,7 +4139,7 @@ type BeginRootfsTarStagingRequest struct { func (x *BeginRootfsTarStagingRequest) Reset() { *x = BeginRootfsTarStagingRequest{} - mi := &file_openshell_proto_msgTypes[42] + mi := &file_openshell_proto_msgTypes[41] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4240,7 +4151,7 @@ func (x *BeginRootfsTarStagingRequest) String() string { func (*BeginRootfsTarStagingRequest) ProtoMessage() {} func (x *BeginRootfsTarStagingRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[42] + mi := &file_openshell_proto_msgTypes[41] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4253,7 +4164,7 @@ func (x *BeginRootfsTarStagingRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use BeginRootfsTarStagingRequest.ProtoReflect.Descriptor instead. func (*BeginRootfsTarStagingRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{42} + return file_openshell_proto_rawDescGZIP(), []int{41} } func (x *BeginRootfsTarStagingRequest) GetWorkspaceScope() *datamodelv1.WorkspaceSelector { @@ -4296,7 +4207,7 @@ type BeginRootfsTarStagingResponse struct { func (x *BeginRootfsTarStagingResponse) Reset() { *x = BeginRootfsTarStagingResponse{} - mi := &file_openshell_proto_msgTypes[43] + mi := &file_openshell_proto_msgTypes[42] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4308,7 +4219,7 @@ func (x *BeginRootfsTarStagingResponse) String() string { func (*BeginRootfsTarStagingResponse) ProtoMessage() {} func (x *BeginRootfsTarStagingResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[43] + mi := &file_openshell_proto_msgTypes[42] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4321,7 +4232,7 @@ func (x *BeginRootfsTarStagingResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use BeginRootfsTarStagingResponse.ProtoReflect.Descriptor instead. func (*BeginRootfsTarStagingResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{43} + return file_openshell_proto_rawDescGZIP(), []int{42} } func (x *BeginRootfsTarStagingResponse) GetStagingToken() string { @@ -4364,7 +4275,7 @@ type GetSandboxRequest struct { func (x *GetSandboxRequest) Reset() { *x = GetSandboxRequest{} - mi := &file_openshell_proto_msgTypes[44] + mi := &file_openshell_proto_msgTypes[43] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4376,7 +4287,7 @@ func (x *GetSandboxRequest) String() string { func (*GetSandboxRequest) ProtoMessage() {} func (x *GetSandboxRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[44] + mi := &file_openshell_proto_msgTypes[43] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4389,7 +4300,7 @@ func (x *GetSandboxRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetSandboxRequest.ProtoReflect.Descriptor instead. func (*GetSandboxRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{44} + return file_openshell_proto_rawDescGZIP(), []int{43} } func (x *GetSandboxRequest) GetWorkspaceScope() *datamodelv1.WorkspaceSelector { @@ -4425,7 +4336,7 @@ type ListSandboxesRequest struct { func (x *ListSandboxesRequest) Reset() { *x = ListSandboxesRequest{} - mi := &file_openshell_proto_msgTypes[45] + mi := &file_openshell_proto_msgTypes[44] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4437,7 +4348,7 @@ func (x *ListSandboxesRequest) String() string { func (*ListSandboxesRequest) ProtoMessage() {} func (x *ListSandboxesRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[45] + mi := &file_openshell_proto_msgTypes[44] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4450,7 +4361,7 @@ func (x *ListSandboxesRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListSandboxesRequest.ProtoReflect.Descriptor instead. func (*ListSandboxesRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{45} + return file_openshell_proto_rawDescGZIP(), []int{44} } func (x *ListSandboxesRequest) GetWorkspaceScope() *datamodelv1.WorkspaceSelector { @@ -4499,7 +4410,7 @@ type ListSandboxProvidersRequest struct { func (x *ListSandboxProvidersRequest) Reset() { *x = ListSandboxProvidersRequest{} - mi := &file_openshell_proto_msgTypes[46] + mi := &file_openshell_proto_msgTypes[45] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4511,7 +4422,7 @@ func (x *ListSandboxProvidersRequest) String() string { func (*ListSandboxProvidersRequest) ProtoMessage() {} func (x *ListSandboxProvidersRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[46] + mi := &file_openshell_proto_msgTypes[45] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4524,7 +4435,7 @@ func (x *ListSandboxProvidersRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListSandboxProvidersRequest.ProtoReflect.Descriptor instead. func (*ListSandboxProvidersRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{46} + return file_openshell_proto_rawDescGZIP(), []int{45} } func (x *ListSandboxProvidersRequest) GetWorkspaceScope() *datamodelv1.WorkspaceSelector { @@ -4577,7 +4488,7 @@ type AttachSandboxProviderRequest struct { func (x *AttachSandboxProviderRequest) Reset() { *x = AttachSandboxProviderRequest{} - mi := &file_openshell_proto_msgTypes[47] + mi := &file_openshell_proto_msgTypes[46] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4589,7 +4500,7 @@ func (x *AttachSandboxProviderRequest) String() string { func (*AttachSandboxProviderRequest) ProtoMessage() {} func (x *AttachSandboxProviderRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[47] + mi := &file_openshell_proto_msgTypes[46] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4602,7 +4513,7 @@ func (x *AttachSandboxProviderRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use AttachSandboxProviderRequest.ProtoReflect.Descriptor instead. func (*AttachSandboxProviderRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{47} + return file_openshell_proto_rawDescGZIP(), []int{46} } func (x *AttachSandboxProviderRequest) GetWorkspaceScope() *datamodelv1.WorkspaceSelector { @@ -4662,7 +4573,7 @@ type DetachSandboxProviderRequest struct { func (x *DetachSandboxProviderRequest) Reset() { *x = DetachSandboxProviderRequest{} - mi := &file_openshell_proto_msgTypes[48] + mi := &file_openshell_proto_msgTypes[47] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4674,7 +4585,7 @@ func (x *DetachSandboxProviderRequest) String() string { func (*DetachSandboxProviderRequest) ProtoMessage() {} func (x *DetachSandboxProviderRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[48] + mi := &file_openshell_proto_msgTypes[47] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4687,7 +4598,7 @@ func (x *DetachSandboxProviderRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use DetachSandboxProviderRequest.ProtoReflect.Descriptor instead. func (*DetachSandboxProviderRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{48} + return file_openshell_proto_rawDescGZIP(), []int{47} } func (x *DetachSandboxProviderRequest) GetWorkspaceScope() *datamodelv1.WorkspaceSelector { @@ -4744,7 +4655,7 @@ type DeleteSandboxRequest struct { func (x *DeleteSandboxRequest) Reset() { *x = DeleteSandboxRequest{} - mi := &file_openshell_proto_msgTypes[49] + mi := &file_openshell_proto_msgTypes[48] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4756,7 +4667,7 @@ func (x *DeleteSandboxRequest) String() string { func (*DeleteSandboxRequest) ProtoMessage() {} func (x *DeleteSandboxRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[49] + mi := &file_openshell_proto_msgTypes[48] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4769,7 +4680,7 @@ func (x *DeleteSandboxRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteSandboxRequest.ProtoReflect.Descriptor instead. func (*DeleteSandboxRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{49} + return file_openshell_proto_rawDescGZIP(), []int{48} } func (x *DeleteSandboxRequest) GetWorkspaceScope() *datamodelv1.WorkspaceSelector { @@ -4815,7 +4726,7 @@ type StopSandboxRequest struct { func (x *StopSandboxRequest) Reset() { *x = StopSandboxRequest{} - mi := &file_openshell_proto_msgTypes[50] + mi := &file_openshell_proto_msgTypes[49] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4827,7 +4738,7 @@ func (x *StopSandboxRequest) String() string { func (*StopSandboxRequest) ProtoMessage() {} func (x *StopSandboxRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[50] + mi := &file_openshell_proto_msgTypes[49] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4840,7 +4751,7 @@ func (x *StopSandboxRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use StopSandboxRequest.ProtoReflect.Descriptor instead. func (*StopSandboxRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{50} + return file_openshell_proto_rawDescGZIP(), []int{49} } func (x *StopSandboxRequest) GetWorkspaceScope() *datamodelv1.WorkspaceSelector { @@ -4879,7 +4790,7 @@ type StartSandboxRequest struct { func (x *StartSandboxRequest) Reset() { *x = StartSandboxRequest{} - mi := &file_openshell_proto_msgTypes[51] + mi := &file_openshell_proto_msgTypes[50] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4891,7 +4802,7 @@ func (x *StartSandboxRequest) String() string { func (*StartSandboxRequest) ProtoMessage() {} func (x *StartSandboxRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[51] + mi := &file_openshell_proto_msgTypes[50] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4904,7 +4815,7 @@ func (x *StartSandboxRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use StartSandboxRequest.ProtoReflect.Descriptor instead. func (*StartSandboxRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{51} + return file_openshell_proto_rawDescGZIP(), []int{50} } func (x *StartSandboxRequest) GetWorkspaceScope() *datamodelv1.WorkspaceSelector { @@ -4941,7 +4852,7 @@ type SandboxResponse struct { func (x *SandboxResponse) Reset() { *x = SandboxResponse{} - mi := &file_openshell_proto_msgTypes[52] + mi := &file_openshell_proto_msgTypes[51] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4953,7 +4864,7 @@ func (x *SandboxResponse) String() string { func (*SandboxResponse) ProtoMessage() {} func (x *SandboxResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[52] + mi := &file_openshell_proto_msgTypes[51] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4966,7 +4877,7 @@ func (x *SandboxResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use SandboxResponse.ProtoReflect.Descriptor instead. func (*SandboxResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{52} + return file_openshell_proto_rawDescGZIP(), []int{51} } func (x *SandboxResponse) GetSandbox() *Sandbox { @@ -4995,7 +4906,7 @@ type ListSandboxesResponse struct { func (x *ListSandboxesResponse) Reset() { *x = ListSandboxesResponse{} - mi := &file_openshell_proto_msgTypes[53] + mi := &file_openshell_proto_msgTypes[52] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5007,7 +4918,7 @@ func (x *ListSandboxesResponse) String() string { func (*ListSandboxesResponse) ProtoMessage() {} func (x *ListSandboxesResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[53] + mi := &file_openshell_proto_msgTypes[52] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5020,7 +4931,7 @@ func (x *ListSandboxesResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListSandboxesResponse.ProtoReflect.Descriptor instead. func (*ListSandboxesResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{53} + return file_openshell_proto_rawDescGZIP(), []int{52} } func (x *ListSandboxesResponse) GetSandboxes() []*Sandbox { @@ -5049,7 +4960,7 @@ type ListSandboxProvidersResponse struct { func (x *ListSandboxProvidersResponse) Reset() { *x = ListSandboxProvidersResponse{} - mi := &file_openshell_proto_msgTypes[54] + mi := &file_openshell_proto_msgTypes[53] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5061,7 +4972,7 @@ func (x *ListSandboxProvidersResponse) String() string { func (*ListSandboxProvidersResponse) ProtoMessage() {} func (x *ListSandboxProvidersResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[54] + mi := &file_openshell_proto_msgTypes[53] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5074,7 +4985,7 @@ func (x *ListSandboxProvidersResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListSandboxProvidersResponse.ProtoReflect.Descriptor instead. func (*ListSandboxProvidersResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{54} + return file_openshell_proto_rawDescGZIP(), []int{53} } func (x *ListSandboxProvidersResponse) GetProviders() []*datamodelv1.Provider { @@ -5105,7 +5016,7 @@ type AttachSandboxProviderResponse struct { func (x *AttachSandboxProviderResponse) Reset() { *x = AttachSandboxProviderResponse{} - mi := &file_openshell_proto_msgTypes[55] + mi := &file_openshell_proto_msgTypes[54] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5117,7 +5028,7 @@ func (x *AttachSandboxProviderResponse) String() string { func (*AttachSandboxProviderResponse) ProtoMessage() {} func (x *AttachSandboxProviderResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[55] + mi := &file_openshell_proto_msgTypes[54] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5130,7 +5041,7 @@ func (x *AttachSandboxProviderResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use AttachSandboxProviderResponse.ProtoReflect.Descriptor instead. func (*AttachSandboxProviderResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{55} + return file_openshell_proto_rawDescGZIP(), []int{54} } func (x *AttachSandboxProviderResponse) GetSandbox() *Sandbox { @@ -5168,7 +5079,7 @@ type DetachSandboxProviderResponse struct { func (x *DetachSandboxProviderResponse) Reset() { *x = DetachSandboxProviderResponse{} - mi := &file_openshell_proto_msgTypes[56] + mi := &file_openshell_proto_msgTypes[55] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5180,7 +5091,7 @@ func (x *DetachSandboxProviderResponse) String() string { func (*DetachSandboxProviderResponse) ProtoMessage() {} func (x *DetachSandboxProviderResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[56] + mi := &file_openshell_proto_msgTypes[55] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5193,7 +5104,7 @@ func (x *DetachSandboxProviderResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use DetachSandboxProviderResponse.ProtoReflect.Descriptor instead. func (*DetachSandboxProviderResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{56} + return file_openshell_proto_rawDescGZIP(), []int{55} } func (x *DetachSandboxProviderResponse) GetSandbox() *Sandbox { @@ -5235,7 +5146,7 @@ type ProviderDesiredIdentity struct { func (x *ProviderDesiredIdentity) Reset() { *x = ProviderDesiredIdentity{} - mi := &file_openshell_proto_msgTypes[57] + mi := &file_openshell_proto_msgTypes[56] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5247,7 +5158,7 @@ func (x *ProviderDesiredIdentity) String() string { func (*ProviderDesiredIdentity) ProtoMessage() {} func (x *ProviderDesiredIdentity) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[57] + mi := &file_openshell_proto_msgTypes[56] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5260,7 +5171,7 @@ func (x *ProviderDesiredIdentity) ProtoReflect() protoreflect.Message { // Deprecated: Use ProviderDesiredIdentity.ProtoReflect.Descriptor instead. func (*ProviderDesiredIdentity) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{57} + return file_openshell_proto_rawDescGZIP(), []int{56} } func (x *ProviderDesiredIdentity) GetSandboxId() string { @@ -5335,7 +5246,7 @@ type ConfigSnapshotRevision struct { func (x *ConfigSnapshotRevision) Reset() { *x = ConfigSnapshotRevision{} - mi := &file_openshell_proto_msgTypes[58] + mi := &file_openshell_proto_msgTypes[57] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5347,7 +5258,7 @@ func (x *ConfigSnapshotRevision) String() string { func (*ConfigSnapshotRevision) ProtoMessage() {} func (x *ConfigSnapshotRevision) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[58] + mi := &file_openshell_proto_msgTypes[57] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5360,7 +5271,7 @@ func (x *ConfigSnapshotRevision) ProtoReflect() protoreflect.Message { // Deprecated: Use ConfigSnapshotRevision.ProtoReflect.Descriptor instead. func (*ConfigSnapshotRevision) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{58} + return file_openshell_proto_rawDescGZIP(), []int{57} } func (x *ConfigSnapshotRevision) GetComponent() isConfigSnapshotRevision_Component { @@ -5437,7 +5348,7 @@ type SandboxConfigRevision struct { func (x *SandboxConfigRevision) Reset() { *x = SandboxConfigRevision{} - mi := &file_openshell_proto_msgTypes[59] + mi := &file_openshell_proto_msgTypes[58] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5449,7 +5360,7 @@ func (x *SandboxConfigRevision) String() string { func (*SandboxConfigRevision) ProtoMessage() {} func (x *SandboxConfigRevision) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[59] + mi := &file_openshell_proto_msgTypes[58] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5462,7 +5373,7 @@ func (x *SandboxConfigRevision) ProtoReflect() protoreflect.Message { // Deprecated: Use SandboxConfigRevision.ProtoReflect.Descriptor instead. func (*SandboxConfigRevision) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{59} + return file_openshell_proto_rawDescGZIP(), []int{58} } func (x *SandboxConfigRevision) GetConfigRevision() uint64 { @@ -5521,7 +5432,7 @@ type ConfigUpdateOperation struct { func (x *ConfigUpdateOperation) Reset() { *x = ConfigUpdateOperation{} - mi := &file_openshell_proto_msgTypes[60] + mi := &file_openshell_proto_msgTypes[59] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5533,7 +5444,7 @@ func (x *ConfigUpdateOperation) String() string { func (*ConfigUpdateOperation) ProtoMessage() {} func (x *ConfigUpdateOperation) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[60] + mi := &file_openshell_proto_msgTypes[59] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5546,7 +5457,7 @@ func (x *ConfigUpdateOperation) ProtoReflect() protoreflect.Message { // Deprecated: Use ConfigUpdateOperation.ProtoReflect.Descriptor instead. func (*ConfigUpdateOperation) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{60} + return file_openshell_proto_rawDescGZIP(), []int{59} } func (x *ConfigUpdateOperation) GetOperationId() string { @@ -5636,7 +5547,7 @@ type ProviderMutationReceipt struct { func (x *ProviderMutationReceipt) Reset() { *x = ProviderMutationReceipt{} - mi := &file_openshell_proto_msgTypes[61] + mi := &file_openshell_proto_msgTypes[60] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5648,7 +5559,7 @@ func (x *ProviderMutationReceipt) String() string { func (*ProviderMutationReceipt) ProtoMessage() {} func (x *ProviderMutationReceipt) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[61] + mi := &file_openshell_proto_msgTypes[60] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5661,7 +5572,7 @@ func (x *ProviderMutationReceipt) ProtoReflect() protoreflect.Message { // Deprecated: Use ProviderMutationReceipt.ProtoReflect.Descriptor instead. func (*ProviderMutationReceipt) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{61} + return file_openshell_proto_rawDescGZIP(), []int{60} } func (x *ProviderMutationReceipt) GetReceiptId() string { @@ -5737,7 +5648,7 @@ type ProviderReadinessObservation struct { func (x *ProviderReadinessObservation) Reset() { *x = ProviderReadinessObservation{} - mi := &file_openshell_proto_msgTypes[62] + mi := &file_openshell_proto_msgTypes[61] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5749,7 +5660,7 @@ func (x *ProviderReadinessObservation) String() string { func (*ProviderReadinessObservation) ProtoMessage() {} func (x *ProviderReadinessObservation) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[62] + mi := &file_openshell_proto_msgTypes[61] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5762,7 +5673,7 @@ func (x *ProviderReadinessObservation) ProtoReflect() protoreflect.Message { // Deprecated: Use ProviderReadinessObservation.ProtoReflect.Descriptor instead. func (*ProviderReadinessObservation) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{62} + return file_openshell_proto_rawDescGZIP(), []int{61} } func (x *ProviderReadinessObservation) GetSessionId() string { @@ -5861,7 +5772,7 @@ type ProviderReadinessStatus struct { func (x *ProviderReadinessStatus) Reset() { *x = ProviderReadinessStatus{} - mi := &file_openshell_proto_msgTypes[63] + mi := &file_openshell_proto_msgTypes[62] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5873,7 +5784,7 @@ func (x *ProviderReadinessStatus) String() string { func (*ProviderReadinessStatus) ProtoMessage() {} func (x *ProviderReadinessStatus) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[63] + mi := &file_openshell_proto_msgTypes[62] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5886,7 +5797,7 @@ func (x *ProviderReadinessStatus) ProtoReflect() protoreflect.Message { // Deprecated: Use ProviderReadinessStatus.ProtoReflect.Descriptor instead. func (*ProviderReadinessStatus) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{63} + return file_openshell_proto_rawDescGZIP(), []int{62} } func (x *ProviderReadinessStatus) GetReceipt() *ProviderMutationReceipt { @@ -5960,7 +5871,7 @@ type GetSandboxProviderStatusRequest struct { func (x *GetSandboxProviderStatusRequest) Reset() { *x = GetSandboxProviderStatusRequest{} - mi := &file_openshell_proto_msgTypes[64] + mi := &file_openshell_proto_msgTypes[63] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5972,7 +5883,7 @@ func (x *GetSandboxProviderStatusRequest) String() string { func (*GetSandboxProviderStatusRequest) ProtoMessage() {} func (x *GetSandboxProviderStatusRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[64] + mi := &file_openshell_proto_msgTypes[63] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5985,7 +5896,7 @@ func (x *GetSandboxProviderStatusRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetSandboxProviderStatusRequest.ProtoReflect.Descriptor instead. func (*GetSandboxProviderStatusRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{64} + return file_openshell_proto_rawDescGZIP(), []int{63} } func (x *GetSandboxProviderStatusRequest) GetWorkspaceScope() *datamodelv1.WorkspaceSelector { @@ -6025,7 +5936,7 @@ type GetSandboxProviderStatusResponse struct { func (x *GetSandboxProviderStatusResponse) Reset() { *x = GetSandboxProviderStatusResponse{} - mi := &file_openshell_proto_msgTypes[65] + mi := &file_openshell_proto_msgTypes[64] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6037,7 +5948,7 @@ func (x *GetSandboxProviderStatusResponse) String() string { func (*GetSandboxProviderStatusResponse) ProtoMessage() {} func (x *GetSandboxProviderStatusResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[65] + mi := &file_openshell_proto_msgTypes[64] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6050,7 +5961,7 @@ func (x *GetSandboxProviderStatusResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use GetSandboxProviderStatusResponse.ProtoReflect.Descriptor instead. func (*GetSandboxProviderStatusResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{65} + return file_openshell_proto_rawDescGZIP(), []int{64} } func (x *GetSandboxProviderStatusResponse) GetStatus() *ProviderReadinessStatus { @@ -6072,7 +5983,7 @@ type ReportProviderReadinessRequest struct { func (x *ReportProviderReadinessRequest) Reset() { *x = ReportProviderReadinessRequest{} - mi := &file_openshell_proto_msgTypes[66] + mi := &file_openshell_proto_msgTypes[65] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6084,7 +5995,7 @@ func (x *ReportProviderReadinessRequest) String() string { func (*ReportProviderReadinessRequest) ProtoMessage() {} func (x *ReportProviderReadinessRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[66] + mi := &file_openshell_proto_msgTypes[65] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6097,7 +6008,7 @@ func (x *ReportProviderReadinessRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ReportProviderReadinessRequest.ProtoReflect.Descriptor instead. func (*ReportProviderReadinessRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{66} + return file_openshell_proto_rawDescGZIP(), []int{65} } func (x *ReportProviderReadinessRequest) GetSandboxId() string { @@ -6127,7 +6038,7 @@ type ReportProviderReadinessResponse struct { func (x *ReportProviderReadinessResponse) Reset() { *x = ReportProviderReadinessResponse{} - mi := &file_openshell_proto_msgTypes[67] + mi := &file_openshell_proto_msgTypes[66] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6139,7 +6050,7 @@ func (x *ReportProviderReadinessResponse) String() string { func (*ReportProviderReadinessResponse) ProtoMessage() {} func (x *ReportProviderReadinessResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[67] + mi := &file_openshell_proto_msgTypes[66] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6152,7 +6063,7 @@ func (x *ReportProviderReadinessResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ReportProviderReadinessResponse.ProtoReflect.Descriptor instead. func (*ReportProviderReadinessResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{67} + return file_openshell_proto_rawDescGZIP(), []int{66} } func (x *ReportProviderReadinessResponse) GetAcceptedSequence() uint64 { @@ -6189,7 +6100,7 @@ type DeleteSandboxResponse struct { func (x *DeleteSandboxResponse) Reset() { *x = DeleteSandboxResponse{} - mi := &file_openshell_proto_msgTypes[68] + mi := &file_openshell_proto_msgTypes[67] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6201,7 +6112,7 @@ func (x *DeleteSandboxResponse) String() string { func (*DeleteSandboxResponse) ProtoMessage() {} func (x *DeleteSandboxResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[68] + mi := &file_openshell_proto_msgTypes[67] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6214,7 +6125,7 @@ func (x *DeleteSandboxResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteSandboxResponse.ProtoReflect.Descriptor instead. func (*DeleteSandboxResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{68} + return file_openshell_proto_rawDescGZIP(), []int{67} } func (x *DeleteSandboxResponse) GetOutcome() DeletionOutcome { @@ -6243,7 +6154,7 @@ type CreateSshSessionRequest struct { func (x *CreateSshSessionRequest) Reset() { *x = CreateSshSessionRequest{} - mi := &file_openshell_proto_msgTypes[69] + mi := &file_openshell_proto_msgTypes[68] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6255,7 +6166,7 @@ func (x *CreateSshSessionRequest) String() string { func (*CreateSshSessionRequest) ProtoMessage() {} func (x *CreateSshSessionRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[69] + mi := &file_openshell_proto_msgTypes[68] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6268,7 +6179,7 @@ func (x *CreateSshSessionRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use CreateSshSessionRequest.ProtoReflect.Descriptor instead. func (*CreateSshSessionRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{69} + return file_openshell_proto_rawDescGZIP(), []int{68} } func (x *CreateSshSessionRequest) GetWorkspaceScope() *datamodelv1.WorkspaceSelector { @@ -6319,7 +6230,7 @@ type CreateSshSessionResponse struct { func (x *CreateSshSessionResponse) Reset() { *x = CreateSshSessionResponse{} - mi := &file_openshell_proto_msgTypes[70] + mi := &file_openshell_proto_msgTypes[69] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6331,7 +6242,7 @@ func (x *CreateSshSessionResponse) String() string { func (*CreateSshSessionResponse) ProtoMessage() {} func (x *CreateSshSessionResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[70] + mi := &file_openshell_proto_msgTypes[69] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6344,7 +6255,7 @@ func (x *CreateSshSessionResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use CreateSshSessionResponse.ProtoReflect.Descriptor instead. func (*CreateSshSessionResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{70} + return file_openshell_proto_rawDescGZIP(), []int{69} } func (x *CreateSshSessionResponse) GetSandboxId() string { @@ -6419,7 +6330,7 @@ type ExposeServiceRequest struct { func (x *ExposeServiceRequest) Reset() { *x = ExposeServiceRequest{} - mi := &file_openshell_proto_msgTypes[71] + mi := &file_openshell_proto_msgTypes[70] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6431,7 +6342,7 @@ func (x *ExposeServiceRequest) String() string { func (*ExposeServiceRequest) ProtoMessage() {} func (x *ExposeServiceRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[71] + mi := &file_openshell_proto_msgTypes[70] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6444,7 +6355,7 @@ func (x *ExposeServiceRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ExposeServiceRequest.ProtoReflect.Descriptor instead. func (*ExposeServiceRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{71} + return file_openshell_proto_rawDescGZIP(), []int{70} } func (x *ExposeServiceRequest) GetWorkspaceScope() *datamodelv1.WorkspaceSelector { @@ -6510,7 +6421,7 @@ type GetServiceRequest struct { func (x *GetServiceRequest) Reset() { *x = GetServiceRequest{} - mi := &file_openshell_proto_msgTypes[72] + mi := &file_openshell_proto_msgTypes[71] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6522,7 +6433,7 @@ func (x *GetServiceRequest) String() string { func (*GetServiceRequest) ProtoMessage() {} func (x *GetServiceRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[72] + mi := &file_openshell_proto_msgTypes[71] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6535,7 +6446,7 @@ func (x *GetServiceRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetServiceRequest.ProtoReflect.Descriptor instead. func (*GetServiceRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{72} + return file_openshell_proto_rawDescGZIP(), []int{71} } func (x *GetServiceRequest) GetWorkspaceScope() *datamodelv1.WorkspaceSelector { @@ -6578,7 +6489,7 @@ type ListServicesRequest struct { func (x *ListServicesRequest) Reset() { *x = ListServicesRequest{} - mi := &file_openshell_proto_msgTypes[73] + mi := &file_openshell_proto_msgTypes[72] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6590,7 +6501,7 @@ func (x *ListServicesRequest) String() string { func (*ListServicesRequest) ProtoMessage() {} func (x *ListServicesRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[73] + mi := &file_openshell_proto_msgTypes[72] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6603,7 +6514,7 @@ func (x *ListServicesRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListServicesRequest.ProtoReflect.Descriptor instead. func (*ListServicesRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{73} + return file_openshell_proto_rawDescGZIP(), []int{72} } func (x *ListServicesRequest) GetWorkspaceScope() *datamodelv1.WorkspaceSelector { @@ -6646,7 +6557,7 @@ type ListServicesResponse struct { func (x *ListServicesResponse) Reset() { *x = ListServicesResponse{} - mi := &file_openshell_proto_msgTypes[74] + mi := &file_openshell_proto_msgTypes[73] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6658,7 +6569,7 @@ func (x *ListServicesResponse) String() string { func (*ListServicesResponse) ProtoMessage() {} func (x *ListServicesResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[74] + mi := &file_openshell_proto_msgTypes[73] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6671,7 +6582,7 @@ func (x *ListServicesResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListServicesResponse.ProtoReflect.Descriptor instead. func (*ListServicesResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{74} + return file_openshell_proto_rawDescGZIP(), []int{73} } func (x *ListServicesResponse) GetServices() []*ServiceEndpointResponse { @@ -6706,7 +6617,7 @@ type DeleteServiceRequest struct { func (x *DeleteServiceRequest) Reset() { *x = DeleteServiceRequest{} - mi := &file_openshell_proto_msgTypes[75] + mi := &file_openshell_proto_msgTypes[74] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6718,7 +6629,7 @@ func (x *DeleteServiceRequest) String() string { func (*DeleteServiceRequest) ProtoMessage() {} func (x *DeleteServiceRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[75] + mi := &file_openshell_proto_msgTypes[74] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6731,7 +6642,7 @@ func (x *DeleteServiceRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteServiceRequest.ProtoReflect.Descriptor instead. func (*DeleteServiceRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{75} + return file_openshell_proto_rawDescGZIP(), []int{74} } func (x *DeleteServiceRequest) GetWorkspaceScope() *datamodelv1.WorkspaceSelector { @@ -6779,7 +6690,7 @@ type DeleteServiceResponse struct { func (x *DeleteServiceResponse) Reset() { *x = DeleteServiceResponse{} - mi := &file_openshell_proto_msgTypes[76] + mi := &file_openshell_proto_msgTypes[75] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6791,7 +6702,7 @@ func (x *DeleteServiceResponse) String() string { func (*DeleteServiceResponse) ProtoMessage() {} func (x *DeleteServiceResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[76] + mi := &file_openshell_proto_msgTypes[75] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6804,7 +6715,7 @@ func (x *DeleteServiceResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteServiceResponse.ProtoReflect.Descriptor instead. func (*DeleteServiceResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{76} + return file_openshell_proto_rawDescGZIP(), []int{75} } func (x *DeleteServiceResponse) GetOutcome() DeletionOutcome { @@ -6837,7 +6748,7 @@ type ServiceEndpoint struct { func (x *ServiceEndpoint) Reset() { *x = ServiceEndpoint{} - mi := &file_openshell_proto_msgTypes[77] + mi := &file_openshell_proto_msgTypes[76] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6849,7 +6760,7 @@ func (x *ServiceEndpoint) String() string { func (*ServiceEndpoint) ProtoMessage() {} func (x *ServiceEndpoint) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[77] + mi := &file_openshell_proto_msgTypes[76] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6862,7 +6773,7 @@ func (x *ServiceEndpoint) ProtoReflect() protoreflect.Message { // Deprecated: Use ServiceEndpoint.ProtoReflect.Descriptor instead. func (*ServiceEndpoint) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{77} + return file_openshell_proto_rawDescGZIP(), []int{76} } func (x *ServiceEndpoint) GetMetadata() *datamodelv1.ObjectMeta { @@ -6925,7 +6836,7 @@ type ServiceEndpointResponse struct { func (x *ServiceEndpointResponse) Reset() { *x = ServiceEndpointResponse{} - mi := &file_openshell_proto_msgTypes[78] + mi := &file_openshell_proto_msgTypes[77] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6937,7 +6848,7 @@ func (x *ServiceEndpointResponse) String() string { func (*ServiceEndpointResponse) ProtoMessage() {} func (x *ServiceEndpointResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[78] + mi := &file_openshell_proto_msgTypes[77] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6950,7 +6861,7 @@ func (x *ServiceEndpointResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ServiceEndpointResponse.ProtoReflect.Descriptor instead. func (*ServiceEndpointResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{78} + return file_openshell_proto_rawDescGZIP(), []int{77} } func (x *ServiceEndpointResponse) GetEndpoint() *ServiceEndpoint { @@ -6981,7 +6892,7 @@ type RevokeSshSessionRequest struct { func (x *RevokeSshSessionRequest) Reset() { *x = RevokeSshSessionRequest{} - mi := &file_openshell_proto_msgTypes[79] + mi := &file_openshell_proto_msgTypes[78] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6993,7 +6904,7 @@ func (x *RevokeSshSessionRequest) String() string { func (*RevokeSshSessionRequest) ProtoMessage() {} func (x *RevokeSshSessionRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[79] + mi := &file_openshell_proto_msgTypes[78] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7006,7 +6917,7 @@ func (x *RevokeSshSessionRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use RevokeSshSessionRequest.ProtoReflect.Descriptor instead. func (*RevokeSshSessionRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{79} + return file_openshell_proto_rawDescGZIP(), []int{78} } func (x *RevokeSshSessionRequest) GetToken() string { @@ -7033,7 +6944,7 @@ type RevokeSshSessionResponse struct { func (x *RevokeSshSessionResponse) Reset() { *x = RevokeSshSessionResponse{} - mi := &file_openshell_proto_msgTypes[80] + mi := &file_openshell_proto_msgTypes[79] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7045,7 +6956,7 @@ func (x *RevokeSshSessionResponse) String() string { func (*RevokeSshSessionResponse) ProtoMessage() {} func (x *RevokeSshSessionResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[80] + mi := &file_openshell_proto_msgTypes[79] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7058,7 +6969,7 @@ func (x *RevokeSshSessionResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use RevokeSshSessionResponse.ProtoReflect.Descriptor instead. func (*RevokeSshSessionResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{80} + return file_openshell_proto_rawDescGZIP(), []int{79} } func (x *RevokeSshSessionResponse) GetOutcome() DeletionOutcome { @@ -7108,7 +7019,7 @@ type ExecSandboxRequest struct { func (x *ExecSandboxRequest) Reset() { *x = ExecSandboxRequest{} - mi := &file_openshell_proto_msgTypes[81] + mi := &file_openshell_proto_msgTypes[80] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7120,7 +7031,7 @@ func (x *ExecSandboxRequest) String() string { func (*ExecSandboxRequest) ProtoMessage() {} func (x *ExecSandboxRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[81] + mi := &file_openshell_proto_msgTypes[80] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7133,7 +7044,7 @@ func (x *ExecSandboxRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ExecSandboxRequest.ProtoReflect.Descriptor instead. func (*ExecSandboxRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{81} + return file_openshell_proto_rawDescGZIP(), []int{80} } func (x *ExecSandboxRequest) GetWorkspaceScope() *datamodelv1.WorkspaceSelector { @@ -7230,7 +7141,7 @@ type ExecSandboxStdout struct { func (x *ExecSandboxStdout) Reset() { *x = ExecSandboxStdout{} - mi := &file_openshell_proto_msgTypes[82] + mi := &file_openshell_proto_msgTypes[81] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7242,7 +7153,7 @@ func (x *ExecSandboxStdout) String() string { func (*ExecSandboxStdout) ProtoMessage() {} func (x *ExecSandboxStdout) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[82] + mi := &file_openshell_proto_msgTypes[81] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7255,7 +7166,7 @@ func (x *ExecSandboxStdout) ProtoReflect() protoreflect.Message { // Deprecated: Use ExecSandboxStdout.ProtoReflect.Descriptor instead. func (*ExecSandboxStdout) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{82} + return file_openshell_proto_rawDescGZIP(), []int{81} } func (x *ExecSandboxStdout) GetData() []byte { @@ -7275,7 +7186,7 @@ type ExecSandboxStderr struct { func (x *ExecSandboxStderr) Reset() { *x = ExecSandboxStderr{} - mi := &file_openshell_proto_msgTypes[83] + mi := &file_openshell_proto_msgTypes[82] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7287,7 +7198,7 @@ func (x *ExecSandboxStderr) String() string { func (*ExecSandboxStderr) ProtoMessage() {} func (x *ExecSandboxStderr) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[83] + mi := &file_openshell_proto_msgTypes[82] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7300,7 +7211,7 @@ func (x *ExecSandboxStderr) ProtoReflect() protoreflect.Message { // Deprecated: Use ExecSandboxStderr.ProtoReflect.Descriptor instead. func (*ExecSandboxStderr) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{83} + return file_openshell_proto_rawDescGZIP(), []int{82} } func (x *ExecSandboxStderr) GetData() []byte { @@ -7320,7 +7231,7 @@ type ExecSandboxExit struct { func (x *ExecSandboxExit) Reset() { *x = ExecSandboxExit{} - mi := &file_openshell_proto_msgTypes[84] + mi := &file_openshell_proto_msgTypes[83] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7332,7 +7243,7 @@ func (x *ExecSandboxExit) String() string { func (*ExecSandboxExit) ProtoMessage() {} func (x *ExecSandboxExit) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[84] + mi := &file_openshell_proto_msgTypes[83] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7345,7 +7256,7 @@ func (x *ExecSandboxExit) ProtoReflect() protoreflect.Message { // Deprecated: Use ExecSandboxExit.ProtoReflect.Descriptor instead. func (*ExecSandboxExit) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{84} + return file_openshell_proto_rawDescGZIP(), []int{83} } func (x *ExecSandboxExit) GetExitCode() int32 { @@ -7370,7 +7281,7 @@ type ExecSandboxEvent struct { func (x *ExecSandboxEvent) Reset() { *x = ExecSandboxEvent{} - mi := &file_openshell_proto_msgTypes[85] + mi := &file_openshell_proto_msgTypes[84] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7382,7 +7293,7 @@ func (x *ExecSandboxEvent) String() string { func (*ExecSandboxEvent) ProtoMessage() {} func (x *ExecSandboxEvent) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[85] + mi := &file_openshell_proto_msgTypes[84] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7395,7 +7306,7 @@ func (x *ExecSandboxEvent) ProtoReflect() protoreflect.Message { // Deprecated: Use ExecSandboxEvent.ProtoReflect.Descriptor instead. func (*ExecSandboxEvent) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{85} + return file_openshell_proto_rawDescGZIP(), []int{84} } func (x *ExecSandboxEvent) GetPayload() isExecSandboxEvent_Payload { @@ -7477,7 +7388,7 @@ type TcpForwardInit struct { func (x *TcpForwardInit) Reset() { *x = TcpForwardInit{} - mi := &file_openshell_proto_msgTypes[86] + mi := &file_openshell_proto_msgTypes[85] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7489,7 +7400,7 @@ func (x *TcpForwardInit) String() string { func (*TcpForwardInit) ProtoMessage() {} func (x *TcpForwardInit) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[86] + mi := &file_openshell_proto_msgTypes[85] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7502,7 +7413,7 @@ func (x *TcpForwardInit) ProtoReflect() protoreflect.Message { // Deprecated: Use TcpForwardInit.ProtoReflect.Descriptor instead. func (*TcpForwardInit) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{86} + return file_openshell_proto_rawDescGZIP(), []int{85} } func (x *TcpForwardInit) GetSandbox() string { @@ -7588,7 +7499,7 @@ type TcpForwardFrame struct { func (x *TcpForwardFrame) Reset() { *x = TcpForwardFrame{} - mi := &file_openshell_proto_msgTypes[87] + mi := &file_openshell_proto_msgTypes[86] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7600,7 +7511,7 @@ func (x *TcpForwardFrame) String() string { func (*TcpForwardFrame) ProtoMessage() {} func (x *TcpForwardFrame) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[87] + mi := &file_openshell_proto_msgTypes[86] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7613,7 +7524,7 @@ func (x *TcpForwardFrame) ProtoReflect() protoreflect.Message { // Deprecated: Use TcpForwardFrame.ProtoReflect.Descriptor instead. func (*TcpForwardFrame) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{87} + return file_openshell_proto_rawDescGZIP(), []int{86} } func (x *TcpForwardFrame) GetPayload() isTcpForwardFrame_Payload { @@ -7672,7 +7583,7 @@ type ExecSandboxInput struct { func (x *ExecSandboxInput) Reset() { *x = ExecSandboxInput{} - mi := &file_openshell_proto_msgTypes[88] + mi := &file_openshell_proto_msgTypes[87] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7684,7 +7595,7 @@ func (x *ExecSandboxInput) String() string { func (*ExecSandboxInput) ProtoMessage() {} func (x *ExecSandboxInput) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[88] + mi := &file_openshell_proto_msgTypes[87] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7697,7 +7608,7 @@ func (x *ExecSandboxInput) ProtoReflect() protoreflect.Message { // Deprecated: Use ExecSandboxInput.ProtoReflect.Descriptor instead. func (*ExecSandboxInput) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{88} + return file_openshell_proto_rawDescGZIP(), []int{87} } func (x *ExecSandboxInput) GetPayload() isExecSandboxInput_Payload { @@ -7770,7 +7681,7 @@ type ExecSandboxWindowResize struct { func (x *ExecSandboxWindowResize) Reset() { *x = ExecSandboxWindowResize{} - mi := &file_openshell_proto_msgTypes[89] + mi := &file_openshell_proto_msgTypes[88] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7782,7 +7693,7 @@ func (x *ExecSandboxWindowResize) String() string { func (*ExecSandboxWindowResize) ProtoMessage() {} func (x *ExecSandboxWindowResize) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[89] + mi := &file_openshell_proto_msgTypes[88] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7795,7 +7706,7 @@ func (x *ExecSandboxWindowResize) ProtoReflect() protoreflect.Message { // Deprecated: Use ExecSandboxWindowResize.ProtoReflect.Descriptor instead. func (*ExecSandboxWindowResize) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{89} + return file_openshell_proto_rawDescGZIP(), []int{88} } func (x *ExecSandboxWindowResize) GetCols() uint32 { @@ -7831,7 +7742,7 @@ type SshSession struct { func (x *SshSession) Reset() { *x = SshSession{} - mi := &file_openshell_proto_msgTypes[90] + mi := &file_openshell_proto_msgTypes[89] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7843,7 +7754,7 @@ func (x *SshSession) String() string { func (*SshSession) ProtoMessage() {} func (x *SshSession) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[90] + mi := &file_openshell_proto_msgTypes[89] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7856,7 +7767,7 @@ func (x *SshSession) ProtoReflect() protoreflect.Message { // Deprecated: Use SshSession.ProtoReflect.Descriptor instead. func (*SshSession) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{90} + return file_openshell_proto_rawDescGZIP(), []int{89} } func (x *SshSession) GetMetadata() *datamodelv1.ObjectMeta { @@ -7945,7 +7856,7 @@ type WatchSandboxRequest struct { func (x *WatchSandboxRequest) Reset() { *x = WatchSandboxRequest{} - mi := &file_openshell_proto_msgTypes[91] + mi := &file_openshell_proto_msgTypes[90] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7957,7 +7868,7 @@ func (x *WatchSandboxRequest) String() string { func (*WatchSandboxRequest) ProtoMessage() {} func (x *WatchSandboxRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[91] + mi := &file_openshell_proto_msgTypes[90] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7970,7 +7881,7 @@ func (x *WatchSandboxRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use WatchSandboxRequest.ProtoReflect.Descriptor instead. func (*WatchSandboxRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{91} + return file_openshell_proto_rawDescGZIP(), []int{90} } func (x *WatchSandboxRequest) GetWorkspaceScope() *datamodelv1.WorkspaceSelector { @@ -8086,7 +7997,7 @@ type SandboxStreamEvent struct { func (x *SandboxStreamEvent) Reset() { *x = SandboxStreamEvent{} - mi := &file_openshell_proto_msgTypes[92] + mi := &file_openshell_proto_msgTypes[91] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8098,7 +8009,7 @@ func (x *SandboxStreamEvent) String() string { func (*SandboxStreamEvent) ProtoMessage() {} func (x *SandboxStreamEvent) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[92] + mi := &file_openshell_proto_msgTypes[91] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8111,7 +8022,7 @@ func (x *SandboxStreamEvent) ProtoReflect() protoreflect.Message { // Deprecated: Use SandboxStreamEvent.ProtoReflect.Descriptor instead. func (*SandboxStreamEvent) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{92} + return file_openshell_proto_rawDescGZIP(), []int{91} } func (x *SandboxStreamEvent) GetPayload() isSandboxStreamEvent_Payload { @@ -8233,7 +8144,7 @@ type SandboxLogLine struct { func (x *SandboxLogLine) Reset() { *x = SandboxLogLine{} - mi := &file_openshell_proto_msgTypes[93] + mi := &file_openshell_proto_msgTypes[92] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8245,7 +8156,7 @@ func (x *SandboxLogLine) String() string { func (*SandboxLogLine) ProtoMessage() {} func (x *SandboxLogLine) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[93] + mi := &file_openshell_proto_msgTypes[92] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8258,7 +8169,7 @@ func (x *SandboxLogLine) ProtoReflect() protoreflect.Message { // Deprecated: Use SandboxLogLine.ProtoReflect.Descriptor instead. func (*SandboxLogLine) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{93} + return file_openshell_proto_rawDescGZIP(), []int{92} } func (x *SandboxLogLine) GetSandboxId() string { @@ -8324,7 +8235,7 @@ type SandboxStreamWarning struct { func (x *SandboxStreamWarning) Reset() { *x = SandboxStreamWarning{} - mi := &file_openshell_proto_msgTypes[94] + mi := &file_openshell_proto_msgTypes[93] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8336,7 +8247,7 @@ func (x *SandboxStreamWarning) String() string { func (*SandboxStreamWarning) ProtoMessage() {} func (x *SandboxStreamWarning) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[94] + mi := &file_openshell_proto_msgTypes[93] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8349,7 +8260,7 @@ func (x *SandboxStreamWarning) ProtoReflect() protoreflect.Message { // Deprecated: Use SandboxStreamWarning.ProtoReflect.Descriptor instead. func (*SandboxStreamWarning) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{94} + return file_openshell_proto_rawDescGZIP(), []int{93} } func (x *SandboxStreamWarning) GetMessage() string { @@ -8374,7 +8285,7 @@ type CreateProviderRequest struct { func (x *CreateProviderRequest) Reset() { *x = CreateProviderRequest{} - mi := &file_openshell_proto_msgTypes[95] + mi := &file_openshell_proto_msgTypes[94] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8386,7 +8297,7 @@ func (x *CreateProviderRequest) String() string { func (*CreateProviderRequest) ProtoMessage() {} func (x *CreateProviderRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[95] + mi := &file_openshell_proto_msgTypes[94] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8399,7 +8310,7 @@ func (x *CreateProviderRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use CreateProviderRequest.ProtoReflect.Descriptor instead. func (*CreateProviderRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{95} + return file_openshell_proto_rawDescGZIP(), []int{94} } func (x *CreateProviderRequest) GetWorkspaceScope() *datamodelv1.WorkspaceSelector { @@ -8435,7 +8346,7 @@ type GetProviderRequest struct { func (x *GetProviderRequest) Reset() { *x = GetProviderRequest{} - mi := &file_openshell_proto_msgTypes[96] + mi := &file_openshell_proto_msgTypes[95] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8447,7 +8358,7 @@ func (x *GetProviderRequest) String() string { func (*GetProviderRequest) ProtoMessage() {} func (x *GetProviderRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[96] + mi := &file_openshell_proto_msgTypes[95] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8460,7 +8371,7 @@ func (x *GetProviderRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetProviderRequest.ProtoReflect.Descriptor instead. func (*GetProviderRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{96} + return file_openshell_proto_rawDescGZIP(), []int{95} } func (x *GetProviderRequest) GetWorkspaceScope() *datamodelv1.WorkspaceSelector { @@ -8495,7 +8406,7 @@ type GetProviderCredentialsRequest struct { func (x *GetProviderCredentialsRequest) Reset() { *x = GetProviderCredentialsRequest{} - mi := &file_openshell_proto_msgTypes[97] + mi := &file_openshell_proto_msgTypes[96] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8507,7 +8418,7 @@ func (x *GetProviderCredentialsRequest) String() string { func (*GetProviderCredentialsRequest) ProtoMessage() {} func (x *GetProviderCredentialsRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[97] + mi := &file_openshell_proto_msgTypes[96] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8520,7 +8431,7 @@ func (x *GetProviderCredentialsRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetProviderCredentialsRequest.ProtoReflect.Descriptor instead. func (*GetProviderCredentialsRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{97} + return file_openshell_proto_rawDescGZIP(), []int{96} } func (x *GetProviderCredentialsRequest) GetWorkspaceScope() *datamodelv1.WorkspaceSelector { @@ -8563,7 +8474,7 @@ type ProviderCredentialValue struct { func (x *ProviderCredentialValue) Reset() { *x = ProviderCredentialValue{} - mi := &file_openshell_proto_msgTypes[98] + mi := &file_openshell_proto_msgTypes[97] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8575,7 +8486,7 @@ func (x *ProviderCredentialValue) String() string { func (*ProviderCredentialValue) ProtoMessage() {} func (x *ProviderCredentialValue) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[98] + mi := &file_openshell_proto_msgTypes[97] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8588,7 +8499,7 @@ func (x *ProviderCredentialValue) ProtoReflect() protoreflect.Message { // Deprecated: Use ProviderCredentialValue.ProtoReflect.Descriptor instead. func (*ProviderCredentialValue) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{98} + return file_openshell_proto_rawDescGZIP(), []int{97} } func (x *ProviderCredentialValue) GetValue() string { @@ -8615,7 +8526,7 @@ type GetProviderCredentialsResponse struct { func (x *GetProviderCredentialsResponse) Reset() { *x = GetProviderCredentialsResponse{} - mi := &file_openshell_proto_msgTypes[99] + mi := &file_openshell_proto_msgTypes[98] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8627,7 +8538,7 @@ func (x *GetProviderCredentialsResponse) String() string { func (*GetProviderCredentialsResponse) ProtoMessage() {} func (x *GetProviderCredentialsResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[99] + mi := &file_openshell_proto_msgTypes[98] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8640,7 +8551,7 @@ func (x *GetProviderCredentialsResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use GetProviderCredentialsResponse.ProtoReflect.Descriptor instead. func (*GetProviderCredentialsResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{99} + return file_openshell_proto_rawDescGZIP(), []int{98} } func (x *GetProviderCredentialsResponse) GetCredentials() map[string]*ProviderCredentialValue { @@ -8669,7 +8580,7 @@ type ListProvidersRequest struct { func (x *ListProvidersRequest) Reset() { *x = ListProvidersRequest{} - mi := &file_openshell_proto_msgTypes[100] + mi := &file_openshell_proto_msgTypes[99] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8681,7 +8592,7 @@ func (x *ListProvidersRequest) String() string { func (*ListProvidersRequest) ProtoMessage() {} func (x *ListProvidersRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[100] + mi := &file_openshell_proto_msgTypes[99] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8694,7 +8605,7 @@ func (x *ListProvidersRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListProvidersRequest.ProtoReflect.Descriptor instead. func (*ListProvidersRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{100} + return file_openshell_proto_rawDescGZIP(), []int{99} } func (x *ListProvidersRequest) GetWorkspaceScope() *datamodelv1.WorkspaceSelector { @@ -8746,7 +8657,7 @@ type UpdateProviderRequest struct { func (x *UpdateProviderRequest) Reset() { *x = UpdateProviderRequest{} - mi := &file_openshell_proto_msgTypes[101] + mi := &file_openshell_proto_msgTypes[100] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8758,7 +8669,7 @@ func (x *UpdateProviderRequest) String() string { func (*UpdateProviderRequest) ProtoMessage() {} func (x *UpdateProviderRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[101] + mi := &file_openshell_proto_msgTypes[100] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8771,7 +8682,7 @@ func (x *UpdateProviderRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use UpdateProviderRequest.ProtoReflect.Descriptor instead. func (*UpdateProviderRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{101} + return file_openshell_proto_rawDescGZIP(), []int{100} } func (x *UpdateProviderRequest) GetWorkspaceScope() *datamodelv1.WorkspaceSelector { @@ -8825,7 +8736,7 @@ type DeleteProviderRequest struct { func (x *DeleteProviderRequest) Reset() { *x = DeleteProviderRequest{} - mi := &file_openshell_proto_msgTypes[102] + mi := &file_openshell_proto_msgTypes[101] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8837,7 +8748,7 @@ func (x *DeleteProviderRequest) String() string { func (*DeleteProviderRequest) ProtoMessage() {} func (x *DeleteProviderRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[102] + mi := &file_openshell_proto_msgTypes[101] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8850,7 +8761,7 @@ func (x *DeleteProviderRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteProviderRequest.ProtoReflect.Descriptor instead. func (*DeleteProviderRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{102} + return file_openshell_proto_rawDescGZIP(), []int{101} } func (x *DeleteProviderRequest) GetWorkspaceScope() *datamodelv1.WorkspaceSelector { @@ -8896,7 +8807,7 @@ type ProviderResponse struct { func (x *ProviderResponse) Reset() { *x = ProviderResponse{} - mi := &file_openshell_proto_msgTypes[103] + mi := &file_openshell_proto_msgTypes[102] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8908,7 +8819,7 @@ func (x *ProviderResponse) String() string { func (*ProviderResponse) ProtoMessage() {} func (x *ProviderResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[103] + mi := &file_openshell_proto_msgTypes[102] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8921,7 +8832,7 @@ func (x *ProviderResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ProviderResponse.ProtoReflect.Descriptor instead. func (*ProviderResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{103} + return file_openshell_proto_rawDescGZIP(), []int{102} } func (x *ProviderResponse) GetProvider() *datamodelv1.Provider { @@ -8957,7 +8868,7 @@ type ListProvidersResponse struct { func (x *ListProvidersResponse) Reset() { *x = ListProvidersResponse{} - mi := &file_openshell_proto_msgTypes[104] + mi := &file_openshell_proto_msgTypes[103] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8969,7 +8880,7 @@ func (x *ListProvidersResponse) String() string { func (*ListProvidersResponse) ProtoMessage() {} func (x *ListProvidersResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[104] + mi := &file_openshell_proto_msgTypes[103] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8982,7 +8893,7 @@ func (x *ListProvidersResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListProvidersResponse.ProtoReflect.Descriptor instead. func (*ListProvidersResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{104} + return file_openshell_proto_rawDescGZIP(), []int{103} } func (x *ListProvidersResponse) GetProviders() []*datamodelv1.Provider { @@ -9016,7 +8927,7 @@ type ListProviderProfilesRequest struct { func (x *ListProviderProfilesRequest) Reset() { *x = ListProviderProfilesRequest{} - mi := &file_openshell_proto_msgTypes[105] + mi := &file_openshell_proto_msgTypes[104] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9028,7 +8939,7 @@ func (x *ListProviderProfilesRequest) String() string { func (*ListProviderProfilesRequest) ProtoMessage() {} func (x *ListProviderProfilesRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[105] + mi := &file_openshell_proto_msgTypes[104] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9041,7 +8952,7 @@ func (x *ListProviderProfilesRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListProviderProfilesRequest.ProtoReflect.Descriptor instead. func (*ListProviderProfilesRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{105} + return file_openshell_proto_rawDescGZIP(), []int{104} } func (x *ListProviderProfilesRequest) GetWorkspaceScope() *datamodelv1.WorkspaceSelector { @@ -9077,7 +8988,7 @@ type GetProviderProfileRequest struct { func (x *GetProviderProfileRequest) Reset() { *x = GetProviderProfileRequest{} - mi := &file_openshell_proto_msgTypes[106] + mi := &file_openshell_proto_msgTypes[105] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9089,7 +9000,7 @@ func (x *GetProviderProfileRequest) String() string { func (*GetProviderProfileRequest) ProtoMessage() {} func (x *GetProviderProfileRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[106] + mi := &file_openshell_proto_msgTypes[105] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9102,7 +9013,7 @@ func (x *GetProviderProfileRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetProviderProfileRequest.ProtoReflect.Descriptor instead. func (*GetProviderProfileRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{106} + return file_openshell_proto_rawDescGZIP(), []int{105} } func (x *GetProviderProfileRequest) GetWorkspaceScope() *datamodelv1.WorkspaceSelector { @@ -9130,7 +9041,7 @@ type ProviderProfileImportItem struct { func (x *ProviderProfileImportItem) Reset() { *x = ProviderProfileImportItem{} - mi := &file_openshell_proto_msgTypes[107] + mi := &file_openshell_proto_msgTypes[106] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9142,7 +9053,7 @@ func (x *ProviderProfileImportItem) String() string { func (*ProviderProfileImportItem) ProtoMessage() {} func (x *ProviderProfileImportItem) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[107] + mi := &file_openshell_proto_msgTypes[106] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9155,7 +9066,7 @@ func (x *ProviderProfileImportItem) ProtoReflect() protoreflect.Message { // Deprecated: Use ProviderProfileImportItem.ProtoReflect.Descriptor instead. func (*ProviderProfileImportItem) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{107} + return file_openshell_proto_rawDescGZIP(), []int{106} } func (x *ProviderProfileImportItem) GetProfile() *ProviderProfile { @@ -9186,7 +9097,7 @@ type ProviderProfileDiagnostic struct { func (x *ProviderProfileDiagnostic) Reset() { *x = ProviderProfileDiagnostic{} - mi := &file_openshell_proto_msgTypes[108] + mi := &file_openshell_proto_msgTypes[107] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9198,7 +9109,7 @@ func (x *ProviderProfileDiagnostic) String() string { func (*ProviderProfileDiagnostic) ProtoMessage() {} func (x *ProviderProfileDiagnostic) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[108] + mi := &file_openshell_proto_msgTypes[107] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9211,7 +9122,7 @@ func (x *ProviderProfileDiagnostic) ProtoReflect() protoreflect.Message { // Deprecated: Use ProviderProfileDiagnostic.ProtoReflect.Descriptor instead. func (*ProviderProfileDiagnostic) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{108} + return file_openshell_proto_rawDescGZIP(), []int{107} } func (x *ProviderProfileDiagnostic) GetSource() string { @@ -9268,7 +9179,7 @@ type ProviderCredentialTokenGrantAudienceOverride struct { func (x *ProviderCredentialTokenGrantAudienceOverride) Reset() { *x = ProviderCredentialTokenGrantAudienceOverride{} - mi := &file_openshell_proto_msgTypes[109] + mi := &file_openshell_proto_msgTypes[108] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9280,7 +9191,7 @@ func (x *ProviderCredentialTokenGrantAudienceOverride) String() string { func (*ProviderCredentialTokenGrantAudienceOverride) ProtoMessage() {} func (x *ProviderCredentialTokenGrantAudienceOverride) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[109] + mi := &file_openshell_proto_msgTypes[108] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9293,7 +9204,7 @@ func (x *ProviderCredentialTokenGrantAudienceOverride) ProtoReflect() protorefle // Deprecated: Use ProviderCredentialTokenGrantAudienceOverride.ProtoReflect.Descriptor instead. func (*ProviderCredentialTokenGrantAudienceOverride) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{109} + return file_openshell_proto_rawDescGZIP(), []int{108} } func (x *ProviderCredentialTokenGrantAudienceOverride) GetHost() string { @@ -9347,7 +9258,7 @@ type ProviderCredentialTokenGrantSubjectToken struct { func (x *ProviderCredentialTokenGrantSubjectToken) Reset() { *x = ProviderCredentialTokenGrantSubjectToken{} - mi := &file_openshell_proto_msgTypes[110] + mi := &file_openshell_proto_msgTypes[109] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9359,7 +9270,7 @@ func (x *ProviderCredentialTokenGrantSubjectToken) String() string { func (*ProviderCredentialTokenGrantSubjectToken) ProtoMessage() {} func (x *ProviderCredentialTokenGrantSubjectToken) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[110] + mi := &file_openshell_proto_msgTypes[109] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9372,7 +9283,7 @@ func (x *ProviderCredentialTokenGrantSubjectToken) ProtoReflect() protoreflect.M // Deprecated: Use ProviderCredentialTokenGrantSubjectToken.ProtoReflect.Descriptor instead. func (*ProviderCredentialTokenGrantSubjectToken) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{110} + return file_openshell_proto_rawDescGZIP(), []int{109} } func (x *ProviderCredentialTokenGrantSubjectToken) GetSource() string { @@ -9428,7 +9339,7 @@ type ProviderCredentialTokenGrant struct { func (x *ProviderCredentialTokenGrant) Reset() { *x = ProviderCredentialTokenGrant{} - mi := &file_openshell_proto_msgTypes[111] + mi := &file_openshell_proto_msgTypes[110] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9440,7 +9351,7 @@ func (x *ProviderCredentialTokenGrant) String() string { func (*ProviderCredentialTokenGrant) ProtoMessage() {} func (x *ProviderCredentialTokenGrant) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[111] + mi := &file_openshell_proto_msgTypes[110] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9453,7 +9364,7 @@ func (x *ProviderCredentialTokenGrant) ProtoReflect() protoreflect.Message { // Deprecated: Use ProviderCredentialTokenGrant.ProtoReflect.Descriptor instead. func (*ProviderCredentialTokenGrant) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{111} + return file_openshell_proto_rawDescGZIP(), []int{110} } func (x *ProviderCredentialTokenGrant) GetTokenEndpoint() string { @@ -9557,7 +9468,7 @@ type ProviderProfileCredential struct { func (x *ProviderProfileCredential) Reset() { *x = ProviderProfileCredential{} - mi := &file_openshell_proto_msgTypes[112] + mi := &file_openshell_proto_msgTypes[111] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9569,7 +9480,7 @@ func (x *ProviderProfileCredential) String() string { func (*ProviderProfileCredential) ProtoMessage() {} func (x *ProviderProfileCredential) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[112] + mi := &file_openshell_proto_msgTypes[111] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9582,7 +9493,7 @@ func (x *ProviderProfileCredential) ProtoReflect() protoreflect.Message { // Deprecated: Use ProviderProfileCredential.ProtoReflect.Descriptor instead. func (*ProviderProfileCredential) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{112} + return file_openshell_proto_rawDescGZIP(), []int{111} } func (x *ProviderProfileCredential) GetName() string { @@ -9681,7 +9592,7 @@ type ProviderCredentialRefreshMaterial struct { func (x *ProviderCredentialRefreshMaterial) Reset() { *x = ProviderCredentialRefreshMaterial{} - mi := &file_openshell_proto_msgTypes[113] + mi := &file_openshell_proto_msgTypes[112] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9693,7 +9604,7 @@ func (x *ProviderCredentialRefreshMaterial) String() string { func (*ProviderCredentialRefreshMaterial) ProtoMessage() {} func (x *ProviderCredentialRefreshMaterial) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[113] + mi := &file_openshell_proto_msgTypes[112] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9706,7 +9617,7 @@ func (x *ProviderCredentialRefreshMaterial) ProtoReflect() protoreflect.Message // Deprecated: Use ProviderCredentialRefreshMaterial.ProtoReflect.Descriptor instead. func (*ProviderCredentialRefreshMaterial) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{113} + return file_openshell_proto_rawDescGZIP(), []int{112} } func (x *ProviderCredentialRefreshMaterial) GetName() string { @@ -9751,7 +9662,7 @@ type ProviderCredentialRefreshOutput struct { func (x *ProviderCredentialRefreshOutput) Reset() { *x = ProviderCredentialRefreshOutput{} - mi := &file_openshell_proto_msgTypes[114] + mi := &file_openshell_proto_msgTypes[113] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9763,7 +9674,7 @@ func (x *ProviderCredentialRefreshOutput) String() string { func (*ProviderCredentialRefreshOutput) ProtoMessage() {} func (x *ProviderCredentialRefreshOutput) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[114] + mi := &file_openshell_proto_msgTypes[113] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9776,7 +9687,7 @@ func (x *ProviderCredentialRefreshOutput) ProtoReflect() protoreflect.Message { // Deprecated: Use ProviderCredentialRefreshOutput.ProtoReflect.Descriptor instead. func (*ProviderCredentialRefreshOutput) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{114} + return file_openshell_proto_rawDescGZIP(), []int{113} } func (x *ProviderCredentialRefreshOutput) GetOutput() string { @@ -9808,7 +9719,7 @@ type ProviderCredentialRefresh struct { func (x *ProviderCredentialRefresh) Reset() { *x = ProviderCredentialRefresh{} - mi := &file_openshell_proto_msgTypes[115] + mi := &file_openshell_proto_msgTypes[114] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9820,7 +9731,7 @@ func (x *ProviderCredentialRefresh) String() string { func (*ProviderCredentialRefresh) ProtoMessage() {} func (x *ProviderCredentialRefresh) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[115] + mi := &file_openshell_proto_msgTypes[114] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9833,7 +9744,7 @@ func (x *ProviderCredentialRefresh) ProtoReflect() protoreflect.Message { // Deprecated: Use ProviderCredentialRefresh.ProtoReflect.Descriptor instead. func (*ProviderCredentialRefresh) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{115} + return file_openshell_proto_rawDescGZIP(), []int{114} } func (x *ProviderCredentialRefresh) GetStrategy() ProviderCredentialRefreshStrategy { @@ -9914,7 +9825,7 @@ type ProviderCredentialRefreshStatus struct { func (x *ProviderCredentialRefreshStatus) Reset() { *x = ProviderCredentialRefreshStatus{} - mi := &file_openshell_proto_msgTypes[116] + mi := &file_openshell_proto_msgTypes[115] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9926,7 +9837,7 @@ func (x *ProviderCredentialRefreshStatus) String() string { func (*ProviderCredentialRefreshStatus) ProtoMessage() {} func (x *ProviderCredentialRefreshStatus) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[116] + mi := &file_openshell_proto_msgTypes[115] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9939,7 +9850,7 @@ func (x *ProviderCredentialRefreshStatus) ProtoReflect() protoreflect.Message { // Deprecated: Use ProviderCredentialRefreshStatus.ProtoReflect.Descriptor instead. func (*ProviderCredentialRefreshStatus) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{116} + return file_openshell_proto_rawDescGZIP(), []int{115} } func (x *ProviderCredentialRefreshStatus) GetProvider() string { @@ -10044,7 +9955,7 @@ type ProviderProfileDiscovery struct { func (x *ProviderProfileDiscovery) Reset() { *x = ProviderProfileDiscovery{} - mi := &file_openshell_proto_msgTypes[117] + mi := &file_openshell_proto_msgTypes[116] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10056,7 +9967,7 @@ func (x *ProviderProfileDiscovery) String() string { func (*ProviderProfileDiscovery) ProtoMessage() {} func (x *ProviderProfileDiscovery) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[117] + mi := &file_openshell_proto_msgTypes[116] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10069,7 +9980,7 @@ func (x *ProviderProfileDiscovery) ProtoReflect() protoreflect.Message { // Deprecated: Use ProviderProfileDiscovery.ProtoReflect.Descriptor instead. func (*ProviderProfileDiscovery) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{117} + return file_openshell_proto_rawDescGZIP(), []int{116} } func (x *ProviderProfileDiscovery) GetCredentials() []string { @@ -10091,7 +10002,7 @@ type GetProviderRefreshStatusRequest struct { func (x *GetProviderRefreshStatusRequest) Reset() { *x = GetProviderRefreshStatusRequest{} - mi := &file_openshell_proto_msgTypes[118] + mi := &file_openshell_proto_msgTypes[117] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10103,7 +10014,7 @@ func (x *GetProviderRefreshStatusRequest) String() string { func (*GetProviderRefreshStatusRequest) ProtoMessage() {} func (x *GetProviderRefreshStatusRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[118] + mi := &file_openshell_proto_msgTypes[117] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10116,7 +10027,7 @@ func (x *GetProviderRefreshStatusRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetProviderRefreshStatusRequest.ProtoReflect.Descriptor instead. func (*GetProviderRefreshStatusRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{118} + return file_openshell_proto_rawDescGZIP(), []int{117} } func (x *GetProviderRefreshStatusRequest) GetWorkspaceScope() *datamodelv1.WorkspaceSelector { @@ -10149,7 +10060,7 @@ type GetProviderRefreshStatusResponse struct { func (x *GetProviderRefreshStatusResponse) Reset() { *x = GetProviderRefreshStatusResponse{} - mi := &file_openshell_proto_msgTypes[119] + mi := &file_openshell_proto_msgTypes[118] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10161,7 +10072,7 @@ func (x *GetProviderRefreshStatusResponse) String() string { func (*GetProviderRefreshStatusResponse) ProtoMessage() {} func (x *GetProviderRefreshStatusResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[119] + mi := &file_openshell_proto_msgTypes[118] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10174,7 +10085,7 @@ func (x *GetProviderRefreshStatusResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use GetProviderRefreshStatusResponse.ProtoReflect.Descriptor instead. func (*GetProviderRefreshStatusResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{119} + return file_openshell_proto_rawDescGZIP(), []int{118} } func (x *GetProviderRefreshStatusResponse) GetCredentials() []*ProviderCredentialRefreshStatus { @@ -10206,7 +10117,7 @@ type ConfigureProviderRefreshRequest struct { func (x *ConfigureProviderRefreshRequest) Reset() { *x = ConfigureProviderRefreshRequest{} - mi := &file_openshell_proto_msgTypes[120] + mi := &file_openshell_proto_msgTypes[119] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10218,7 +10129,7 @@ func (x *ConfigureProviderRefreshRequest) String() string { func (*ConfigureProviderRefreshRequest) ProtoMessage() {} func (x *ConfigureProviderRefreshRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[120] + mi := &file_openshell_proto_msgTypes[119] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10231,7 +10142,7 @@ func (x *ConfigureProviderRefreshRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ConfigureProviderRefreshRequest.ProtoReflect.Descriptor instead. func (*ConfigureProviderRefreshRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{120} + return file_openshell_proto_rawDescGZIP(), []int{119} } func (x *ConfigureProviderRefreshRequest) GetWorkspaceScope() *datamodelv1.WorkspaceSelector { @@ -10299,7 +10210,7 @@ type ConfigureProviderRefreshResponse struct { func (x *ConfigureProviderRefreshResponse) Reset() { *x = ConfigureProviderRefreshResponse{} - mi := &file_openshell_proto_msgTypes[121] + mi := &file_openshell_proto_msgTypes[120] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10311,7 +10222,7 @@ func (x *ConfigureProviderRefreshResponse) String() string { func (*ConfigureProviderRefreshResponse) ProtoMessage() {} func (x *ConfigureProviderRefreshResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[121] + mi := &file_openshell_proto_msgTypes[120] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10324,7 +10235,7 @@ func (x *ConfigureProviderRefreshResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ConfigureProviderRefreshResponse.ProtoReflect.Descriptor instead. func (*ConfigureProviderRefreshResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{121} + return file_openshell_proto_rawDescGZIP(), []int{120} } func (x *ConfigureProviderRefreshResponse) GetStatus() *ProviderCredentialRefreshStatus { @@ -10349,7 +10260,7 @@ type RotateProviderCredentialRequest struct { func (x *RotateProviderCredentialRequest) Reset() { *x = RotateProviderCredentialRequest{} - mi := &file_openshell_proto_msgTypes[122] + mi := &file_openshell_proto_msgTypes[121] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10361,7 +10272,7 @@ func (x *RotateProviderCredentialRequest) String() string { func (*RotateProviderCredentialRequest) ProtoMessage() {} func (x *RotateProviderCredentialRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[122] + mi := &file_openshell_proto_msgTypes[121] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10374,7 +10285,7 @@ func (x *RotateProviderCredentialRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use RotateProviderCredentialRequest.ProtoReflect.Descriptor instead. func (*RotateProviderCredentialRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{122} + return file_openshell_proto_rawDescGZIP(), []int{121} } func (x *RotateProviderCredentialRequest) GetWorkspaceScope() *datamodelv1.WorkspaceSelector { @@ -10414,7 +10325,7 @@ type RotateProviderCredentialResponse struct { func (x *RotateProviderCredentialResponse) Reset() { *x = RotateProviderCredentialResponse{} - mi := &file_openshell_proto_msgTypes[123] + mi := &file_openshell_proto_msgTypes[122] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10426,7 +10337,7 @@ func (x *RotateProviderCredentialResponse) String() string { func (*RotateProviderCredentialResponse) ProtoMessage() {} func (x *RotateProviderCredentialResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[123] + mi := &file_openshell_proto_msgTypes[122] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10439,7 +10350,7 @@ func (x *RotateProviderCredentialResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use RotateProviderCredentialResponse.ProtoReflect.Descriptor instead. func (*RotateProviderCredentialResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{123} + return file_openshell_proto_rawDescGZIP(), []int{122} } func (x *RotateProviderCredentialResponse) GetStatus() *ProviderCredentialRefreshStatus { @@ -10465,7 +10376,7 @@ type DeleteProviderRefreshRequest struct { func (x *DeleteProviderRefreshRequest) Reset() { *x = DeleteProviderRefreshRequest{} - mi := &file_openshell_proto_msgTypes[124] + mi := &file_openshell_proto_msgTypes[123] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10477,7 +10388,7 @@ func (x *DeleteProviderRefreshRequest) String() string { func (*DeleteProviderRefreshRequest) ProtoMessage() {} func (x *DeleteProviderRefreshRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[124] + mi := &file_openshell_proto_msgTypes[123] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10490,7 +10401,7 @@ func (x *DeleteProviderRefreshRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteProviderRefreshRequest.ProtoReflect.Descriptor instead. func (*DeleteProviderRefreshRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{124} + return file_openshell_proto_rawDescGZIP(), []int{123} } func (x *DeleteProviderRefreshRequest) GetWorkspaceScope() *datamodelv1.WorkspaceSelector { @@ -10537,7 +10448,7 @@ type DeleteProviderRefreshResponse struct { func (x *DeleteProviderRefreshResponse) Reset() { *x = DeleteProviderRefreshResponse{} - mi := &file_openshell_proto_msgTypes[125] + mi := &file_openshell_proto_msgTypes[124] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10549,7 +10460,7 @@ func (x *DeleteProviderRefreshResponse) String() string { func (*DeleteProviderRefreshResponse) ProtoMessage() {} func (x *DeleteProviderRefreshResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[125] + mi := &file_openshell_proto_msgTypes[124] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10562,7 +10473,7 @@ func (x *DeleteProviderRefreshResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteProviderRefreshResponse.ProtoReflect.Descriptor instead. func (*DeleteProviderRefreshResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{125} + return file_openshell_proto_rawDescGZIP(), []int{124} } func (x *DeleteProviderRefreshResponse) GetOutcome() DeletionOutcome { @@ -10605,7 +10516,7 @@ type ProviderProfile struct { func (x *ProviderProfile) Reset() { *x = ProviderProfile{} - mi := &file_openshell_proto_msgTypes[126] + mi := &file_openshell_proto_msgTypes[125] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10617,7 +10528,7 @@ func (x *ProviderProfile) String() string { func (*ProviderProfile) ProtoMessage() {} func (x *ProviderProfile) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[126] + mi := &file_openshell_proto_msgTypes[125] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10630,7 +10541,7 @@ func (x *ProviderProfile) ProtoReflect() protoreflect.Message { // Deprecated: Use ProviderProfile.ProtoReflect.Descriptor instead. func (*ProviderProfile) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{126} + return file_openshell_proto_rawDescGZIP(), []int{125} } func (x *ProviderProfile) GetId() string { @@ -10746,7 +10657,7 @@ type ProviderProfileFile struct { func (x *ProviderProfileFile) Reset() { *x = ProviderProfileFile{} - mi := &file_openshell_proto_msgTypes[127] + mi := &file_openshell_proto_msgTypes[126] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10758,7 +10669,7 @@ func (x *ProviderProfileFile) String() string { func (*ProviderProfileFile) ProtoMessage() {} func (x *ProviderProfileFile) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[127] + mi := &file_openshell_proto_msgTypes[126] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10771,7 +10682,7 @@ func (x *ProviderProfileFile) ProtoReflect() protoreflect.Message { // Deprecated: Use ProviderProfileFile.ProtoReflect.Descriptor instead. func (*ProviderProfileFile) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{127} + return file_openshell_proto_rawDescGZIP(), []int{126} } func (x *ProviderProfileFile) GetPath() string { @@ -10805,7 +10716,7 @@ type ProviderProfileResponse struct { func (x *ProviderProfileResponse) Reset() { *x = ProviderProfileResponse{} - mi := &file_openshell_proto_msgTypes[128] + mi := &file_openshell_proto_msgTypes[127] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10817,7 +10728,7 @@ func (x *ProviderProfileResponse) String() string { func (*ProviderProfileResponse) ProtoMessage() {} func (x *ProviderProfileResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[128] + mi := &file_openshell_proto_msgTypes[127] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10830,7 +10741,7 @@ func (x *ProviderProfileResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ProviderProfileResponse.ProtoReflect.Descriptor instead. func (*ProviderProfileResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{128} + return file_openshell_proto_rawDescGZIP(), []int{127} } func (x *ProviderProfileResponse) GetProfile() *ProviderProfile { @@ -10852,7 +10763,7 @@ type ListProviderProfilesResponse struct { func (x *ListProviderProfilesResponse) Reset() { *x = ListProviderProfilesResponse{} - mi := &file_openshell_proto_msgTypes[129] + mi := &file_openshell_proto_msgTypes[128] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10864,7 +10775,7 @@ func (x *ListProviderProfilesResponse) String() string { func (*ListProviderProfilesResponse) ProtoMessage() {} func (x *ListProviderProfilesResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[129] + mi := &file_openshell_proto_msgTypes[128] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10877,7 +10788,7 @@ func (x *ListProviderProfilesResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListProviderProfilesResponse.ProtoReflect.Descriptor instead. func (*ListProviderProfilesResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{129} + return file_openshell_proto_rawDescGZIP(), []int{128} } func (x *ListProviderProfilesResponse) GetProfiles() []*ProviderProfile { @@ -10909,7 +10820,7 @@ type ImportProviderProfilesRequest struct { func (x *ImportProviderProfilesRequest) Reset() { *x = ImportProviderProfilesRequest{} - mi := &file_openshell_proto_msgTypes[130] + mi := &file_openshell_proto_msgTypes[129] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10921,7 +10832,7 @@ func (x *ImportProviderProfilesRequest) String() string { func (*ImportProviderProfilesRequest) ProtoMessage() {} func (x *ImportProviderProfilesRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[130] + mi := &file_openshell_proto_msgTypes[129] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10934,7 +10845,7 @@ func (x *ImportProviderProfilesRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ImportProviderProfilesRequest.ProtoReflect.Descriptor instead. func (*ImportProviderProfilesRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{130} + return file_openshell_proto_rawDescGZIP(), []int{129} } func (x *ImportProviderProfilesRequest) GetWorkspaceScope() *datamodelv1.WorkspaceSelector { @@ -10970,7 +10881,7 @@ type ImportProviderProfilesResponse struct { func (x *ImportProviderProfilesResponse) Reset() { *x = ImportProviderProfilesResponse{} - mi := &file_openshell_proto_msgTypes[131] + mi := &file_openshell_proto_msgTypes[130] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10982,7 +10893,7 @@ func (x *ImportProviderProfilesResponse) String() string { func (*ImportProviderProfilesResponse) ProtoMessage() {} func (x *ImportProviderProfilesResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[131] + mi := &file_openshell_proto_msgTypes[130] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10995,7 +10906,7 @@ func (x *ImportProviderProfilesResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ImportProviderProfilesResponse.ProtoReflect.Descriptor instead. func (*ImportProviderProfilesResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{131} + return file_openshell_proto_rawDescGZIP(), []int{130} } func (x *ImportProviderProfilesResponse) GetDiagnostics() []*ProviderProfileDiagnostic { @@ -11041,7 +10952,7 @@ type UpdateProviderProfilesRequest struct { func (x *UpdateProviderProfilesRequest) Reset() { *x = UpdateProviderProfilesRequest{} - mi := &file_openshell_proto_msgTypes[132] + mi := &file_openshell_proto_msgTypes[131] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11053,7 +10964,7 @@ func (x *UpdateProviderProfilesRequest) String() string { func (*UpdateProviderProfilesRequest) ProtoMessage() {} func (x *UpdateProviderProfilesRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[132] + mi := &file_openshell_proto_msgTypes[131] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11066,7 +10977,7 @@ func (x *UpdateProviderProfilesRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use UpdateProviderProfilesRequest.ProtoReflect.Descriptor instead. func (*UpdateProviderProfilesRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{132} + return file_openshell_proto_rawDescGZIP(), []int{131} } func (x *UpdateProviderProfilesRequest) GetWorkspaceScope() *datamodelv1.WorkspaceSelector { @@ -11116,7 +11027,7 @@ type UpdateProviderProfilesResponse struct { func (x *UpdateProviderProfilesResponse) Reset() { *x = UpdateProviderProfilesResponse{} - mi := &file_openshell_proto_msgTypes[133] + mi := &file_openshell_proto_msgTypes[132] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11128,7 +11039,7 @@ func (x *UpdateProviderProfilesResponse) String() string { func (*UpdateProviderProfilesResponse) ProtoMessage() {} func (x *UpdateProviderProfilesResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[133] + mi := &file_openshell_proto_msgTypes[132] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11141,7 +11052,7 @@ func (x *UpdateProviderProfilesResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use UpdateProviderProfilesResponse.ProtoReflect.Descriptor instead. func (*UpdateProviderProfilesResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{133} + return file_openshell_proto_rawDescGZIP(), []int{132} } func (x *UpdateProviderProfilesResponse) GetDiagnostics() []*ProviderProfileDiagnostic { @@ -11177,7 +11088,7 @@ type LintProviderProfilesRequest struct { func (x *LintProviderProfilesRequest) Reset() { *x = LintProviderProfilesRequest{} - mi := &file_openshell_proto_msgTypes[134] + mi := &file_openshell_proto_msgTypes[133] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11189,7 +11100,7 @@ func (x *LintProviderProfilesRequest) String() string { func (*LintProviderProfilesRequest) ProtoMessage() {} func (x *LintProviderProfilesRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[134] + mi := &file_openshell_proto_msgTypes[133] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11202,7 +11113,7 @@ func (x *LintProviderProfilesRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use LintProviderProfilesRequest.ProtoReflect.Descriptor instead. func (*LintProviderProfilesRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{134} + return file_openshell_proto_rawDescGZIP(), []int{133} } func (x *LintProviderProfilesRequest) GetWorkspaceScope() *datamodelv1.WorkspaceSelector { @@ -11233,7 +11144,7 @@ type LintProviderProfilesResponse struct { func (x *LintProviderProfilesResponse) Reset() { *x = LintProviderProfilesResponse{} - mi := &file_openshell_proto_msgTypes[135] + mi := &file_openshell_proto_msgTypes[134] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11245,7 +11156,7 @@ func (x *LintProviderProfilesResponse) String() string { func (*LintProviderProfilesResponse) ProtoMessage() {} func (x *LintProviderProfilesResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[135] + mi := &file_openshell_proto_msgTypes[134] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11258,7 +11169,7 @@ func (x *LintProviderProfilesResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use LintProviderProfilesResponse.ProtoReflect.Descriptor instead. func (*LintProviderProfilesResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{135} + return file_openshell_proto_rawDescGZIP(), []int{134} } func (x *LintProviderProfilesResponse) GetDiagnostics() []*ProviderProfileDiagnostic { @@ -11292,7 +11203,7 @@ type DeleteProviderResponse struct { func (x *DeleteProviderResponse) Reset() { *x = DeleteProviderResponse{} - mi := &file_openshell_proto_msgTypes[136] + mi := &file_openshell_proto_msgTypes[135] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11304,7 +11215,7 @@ func (x *DeleteProviderResponse) String() string { func (*DeleteProviderResponse) ProtoMessage() {} func (x *DeleteProviderResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[136] + mi := &file_openshell_proto_msgTypes[135] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11317,7 +11228,7 @@ func (x *DeleteProviderResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteProviderResponse.ProtoReflect.Descriptor instead. func (*DeleteProviderResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{136} + return file_openshell_proto_rawDescGZIP(), []int{135} } func (x *DeleteProviderResponse) GetOutcome() DeletionOutcome { @@ -11343,7 +11254,7 @@ type DeleteProviderProfileRequest struct { func (x *DeleteProviderProfileRequest) Reset() { *x = DeleteProviderProfileRequest{} - mi := &file_openshell_proto_msgTypes[137] + mi := &file_openshell_proto_msgTypes[136] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11355,7 +11266,7 @@ func (x *DeleteProviderProfileRequest) String() string { func (*DeleteProviderProfileRequest) ProtoMessage() {} func (x *DeleteProviderProfileRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[137] + mi := &file_openshell_proto_msgTypes[136] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11368,7 +11279,7 @@ func (x *DeleteProviderProfileRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteProviderProfileRequest.ProtoReflect.Descriptor instead. func (*DeleteProviderProfileRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{137} + return file_openshell_proto_rawDescGZIP(), []int{136} } func (x *DeleteProviderProfileRequest) GetWorkspaceScope() *datamodelv1.WorkspaceSelector { @@ -11409,7 +11320,7 @@ type DeleteProviderProfileResponse struct { func (x *DeleteProviderProfileResponse) Reset() { *x = DeleteProviderProfileResponse{} - mi := &file_openshell_proto_msgTypes[138] + mi := &file_openshell_proto_msgTypes[137] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11421,7 +11332,7 @@ func (x *DeleteProviderProfileResponse) String() string { func (*DeleteProviderProfileResponse) ProtoMessage() {} func (x *DeleteProviderProfileResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[138] + mi := &file_openshell_proto_msgTypes[137] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11434,7 +11345,7 @@ func (x *DeleteProviderProfileResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteProviderProfileResponse.ProtoReflect.Descriptor instead. func (*DeleteProviderProfileResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{138} + return file_openshell_proto_rawDescGZIP(), []int{137} } func (x *DeleteProviderProfileResponse) GetOutcome() DeletionOutcome { @@ -11463,7 +11374,7 @@ type GetSandboxProviderEnvironmentRequest struct { func (x *GetSandboxProviderEnvironmentRequest) Reset() { *x = GetSandboxProviderEnvironmentRequest{} - mi := &file_openshell_proto_msgTypes[139] + mi := &file_openshell_proto_msgTypes[138] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11475,7 +11386,7 @@ func (x *GetSandboxProviderEnvironmentRequest) String() string { func (*GetSandboxProviderEnvironmentRequest) ProtoMessage() {} func (x *GetSandboxProviderEnvironmentRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[139] + mi := &file_openshell_proto_msgTypes[138] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11488,7 +11399,7 @@ func (x *GetSandboxProviderEnvironmentRequest) ProtoReflect() protoreflect.Messa // Deprecated: Use GetSandboxProviderEnvironmentRequest.ProtoReflect.Descriptor instead. func (*GetSandboxProviderEnvironmentRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{139} + return file_openshell_proto_rawDescGZIP(), []int{138} } func (x *GetSandboxProviderEnvironmentRequest) GetSandboxId() string { @@ -11524,7 +11435,7 @@ type StaticCredentialEndpointBinding struct { func (x *StaticCredentialEndpointBinding) Reset() { *x = StaticCredentialEndpointBinding{} - mi := &file_openshell_proto_msgTypes[140] + mi := &file_openshell_proto_msgTypes[139] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11536,7 +11447,7 @@ func (x *StaticCredentialEndpointBinding) String() string { func (*StaticCredentialEndpointBinding) ProtoMessage() {} func (x *StaticCredentialEndpointBinding) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[140] + mi := &file_openshell_proto_msgTypes[139] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11549,7 +11460,7 @@ func (x *StaticCredentialEndpointBinding) ProtoReflect() protoreflect.Message { // Deprecated: Use StaticCredentialEndpointBinding.ProtoReflect.Descriptor instead. func (*StaticCredentialEndpointBinding) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{140} + return file_openshell_proto_rawDescGZIP(), []int{139} } func (x *StaticCredentialEndpointBinding) GetHost() string { @@ -11593,7 +11504,7 @@ type StaticCredentialBinding struct { func (x *StaticCredentialBinding) Reset() { *x = StaticCredentialBinding{} - mi := &file_openshell_proto_msgTypes[141] + mi := &file_openshell_proto_msgTypes[140] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11605,7 +11516,7 @@ func (x *StaticCredentialBinding) String() string { func (*StaticCredentialBinding) ProtoMessage() {} func (x *StaticCredentialBinding) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[141] + mi := &file_openshell_proto_msgTypes[140] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11618,7 +11529,7 @@ func (x *StaticCredentialBinding) ProtoReflect() protoreflect.Message { // Deprecated: Use StaticCredentialBinding.ProtoReflect.Descriptor instead. func (*StaticCredentialBinding) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{141} + return file_openshell_proto_rawDescGZIP(), []int{140} } func (x *StaticCredentialBinding) GetEndpoints() []*StaticCredentialEndpointBinding { @@ -11686,7 +11597,7 @@ type GetSandboxProviderEnvironmentResponse struct { func (x *GetSandboxProviderEnvironmentResponse) Reset() { *x = GetSandboxProviderEnvironmentResponse{} - mi := &file_openshell_proto_msgTypes[142] + mi := &file_openshell_proto_msgTypes[141] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11698,7 +11609,7 @@ func (x *GetSandboxProviderEnvironmentResponse) String() string { func (*GetSandboxProviderEnvironmentResponse) ProtoMessage() {} func (x *GetSandboxProviderEnvironmentResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[142] + mi := &file_openshell_proto_msgTypes[141] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11711,7 +11622,7 @@ func (x *GetSandboxProviderEnvironmentResponse) ProtoReflect() protoreflect.Mess // Deprecated: Use GetSandboxProviderEnvironmentResponse.ProtoReflect.Descriptor instead. func (*GetSandboxProviderEnvironmentResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{142} + return file_openshell_proto_rawDescGZIP(), []int{141} } func (x *GetSandboxProviderEnvironmentResponse) GetEnvironment() map[string]string { @@ -11815,7 +11726,7 @@ type ExchangeProviderSubjectTokenRequest struct { func (x *ExchangeProviderSubjectTokenRequest) Reset() { *x = ExchangeProviderSubjectTokenRequest{} - mi := &file_openshell_proto_msgTypes[143] + mi := &file_openshell_proto_msgTypes[142] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11827,7 +11738,7 @@ func (x *ExchangeProviderSubjectTokenRequest) String() string { func (*ExchangeProviderSubjectTokenRequest) ProtoMessage() {} func (x *ExchangeProviderSubjectTokenRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[143] + mi := &file_openshell_proto_msgTypes[142] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11840,7 +11751,7 @@ func (x *ExchangeProviderSubjectTokenRequest) ProtoReflect() protoreflect.Messag // Deprecated: Use ExchangeProviderSubjectTokenRequest.ProtoReflect.Descriptor instead. func (*ExchangeProviderSubjectTokenRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{143} + return file_openshell_proto_rawDescGZIP(), []int{142} } func (x *ExchangeProviderSubjectTokenRequest) GetSandboxId() string { @@ -11882,7 +11793,7 @@ type ExchangeProviderSubjectTokenResponse struct { func (x *ExchangeProviderSubjectTokenResponse) Reset() { *x = ExchangeProviderSubjectTokenResponse{} - mi := &file_openshell_proto_msgTypes[144] + mi := &file_openshell_proto_msgTypes[143] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11894,7 +11805,7 @@ func (x *ExchangeProviderSubjectTokenResponse) String() string { func (*ExchangeProviderSubjectTokenResponse) ProtoMessage() {} func (x *ExchangeProviderSubjectTokenResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[144] + mi := &file_openshell_proto_msgTypes[143] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11907,7 +11818,7 @@ func (x *ExchangeProviderSubjectTokenResponse) ProtoReflect() protoreflect.Messa // Deprecated: Use ExchangeProviderSubjectTokenResponse.ProtoReflect.Descriptor instead. func (*ExchangeProviderSubjectTokenResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{144} + return file_openshell_proto_rawDescGZIP(), []int{143} } func (x *ExchangeProviderSubjectTokenResponse) GetAccessToken() string { @@ -11980,7 +11891,7 @@ type UpdateConfigRequest struct { func (x *UpdateConfigRequest) Reset() { *x = UpdateConfigRequest{} - mi := &file_openshell_proto_msgTypes[145] + mi := &file_openshell_proto_msgTypes[144] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11992,7 +11903,7 @@ func (x *UpdateConfigRequest) String() string { func (*UpdateConfigRequest) ProtoMessage() {} func (x *UpdateConfigRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[145] + mi := &file_openshell_proto_msgTypes[144] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12005,7 +11916,7 @@ func (x *UpdateConfigRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use UpdateConfigRequest.ProtoReflect.Descriptor instead. func (*UpdateConfigRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{145} + return file_openshell_proto_rawDescGZIP(), []int{144} } func (x *UpdateConfigRequest) GetWorkspaceScope() *datamodelv1.WorkspaceSelector { @@ -12102,7 +12013,7 @@ type PolicyMergeOperation struct { func (x *PolicyMergeOperation) Reset() { *x = PolicyMergeOperation{} - mi := &file_openshell_proto_msgTypes[146] + mi := &file_openshell_proto_msgTypes[145] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12114,7 +12025,7 @@ func (x *PolicyMergeOperation) String() string { func (*PolicyMergeOperation) ProtoMessage() {} func (x *PolicyMergeOperation) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[146] + mi := &file_openshell_proto_msgTypes[145] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12127,7 +12038,7 @@ func (x *PolicyMergeOperation) ProtoReflect() protoreflect.Message { // Deprecated: Use PolicyMergeOperation.ProtoReflect.Descriptor instead. func (*PolicyMergeOperation) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{146} + return file_openshell_proto_rawDescGZIP(), []int{145} } func (x *PolicyMergeOperation) GetOperation() isPolicyMergeOperation_Operation { @@ -12241,7 +12152,7 @@ type AddNetworkRule struct { func (x *AddNetworkRule) Reset() { *x = AddNetworkRule{} - mi := &file_openshell_proto_msgTypes[147] + mi := &file_openshell_proto_msgTypes[146] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12253,7 +12164,7 @@ func (x *AddNetworkRule) String() string { func (*AddNetworkRule) ProtoMessage() {} func (x *AddNetworkRule) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[147] + mi := &file_openshell_proto_msgTypes[146] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12266,7 +12177,7 @@ func (x *AddNetworkRule) ProtoReflect() protoreflect.Message { // Deprecated: Use AddNetworkRule.ProtoReflect.Descriptor instead. func (*AddNetworkRule) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{147} + return file_openshell_proto_rawDescGZIP(), []int{146} } func (x *AddNetworkRule) GetRuleName() string { @@ -12294,7 +12205,7 @@ type RemoveNetworkEndpoint struct { func (x *RemoveNetworkEndpoint) Reset() { *x = RemoveNetworkEndpoint{} - mi := &file_openshell_proto_msgTypes[148] + mi := &file_openshell_proto_msgTypes[147] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12306,7 +12217,7 @@ func (x *RemoveNetworkEndpoint) String() string { func (*RemoveNetworkEndpoint) ProtoMessage() {} func (x *RemoveNetworkEndpoint) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[148] + mi := &file_openshell_proto_msgTypes[147] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12319,7 +12230,7 @@ func (x *RemoveNetworkEndpoint) ProtoReflect() protoreflect.Message { // Deprecated: Use RemoveNetworkEndpoint.ProtoReflect.Descriptor instead. func (*RemoveNetworkEndpoint) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{148} + return file_openshell_proto_rawDescGZIP(), []int{147} } func (x *RemoveNetworkEndpoint) GetRuleName() string { @@ -12352,7 +12263,7 @@ type RemoveNetworkRule struct { func (x *RemoveNetworkRule) Reset() { *x = RemoveNetworkRule{} - mi := &file_openshell_proto_msgTypes[149] + mi := &file_openshell_proto_msgTypes[148] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12364,7 +12275,7 @@ func (x *RemoveNetworkRule) String() string { func (*RemoveNetworkRule) ProtoMessage() {} func (x *RemoveNetworkRule) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[149] + mi := &file_openshell_proto_msgTypes[148] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12377,7 +12288,7 @@ func (x *RemoveNetworkRule) ProtoReflect() protoreflect.Message { // Deprecated: Use RemoveNetworkRule.ProtoReflect.Descriptor instead. func (*RemoveNetworkRule) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{149} + return file_openshell_proto_rawDescGZIP(), []int{148} } func (x *RemoveNetworkRule) GetRuleName() string { @@ -12406,7 +12317,7 @@ type L7RuleTarget struct { func (x *L7RuleTarget) Reset() { *x = L7RuleTarget{} - mi := &file_openshell_proto_msgTypes[150] + mi := &file_openshell_proto_msgTypes[149] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12418,7 +12329,7 @@ func (x *L7RuleTarget) String() string { func (*L7RuleTarget) ProtoMessage() {} func (x *L7RuleTarget) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[150] + mi := &file_openshell_proto_msgTypes[149] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12431,7 +12342,7 @@ func (x *L7RuleTarget) ProtoReflect() protoreflect.Message { // Deprecated: Use L7RuleTarget.ProtoReflect.Descriptor instead. func (*L7RuleTarget) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{150} + return file_openshell_proto_rawDescGZIP(), []int{149} } func (x *L7RuleTarget) GetRuleName() string { @@ -12486,7 +12397,7 @@ type AddDenyRules struct { func (x *AddDenyRules) Reset() { *x = AddDenyRules{} - mi := &file_openshell_proto_msgTypes[151] + mi := &file_openshell_proto_msgTypes[150] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12498,7 +12409,7 @@ func (x *AddDenyRules) String() string { func (*AddDenyRules) ProtoMessage() {} func (x *AddDenyRules) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[151] + mi := &file_openshell_proto_msgTypes[150] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12511,7 +12422,7 @@ func (x *AddDenyRules) ProtoReflect() protoreflect.Message { // Deprecated: Use AddDenyRules.ProtoReflect.Descriptor instead. func (*AddDenyRules) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{151} + return file_openshell_proto_rawDescGZIP(), []int{150} } func (x *AddDenyRules) GetDenyRules() []*sandboxv1.L7DenyRule { @@ -12538,7 +12449,7 @@ type AddAllowRules struct { func (x *AddAllowRules) Reset() { *x = AddAllowRules{} - mi := &file_openshell_proto_msgTypes[152] + mi := &file_openshell_proto_msgTypes[151] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12550,7 +12461,7 @@ func (x *AddAllowRules) String() string { func (*AddAllowRules) ProtoMessage() {} func (x *AddAllowRules) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[152] + mi := &file_openshell_proto_msgTypes[151] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12563,7 +12474,7 @@ func (x *AddAllowRules) ProtoReflect() protoreflect.Message { // Deprecated: Use AddAllowRules.ProtoReflect.Descriptor instead. func (*AddAllowRules) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{152} + return file_openshell_proto_rawDescGZIP(), []int{151} } func (x *AddAllowRules) GetRules() []*sandboxv1.L7Rule { @@ -12590,7 +12501,7 @@ type RemoveNetworkBinary struct { func (x *RemoveNetworkBinary) Reset() { *x = RemoveNetworkBinary{} - mi := &file_openshell_proto_msgTypes[153] + mi := &file_openshell_proto_msgTypes[152] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12602,7 +12513,7 @@ func (x *RemoveNetworkBinary) String() string { func (*RemoveNetworkBinary) ProtoMessage() {} func (x *RemoveNetworkBinary) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[153] + mi := &file_openshell_proto_msgTypes[152] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12615,7 +12526,7 @@ func (x *RemoveNetworkBinary) ProtoReflect() protoreflect.Message { // Deprecated: Use RemoveNetworkBinary.ProtoReflect.Descriptor instead. func (*RemoveNetworkBinary) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{153} + return file_openshell_proto_rawDescGZIP(), []int{152} } func (x *RemoveNetworkBinary) GetRuleName() string { @@ -12651,7 +12562,7 @@ type UpdateConfigResponse struct { func (x *UpdateConfigResponse) Reset() { *x = UpdateConfigResponse{} - mi := &file_openshell_proto_msgTypes[154] + mi := &file_openshell_proto_msgTypes[153] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12663,7 +12574,7 @@ func (x *UpdateConfigResponse) String() string { func (*UpdateConfigResponse) ProtoMessage() {} func (x *UpdateConfigResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[154] + mi := &file_openshell_proto_msgTypes[153] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12676,7 +12587,7 @@ func (x *UpdateConfigResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use UpdateConfigResponse.ProtoReflect.Descriptor instead. func (*UpdateConfigResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{154} + return file_openshell_proto_rawDescGZIP(), []int{153} } func (x *UpdateConfigResponse) GetVersion() uint32 { @@ -12730,7 +12641,7 @@ type GetSandboxPolicyStatusRequest struct { func (x *GetSandboxPolicyStatusRequest) Reset() { *x = GetSandboxPolicyStatusRequest{} - mi := &file_openshell_proto_msgTypes[155] + mi := &file_openshell_proto_msgTypes[154] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12742,7 +12653,7 @@ func (x *GetSandboxPolicyStatusRequest) String() string { func (*GetSandboxPolicyStatusRequest) ProtoMessage() {} func (x *GetSandboxPolicyStatusRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[155] + mi := &file_openshell_proto_msgTypes[154] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12755,7 +12666,7 @@ func (x *GetSandboxPolicyStatusRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetSandboxPolicyStatusRequest.ProtoReflect.Descriptor instead. func (*GetSandboxPolicyStatusRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{155} + return file_openshell_proto_rawDescGZIP(), []int{154} } func (x *GetSandboxPolicyStatusRequest) GetWorkspaceScope() *datamodelv1.WorkspaceSelector { @@ -12799,7 +12710,7 @@ type GetSandboxPolicyStatusResponse struct { func (x *GetSandboxPolicyStatusResponse) Reset() { *x = GetSandboxPolicyStatusResponse{} - mi := &file_openshell_proto_msgTypes[156] + mi := &file_openshell_proto_msgTypes[155] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12811,7 +12722,7 @@ func (x *GetSandboxPolicyStatusResponse) String() string { func (*GetSandboxPolicyStatusResponse) ProtoMessage() {} func (x *GetSandboxPolicyStatusResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[156] + mi := &file_openshell_proto_msgTypes[155] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12824,7 +12735,7 @@ func (x *GetSandboxPolicyStatusResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use GetSandboxPolicyStatusResponse.ProtoReflect.Descriptor instead. func (*GetSandboxPolicyStatusResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{156} + return file_openshell_proto_rawDescGZIP(), []int{155} } func (x *GetSandboxPolicyStatusResponse) GetRevision() *SandboxPolicyRevision { @@ -12861,7 +12772,7 @@ type ListSandboxPoliciesRequest struct { func (x *ListSandboxPoliciesRequest) Reset() { *x = ListSandboxPoliciesRequest{} - mi := &file_openshell_proto_msgTypes[157] + mi := &file_openshell_proto_msgTypes[156] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12873,7 +12784,7 @@ func (x *ListSandboxPoliciesRequest) String() string { func (*ListSandboxPoliciesRequest) ProtoMessage() {} func (x *ListSandboxPoliciesRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[157] + mi := &file_openshell_proto_msgTypes[156] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12886,7 +12797,7 @@ func (x *ListSandboxPoliciesRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListSandboxPoliciesRequest.ProtoReflect.Descriptor instead. func (*ListSandboxPoliciesRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{157} + return file_openshell_proto_rawDescGZIP(), []int{156} } func (x *ListSandboxPoliciesRequest) GetWorkspaceScope() *datamodelv1.WorkspaceSelector { @@ -12938,7 +12849,7 @@ type ListSandboxPoliciesResponse struct { func (x *ListSandboxPoliciesResponse) Reset() { *x = ListSandboxPoliciesResponse{} - mi := &file_openshell_proto_msgTypes[158] + mi := &file_openshell_proto_msgTypes[157] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12950,7 +12861,7 @@ func (x *ListSandboxPoliciesResponse) String() string { func (*ListSandboxPoliciesResponse) ProtoMessage() {} func (x *ListSandboxPoliciesResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[158] + mi := &file_openshell_proto_msgTypes[157] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12963,7 +12874,7 @@ func (x *ListSandboxPoliciesResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListSandboxPoliciesResponse.ProtoReflect.Descriptor instead. func (*ListSandboxPoliciesResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{158} + return file_openshell_proto_rawDescGZIP(), []int{157} } func (x *ListSandboxPoliciesResponse) GetRevisions() []*SandboxPolicyRevision { @@ -12997,7 +12908,7 @@ type ReportPolicyStatusRequest struct { func (x *ReportPolicyStatusRequest) Reset() { *x = ReportPolicyStatusRequest{} - mi := &file_openshell_proto_msgTypes[159] + mi := &file_openshell_proto_msgTypes[158] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13009,7 +12920,7 @@ func (x *ReportPolicyStatusRequest) String() string { func (*ReportPolicyStatusRequest) ProtoMessage() {} func (x *ReportPolicyStatusRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[159] + mi := &file_openshell_proto_msgTypes[158] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13022,7 +12933,7 @@ func (x *ReportPolicyStatusRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ReportPolicyStatusRequest.ProtoReflect.Descriptor instead. func (*ReportPolicyStatusRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{159} + return file_openshell_proto_rawDescGZIP(), []int{158} } func (x *ReportPolicyStatusRequest) GetSandboxId() string { @@ -13062,7 +12973,7 @@ type ReportPolicyStatusResponse struct { func (x *ReportPolicyStatusResponse) Reset() { *x = ReportPolicyStatusResponse{} - mi := &file_openshell_proto_msgTypes[160] + mi := &file_openshell_proto_msgTypes[159] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13074,7 +12985,7 @@ func (x *ReportPolicyStatusResponse) String() string { func (*ReportPolicyStatusResponse) ProtoMessage() {} func (x *ReportPolicyStatusResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[160] + mi := &file_openshell_proto_msgTypes[159] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13087,7 +12998,7 @@ func (x *ReportPolicyStatusResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ReportPolicyStatusResponse.ProtoReflect.Descriptor instead. func (*ReportPolicyStatusResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{160} + return file_openshell_proto_rawDescGZIP(), []int{159} } type SandboxConfigurationAdmission struct { @@ -13105,7 +13016,7 @@ type SandboxConfigurationAdmission struct { func (x *SandboxConfigurationAdmission) Reset() { *x = SandboxConfigurationAdmission{} - mi := &file_openshell_proto_msgTypes[161] + mi := &file_openshell_proto_msgTypes[160] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13117,7 +13028,7 @@ func (x *SandboxConfigurationAdmission) String() string { func (*SandboxConfigurationAdmission) ProtoMessage() {} func (x *SandboxConfigurationAdmission) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[161] + mi := &file_openshell_proto_msgTypes[160] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13130,7 +13041,7 @@ func (x *SandboxConfigurationAdmission) ProtoReflect() protoreflect.Message { // Deprecated: Use SandboxConfigurationAdmission.ProtoReflect.Descriptor instead. func (*SandboxConfigurationAdmission) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{161} + return file_openshell_proto_rawDescGZIP(), []int{160} } func (x *SandboxConfigurationAdmission) GetInstanceId() string { @@ -13194,7 +13105,7 @@ type ReportSandboxConfigurationRequest struct { func (x *ReportSandboxConfigurationRequest) Reset() { *x = ReportSandboxConfigurationRequest{} - mi := &file_openshell_proto_msgTypes[162] + mi := &file_openshell_proto_msgTypes[161] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13206,7 +13117,7 @@ func (x *ReportSandboxConfigurationRequest) String() string { func (*ReportSandboxConfigurationRequest) ProtoMessage() {} func (x *ReportSandboxConfigurationRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[162] + mi := &file_openshell_proto_msgTypes[161] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13219,7 +13130,7 @@ func (x *ReportSandboxConfigurationRequest) ProtoReflect() protoreflect.Message // Deprecated: Use ReportSandboxConfigurationRequest.ProtoReflect.Descriptor instead. func (*ReportSandboxConfigurationRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{162} + return file_openshell_proto_rawDescGZIP(), []int{161} } func (x *ReportSandboxConfigurationRequest) GetSandboxId() string { @@ -13251,7 +13162,7 @@ type ReportSandboxConfigurationResponse struct { func (x *ReportSandboxConfigurationResponse) Reset() { *x = ReportSandboxConfigurationResponse{} - mi := &file_openshell_proto_msgTypes[163] + mi := &file_openshell_proto_msgTypes[162] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13263,7 +13174,7 @@ func (x *ReportSandboxConfigurationResponse) String() string { func (*ReportSandboxConfigurationResponse) ProtoMessage() {} func (x *ReportSandboxConfigurationResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[163] + mi := &file_openshell_proto_msgTypes[162] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13276,7 +13187,7 @@ func (x *ReportSandboxConfigurationResponse) ProtoReflect() protoreflect.Message // Deprecated: Use ReportSandboxConfigurationResponse.ProtoReflect.Descriptor instead. func (*ReportSandboxConfigurationResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{163} + return file_openshell_proto_rawDescGZIP(), []int{162} } // A versioned policy revision with metadata. @@ -13309,7 +13220,7 @@ type SandboxPolicyRevision struct { func (x *SandboxPolicyRevision) Reset() { *x = SandboxPolicyRevision{} - mi := &file_openshell_proto_msgTypes[164] + mi := &file_openshell_proto_msgTypes[163] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13321,7 +13232,7 @@ func (x *SandboxPolicyRevision) String() string { func (*SandboxPolicyRevision) ProtoMessage() {} func (x *SandboxPolicyRevision) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[164] + mi := &file_openshell_proto_msgTypes[163] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13334,7 +13245,7 @@ func (x *SandboxPolicyRevision) ProtoReflect() protoreflect.Message { // Deprecated: Use SandboxPolicyRevision.ProtoReflect.Descriptor instead. func (*SandboxPolicyRevision) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{164} + return file_openshell_proto_rawDescGZIP(), []int{163} } func (x *SandboxPolicyRevision) GetVersion() uint32 { @@ -13414,7 +13325,7 @@ type GetSandboxLogsRequest struct { func (x *GetSandboxLogsRequest) Reset() { *x = GetSandboxLogsRequest{} - mi := &file_openshell_proto_msgTypes[165] + mi := &file_openshell_proto_msgTypes[164] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13426,7 +13337,7 @@ func (x *GetSandboxLogsRequest) String() string { func (*GetSandboxLogsRequest) ProtoMessage() {} func (x *GetSandboxLogsRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[165] + mi := &file_openshell_proto_msgTypes[164] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13439,7 +13350,7 @@ func (x *GetSandboxLogsRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetSandboxLogsRequest.ProtoReflect.Descriptor instead. func (*GetSandboxLogsRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{165} + return file_openshell_proto_rawDescGZIP(), []int{164} } func (x *GetSandboxLogsRequest) GetWorkspaceScope() *datamodelv1.WorkspaceSelector { @@ -13497,7 +13408,7 @@ type PushSandboxLogsRequest struct { func (x *PushSandboxLogsRequest) Reset() { *x = PushSandboxLogsRequest{} - mi := &file_openshell_proto_msgTypes[166] + mi := &file_openshell_proto_msgTypes[165] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13509,7 +13420,7 @@ func (x *PushSandboxLogsRequest) String() string { func (*PushSandboxLogsRequest) ProtoMessage() {} func (x *PushSandboxLogsRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[166] + mi := &file_openshell_proto_msgTypes[165] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13522,7 +13433,7 @@ func (x *PushSandboxLogsRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use PushSandboxLogsRequest.ProtoReflect.Descriptor instead. func (*PushSandboxLogsRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{166} + return file_openshell_proto_rawDescGZIP(), []int{165} } func (x *PushSandboxLogsRequest) GetSandboxId() string { @@ -13548,7 +13459,7 @@ type PushSandboxLogsResponse struct { func (x *PushSandboxLogsResponse) Reset() { *x = PushSandboxLogsResponse{} - mi := &file_openshell_proto_msgTypes[167] + mi := &file_openshell_proto_msgTypes[166] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13560,7 +13471,7 @@ func (x *PushSandboxLogsResponse) String() string { func (*PushSandboxLogsResponse) ProtoMessage() {} func (x *PushSandboxLogsResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[167] + mi := &file_openshell_proto_msgTypes[166] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13573,7 +13484,7 @@ func (x *PushSandboxLogsResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use PushSandboxLogsResponse.ProtoReflect.Descriptor instead. func (*PushSandboxLogsResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{167} + return file_openshell_proto_rawDescGZIP(), []int{166} } // Get sandbox logs response. @@ -13589,7 +13500,7 @@ type GetSandboxLogsResponse struct { func (x *GetSandboxLogsResponse) Reset() { *x = GetSandboxLogsResponse{} - mi := &file_openshell_proto_msgTypes[168] + mi := &file_openshell_proto_msgTypes[167] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13601,7 +13512,7 @@ func (x *GetSandboxLogsResponse) String() string { func (*GetSandboxLogsResponse) ProtoMessage() {} func (x *GetSandboxLogsResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[168] + mi := &file_openshell_proto_msgTypes[167] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13614,7 +13525,7 @@ func (x *GetSandboxLogsResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use GetSandboxLogsResponse.ProtoReflect.Descriptor instead. func (*GetSandboxLogsResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{168} + return file_openshell_proto_rawDescGZIP(), []int{167} } func (x *GetSandboxLogsResponse) GetLogs() []*SandboxLogLine { @@ -13647,7 +13558,7 @@ type SupervisorMessage struct { func (x *SupervisorMessage) Reset() { *x = SupervisorMessage{} - mi := &file_openshell_proto_msgTypes[169] + mi := &file_openshell_proto_msgTypes[168] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13659,7 +13570,7 @@ func (x *SupervisorMessage) String() string { func (*SupervisorMessage) ProtoMessage() {} func (x *SupervisorMessage) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[169] + mi := &file_openshell_proto_msgTypes[168] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13672,7 +13583,7 @@ func (x *SupervisorMessage) ProtoReflect() protoreflect.Message { // Deprecated: Use SupervisorMessage.ProtoReflect.Descriptor instead. func (*SupervisorMessage) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{169} + return file_openshell_proto_rawDescGZIP(), []int{168} } func (x *SupervisorMessage) GetPayload() isSupervisorMessage_Payload { @@ -13764,7 +13675,7 @@ type GatewayMessage struct { func (x *GatewayMessage) Reset() { *x = GatewayMessage{} - mi := &file_openshell_proto_msgTypes[170] + mi := &file_openshell_proto_msgTypes[169] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13776,7 +13687,7 @@ func (x *GatewayMessage) String() string { func (*GatewayMessage) ProtoMessage() {} func (x *GatewayMessage) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[170] + mi := &file_openshell_proto_msgTypes[169] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13789,7 +13700,7 @@ func (x *GatewayMessage) ProtoReflect() protoreflect.Message { // Deprecated: Use GatewayMessage.ProtoReflect.Descriptor instead. func (*GatewayMessage) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{170} + return file_openshell_proto_rawDescGZIP(), []int{169} } func (x *GatewayMessage) GetPayload() isGatewayMessage_Payload { @@ -13919,7 +13830,7 @@ type SupervisorHello struct { func (x *SupervisorHello) Reset() { *x = SupervisorHello{} - mi := &file_openshell_proto_msgTypes[171] + mi := &file_openshell_proto_msgTypes[170] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13931,7 +13842,7 @@ func (x *SupervisorHello) String() string { func (*SupervisorHello) ProtoMessage() {} func (x *SupervisorHello) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[171] + mi := &file_openshell_proto_msgTypes[170] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13944,7 +13855,7 @@ func (x *SupervisorHello) ProtoReflect() protoreflect.Message { // Deprecated: Use SupervisorHello.ProtoReflect.Descriptor instead. func (*SupervisorHello) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{171} + return file_openshell_proto_rawDescGZIP(), []int{170} } func (x *SupervisorHello) GetSandboxId() string { @@ -14002,7 +13913,7 @@ type SessionAccepted struct { func (x *SessionAccepted) Reset() { *x = SessionAccepted{} - mi := &file_openshell_proto_msgTypes[172] + mi := &file_openshell_proto_msgTypes[171] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14014,7 +13925,7 @@ func (x *SessionAccepted) String() string { func (*SessionAccepted) ProtoMessage() {} func (x *SessionAccepted) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[172] + mi := &file_openshell_proto_msgTypes[171] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14027,7 +13938,7 @@ func (x *SessionAccepted) ProtoReflect() protoreflect.Message { // Deprecated: Use SessionAccepted.ProtoReflect.Descriptor instead. func (*SessionAccepted) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{172} + return file_openshell_proto_rawDescGZIP(), []int{171} } func (x *SessionAccepted) GetSessionId() string { @@ -14055,7 +13966,7 @@ type SessionRejected struct { func (x *SessionRejected) Reset() { *x = SessionRejected{} - mi := &file_openshell_proto_msgTypes[173] + mi := &file_openshell_proto_msgTypes[172] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14067,7 +13978,7 @@ func (x *SessionRejected) String() string { func (*SessionRejected) ProtoMessage() {} func (x *SessionRejected) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[173] + mi := &file_openshell_proto_msgTypes[172] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14080,7 +13991,7 @@ func (x *SessionRejected) ProtoReflect() protoreflect.Message { // Deprecated: Use SessionRejected.ProtoReflect.Descriptor instead. func (*SessionRejected) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{173} + return file_openshell_proto_rawDescGZIP(), []int{172} } func (x *SessionRejected) GetReason() string { @@ -14109,7 +14020,7 @@ type SessionRedirect struct { func (x *SessionRedirect) Reset() { *x = SessionRedirect{} - mi := &file_openshell_proto_msgTypes[174] + mi := &file_openshell_proto_msgTypes[173] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14121,7 +14032,7 @@ func (x *SessionRedirect) String() string { func (*SessionRedirect) ProtoMessage() {} func (x *SessionRedirect) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[174] + mi := &file_openshell_proto_msgTypes[173] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14134,7 +14045,7 @@ func (x *SessionRedirect) ProtoReflect() protoreflect.Message { // Deprecated: Use SessionRedirect.ProtoReflect.Descriptor instead. func (*SessionRedirect) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{174} + return file_openshell_proto_rawDescGZIP(), []int{173} } func (x *SessionRedirect) GetPeerEndpoint() string { @@ -14160,7 +14071,7 @@ type SupervisorHeartbeat struct { func (x *SupervisorHeartbeat) Reset() { *x = SupervisorHeartbeat{} - mi := &file_openshell_proto_msgTypes[175] + mi := &file_openshell_proto_msgTypes[174] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14172,7 +14083,7 @@ func (x *SupervisorHeartbeat) String() string { func (*SupervisorHeartbeat) ProtoMessage() {} func (x *SupervisorHeartbeat) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[175] + mi := &file_openshell_proto_msgTypes[174] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14185,7 +14096,7 @@ func (x *SupervisorHeartbeat) ProtoReflect() protoreflect.Message { // Deprecated: Use SupervisorHeartbeat.ProtoReflect.Descriptor instead. func (*SupervisorHeartbeat) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{175} + return file_openshell_proto_rawDescGZIP(), []int{174} } // Gateway heartbeat. @@ -14197,7 +14108,7 @@ type GatewayHeartbeat struct { func (x *GatewayHeartbeat) Reset() { *x = GatewayHeartbeat{} - mi := &file_openshell_proto_msgTypes[176] + mi := &file_openshell_proto_msgTypes[175] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14209,7 +14120,7 @@ func (x *GatewayHeartbeat) String() string { func (*GatewayHeartbeat) ProtoMessage() {} func (x *GatewayHeartbeat) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[176] + mi := &file_openshell_proto_msgTypes[175] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14222,7 +14133,7 @@ func (x *GatewayHeartbeat) ProtoReflect() protoreflect.Message { // Deprecated: Use GatewayHeartbeat.ProtoReflect.Descriptor instead. func (*GatewayHeartbeat) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{176} + return file_openshell_proto_rawDescGZIP(), []int{175} } // Terminal result reported before the supervisor shuts down. A successful RPC @@ -14239,7 +14150,7 @@ type ReportMainProcessExitRequest struct { func (x *ReportMainProcessExitRequest) Reset() { *x = ReportMainProcessExitRequest{} - mi := &file_openshell_proto_msgTypes[177] + mi := &file_openshell_proto_msgTypes[176] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14251,7 +14162,7 @@ func (x *ReportMainProcessExitRequest) String() string { func (*ReportMainProcessExitRequest) ProtoMessage() {} func (x *ReportMainProcessExitRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[177] + mi := &file_openshell_proto_msgTypes[176] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14264,7 +14175,7 @@ func (x *ReportMainProcessExitRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ReportMainProcessExitRequest.ProtoReflect.Descriptor instead. func (*ReportMainProcessExitRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{177} + return file_openshell_proto_rawDescGZIP(), []int{176} } func (x *ReportMainProcessExitRequest) GetSandboxId() string { @@ -14296,7 +14207,7 @@ type ReportMainProcessExitResponse struct { func (x *ReportMainProcessExitResponse) Reset() { *x = ReportMainProcessExitResponse{} - mi := &file_openshell_proto_msgTypes[178] + mi := &file_openshell_proto_msgTypes[177] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14308,7 +14219,7 @@ func (x *ReportMainProcessExitResponse) String() string { func (*ReportMainProcessExitResponse) ProtoMessage() {} func (x *ReportMainProcessExitResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[178] + mi := &file_openshell_proto_msgTypes[177] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14321,7 +14232,7 @@ func (x *ReportMainProcessExitResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ReportMainProcessExitResponse.ProtoReflect.Descriptor instead. func (*ReportMainProcessExitResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{178} + return file_openshell_proto_rawDescGZIP(), []int{177} } // Terminal-delivery completion reported after all expected foreground SSH @@ -14336,7 +14247,7 @@ type FinalizeMainProcessExitRequest struct { func (x *FinalizeMainProcessExitRequest) Reset() { *x = FinalizeMainProcessExitRequest{} - mi := &file_openshell_proto_msgTypes[179] + mi := &file_openshell_proto_msgTypes[178] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14348,7 +14259,7 @@ func (x *FinalizeMainProcessExitRequest) String() string { func (*FinalizeMainProcessExitRequest) ProtoMessage() {} func (x *FinalizeMainProcessExitRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[179] + mi := &file_openshell_proto_msgTypes[178] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14361,7 +14272,7 @@ func (x *FinalizeMainProcessExitRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use FinalizeMainProcessExitRequest.ProtoReflect.Descriptor instead. func (*FinalizeMainProcessExitRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{179} + return file_openshell_proto_rawDescGZIP(), []int{178} } func (x *FinalizeMainProcessExitRequest) GetSandboxId() string { @@ -14386,7 +14297,7 @@ type FinalizeMainProcessExitResponse struct { func (x *FinalizeMainProcessExitResponse) Reset() { *x = FinalizeMainProcessExitResponse{} - mi := &file_openshell_proto_msgTypes[180] + mi := &file_openshell_proto_msgTypes[179] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14398,7 +14309,7 @@ func (x *FinalizeMainProcessExitResponse) String() string { func (*FinalizeMainProcessExitResponse) ProtoMessage() {} func (x *FinalizeMainProcessExitResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[180] + mi := &file_openshell_proto_msgTypes[179] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14411,7 +14322,7 @@ func (x *FinalizeMainProcessExitResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use FinalizeMainProcessExitResponse.ProtoReflect.Descriptor instead. func (*FinalizeMainProcessExitResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{180} + return file_openshell_proto_rawDescGZIP(), []int{179} } // Gateway requests the supervisor to open a relay channel. @@ -14440,7 +14351,7 @@ type RelayOpen struct { func (x *RelayOpen) Reset() { *x = RelayOpen{} - mi := &file_openshell_proto_msgTypes[181] + mi := &file_openshell_proto_msgTypes[180] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14452,7 +14363,7 @@ func (x *RelayOpen) String() string { func (*RelayOpen) ProtoMessage() {} func (x *RelayOpen) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[181] + mi := &file_openshell_proto_msgTypes[180] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14465,7 +14376,7 @@ func (x *RelayOpen) ProtoReflect() protoreflect.Message { // Deprecated: Use RelayOpen.ProtoReflect.Descriptor instead. func (*RelayOpen) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{181} + return file_openshell_proto_rawDescGZIP(), []int{180} } func (x *RelayOpen) GetChannelId() string { @@ -14532,7 +14443,7 @@ type SshRelayTarget struct { func (x *SshRelayTarget) Reset() { *x = SshRelayTarget{} - mi := &file_openshell_proto_msgTypes[182] + mi := &file_openshell_proto_msgTypes[181] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14544,7 +14455,7 @@ func (x *SshRelayTarget) String() string { func (*SshRelayTarget) ProtoMessage() {} func (x *SshRelayTarget) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[182] + mi := &file_openshell_proto_msgTypes[181] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14557,7 +14468,7 @@ func (x *SshRelayTarget) ProtoReflect() protoreflect.Message { // Deprecated: Use SshRelayTarget.ProtoReflect.Descriptor instead. func (*SshRelayTarget) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{182} + return file_openshell_proto_rawDescGZIP(), []int{181} } // TCP target dialed by the supervisor from inside the sandbox. @@ -14573,7 +14484,7 @@ type TcpRelayTarget struct { func (x *TcpRelayTarget) Reset() { *x = TcpRelayTarget{} - mi := &file_openshell_proto_msgTypes[183] + mi := &file_openshell_proto_msgTypes[182] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14585,7 +14496,7 @@ func (x *TcpRelayTarget) String() string { func (*TcpRelayTarget) ProtoMessage() {} func (x *TcpRelayTarget) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[183] + mi := &file_openshell_proto_msgTypes[182] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14598,7 +14509,7 @@ func (x *TcpRelayTarget) ProtoReflect() protoreflect.Message { // Deprecated: Use TcpRelayTarget.ProtoReflect.Descriptor instead. func (*TcpRelayTarget) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{183} + return file_openshell_proto_rawDescGZIP(), []int{182} } func (x *TcpRelayTarget) GetHost() string { @@ -14626,7 +14537,7 @@ type RelayInit struct { func (x *RelayInit) Reset() { *x = RelayInit{} - mi := &file_openshell_proto_msgTypes[184] + mi := &file_openshell_proto_msgTypes[183] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14638,7 +14549,7 @@ func (x *RelayInit) String() string { func (*RelayInit) ProtoMessage() {} func (x *RelayInit) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[184] + mi := &file_openshell_proto_msgTypes[183] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14651,7 +14562,7 @@ func (x *RelayInit) ProtoReflect() protoreflect.Message { // Deprecated: Use RelayInit.ProtoReflect.Descriptor instead. func (*RelayInit) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{184} + return file_openshell_proto_rawDescGZIP(), []int{183} } func (x *RelayInit) GetChannelId() string { @@ -14678,7 +14589,7 @@ type RelayFrame struct { func (x *RelayFrame) Reset() { *x = RelayFrame{} - mi := &file_openshell_proto_msgTypes[185] + mi := &file_openshell_proto_msgTypes[184] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14690,7 +14601,7 @@ func (x *RelayFrame) String() string { func (*RelayFrame) ProtoMessage() {} func (x *RelayFrame) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[185] + mi := &file_openshell_proto_msgTypes[184] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14703,7 +14614,7 @@ func (x *RelayFrame) ProtoReflect() protoreflect.Message { // Deprecated: Use RelayFrame.ProtoReflect.Descriptor instead. func (*RelayFrame) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{185} + return file_openshell_proto_rawDescGZIP(), []int{184} } func (x *RelayFrame) GetPayload() isRelayFrame_Payload { @@ -14763,7 +14674,7 @@ type PeerRelayInit struct { func (x *PeerRelayInit) Reset() { *x = PeerRelayInit{} - mi := &file_openshell_proto_msgTypes[186] + mi := &file_openshell_proto_msgTypes[185] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14775,7 +14686,7 @@ func (x *PeerRelayInit) String() string { func (*PeerRelayInit) ProtoMessage() {} func (x *PeerRelayInit) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[186] + mi := &file_openshell_proto_msgTypes[185] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14788,7 +14699,7 @@ func (x *PeerRelayInit) ProtoReflect() protoreflect.Message { // Deprecated: Use PeerRelayInit.ProtoReflect.Descriptor instead. func (*PeerRelayInit) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{186} + return file_openshell_proto_rawDescGZIP(), []int{185} } func (x *PeerRelayInit) GetSandboxId() string { @@ -14826,7 +14737,7 @@ type PeerRelayFrame struct { func (x *PeerRelayFrame) Reset() { *x = PeerRelayFrame{} - mi := &file_openshell_proto_msgTypes[187] + mi := &file_openshell_proto_msgTypes[186] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14838,7 +14749,7 @@ func (x *PeerRelayFrame) String() string { func (*PeerRelayFrame) ProtoMessage() {} func (x *PeerRelayFrame) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[187] + mi := &file_openshell_proto_msgTypes[186] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14851,7 +14762,7 @@ func (x *PeerRelayFrame) ProtoReflect() protoreflect.Message { // Deprecated: Use PeerRelayFrame.ProtoReflect.Descriptor instead. func (*PeerRelayFrame) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{187} + return file_openshell_proto_rawDescGZIP(), []int{186} } func (x *PeerRelayFrame) GetPayload() isPeerRelayFrame_Payload { @@ -14910,7 +14821,7 @@ type RelayOpenResult struct { func (x *RelayOpenResult) Reset() { *x = RelayOpenResult{} - mi := &file_openshell_proto_msgTypes[188] + mi := &file_openshell_proto_msgTypes[187] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14922,7 +14833,7 @@ func (x *RelayOpenResult) String() string { func (*RelayOpenResult) ProtoMessage() {} func (x *RelayOpenResult) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[188] + mi := &file_openshell_proto_msgTypes[187] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14935,7 +14846,7 @@ func (x *RelayOpenResult) ProtoReflect() protoreflect.Message { // Deprecated: Use RelayOpenResult.ProtoReflect.Descriptor instead. func (*RelayOpenResult) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{188} + return file_openshell_proto_rawDescGZIP(), []int{187} } func (x *RelayOpenResult) GetChannelId() string { @@ -14972,7 +14883,7 @@ type RelayClose struct { func (x *RelayClose) Reset() { *x = RelayClose{} - mi := &file_openshell_proto_msgTypes[189] + mi := &file_openshell_proto_msgTypes[188] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14984,7 +14895,7 @@ func (x *RelayClose) String() string { func (*RelayClose) ProtoMessage() {} func (x *RelayClose) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[189] + mi := &file_openshell_proto_msgTypes[188] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14997,7 +14908,7 @@ func (x *RelayClose) ProtoReflect() protoreflect.Message { // Deprecated: Use RelayClose.ProtoReflect.Descriptor instead. func (*RelayClose) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{189} + return file_openshell_proto_rawDescGZIP(), []int{188} } func (x *RelayClose) GetChannelId() string { @@ -15031,7 +14942,7 @@ type L7RequestSample struct { func (x *L7RequestSample) Reset() { *x = L7RequestSample{} - mi := &file_openshell_proto_msgTypes[190] + mi := &file_openshell_proto_msgTypes[189] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -15043,7 +14954,7 @@ func (x *L7RequestSample) String() string { func (*L7RequestSample) ProtoMessage() {} func (x *L7RequestSample) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[190] + mi := &file_openshell_proto_msgTypes[189] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15056,7 +14967,7 @@ func (x *L7RequestSample) ProtoReflect() protoreflect.Message { // Deprecated: Use L7RequestSample.ProtoReflect.Descriptor instead. func (*L7RequestSample) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{190} + return file_openshell_proto_rawDescGZIP(), []int{189} } func (x *L7RequestSample) GetMethod() string { @@ -15130,7 +15041,7 @@ type DenialSummary struct { func (x *DenialSummary) Reset() { *x = DenialSummary{} - mi := &file_openshell_proto_msgTypes[191] + mi := &file_openshell_proto_msgTypes[190] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -15142,7 +15053,7 @@ func (x *DenialSummary) String() string { func (*DenialSummary) ProtoMessage() {} func (x *DenialSummary) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[191] + mi := &file_openshell_proto_msgTypes[190] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15155,7 +15066,7 @@ func (x *DenialSummary) ProtoReflect() protoreflect.Message { // Deprecated: Use DenialSummary.ProtoReflect.Descriptor instead. func (*DenialSummary) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{191} + return file_openshell_proto_rawDescGZIP(), []int{190} } func (x *DenialSummary) GetSandboxId() string { @@ -15290,7 +15201,7 @@ type DenialGroupCount struct { func (x *DenialGroupCount) Reset() { *x = DenialGroupCount{} - mi := &file_openshell_proto_msgTypes[192] + mi := &file_openshell_proto_msgTypes[191] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -15302,7 +15213,7 @@ func (x *DenialGroupCount) String() string { func (*DenialGroupCount) ProtoMessage() {} func (x *DenialGroupCount) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[192] + mi := &file_openshell_proto_msgTypes[191] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15315,7 +15226,7 @@ func (x *DenialGroupCount) ProtoReflect() protoreflect.Message { // Deprecated: Use DenialGroupCount.ProtoReflect.Descriptor instead. func (*DenialGroupCount) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{192} + return file_openshell_proto_rawDescGZIP(), []int{191} } func (x *DenialGroupCount) GetDenyGroup() string { @@ -15348,7 +15259,7 @@ type NetworkActivitySummary struct { func (x *NetworkActivitySummary) Reset() { *x = NetworkActivitySummary{} - mi := &file_openshell_proto_msgTypes[193] + mi := &file_openshell_proto_msgTypes[192] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -15360,7 +15271,7 @@ func (x *NetworkActivitySummary) String() string { func (*NetworkActivitySummary) ProtoMessage() {} func (x *NetworkActivitySummary) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[193] + mi := &file_openshell_proto_msgTypes[192] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15373,7 +15284,7 @@ func (x *NetworkActivitySummary) ProtoReflect() protoreflect.Message { // Deprecated: Use NetworkActivitySummary.ProtoReflect.Descriptor instead. func (*NetworkActivitySummary) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{193} + return file_openshell_proto_rawDescGZIP(), []int{192} } func (x *NetworkActivitySummary) GetNetworkActivityCount() uint32 { @@ -15461,7 +15372,7 @@ type PolicyChunk struct { func (x *PolicyChunk) Reset() { *x = PolicyChunk{} - mi := &file_openshell_proto_msgTypes[194] + mi := &file_openshell_proto_msgTypes[193] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -15473,7 +15384,7 @@ func (x *PolicyChunk) String() string { func (*PolicyChunk) ProtoMessage() {} func (x *PolicyChunk) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[194] + mi := &file_openshell_proto_msgTypes[193] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15486,7 +15397,7 @@ func (x *PolicyChunk) ProtoReflect() protoreflect.Message { // Deprecated: Use PolicyChunk.ProtoReflect.Descriptor instead. func (*PolicyChunk) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{194} + return file_openshell_proto_rawDescGZIP(), []int{193} } func (x *PolicyChunk) GetId() string { @@ -15674,7 +15585,7 @@ type DraftPolicyUpdate struct { func (x *DraftPolicyUpdate) Reset() { *x = DraftPolicyUpdate{} - mi := &file_openshell_proto_msgTypes[195] + mi := &file_openshell_proto_msgTypes[194] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -15686,7 +15597,7 @@ func (x *DraftPolicyUpdate) String() string { func (*DraftPolicyUpdate) ProtoMessage() {} func (x *DraftPolicyUpdate) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[195] + mi := &file_openshell_proto_msgTypes[194] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15699,7 +15610,7 @@ func (x *DraftPolicyUpdate) ProtoReflect() protoreflect.Message { // Deprecated: Use DraftPolicyUpdate.ProtoReflect.Descriptor instead. func (*DraftPolicyUpdate) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{195} + return file_openshell_proto_rawDescGZIP(), []int{194} } func (x *DraftPolicyUpdate) GetDraftVersion() uint64 { @@ -15758,7 +15669,7 @@ type SubmitPolicyAnalysisRequest struct { func (x *SubmitPolicyAnalysisRequest) Reset() { *x = SubmitPolicyAnalysisRequest{} - mi := &file_openshell_proto_msgTypes[196] + mi := &file_openshell_proto_msgTypes[195] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -15770,7 +15681,7 @@ func (x *SubmitPolicyAnalysisRequest) String() string { func (*SubmitPolicyAnalysisRequest) ProtoMessage() {} func (x *SubmitPolicyAnalysisRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[196] + mi := &file_openshell_proto_msgTypes[195] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15783,7 +15694,7 @@ func (x *SubmitPolicyAnalysisRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use SubmitPolicyAnalysisRequest.ProtoReflect.Descriptor instead. func (*SubmitPolicyAnalysisRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{196} + return file_openshell_proto_rawDescGZIP(), []int{195} } func (x *SubmitPolicyAnalysisRequest) GetWorkspaceScope() *datamodelv1.WorkspaceSelector { @@ -15846,7 +15757,7 @@ type SubmitPolicyAnalysisResponse struct { func (x *SubmitPolicyAnalysisResponse) Reset() { *x = SubmitPolicyAnalysisResponse{} - mi := &file_openshell_proto_msgTypes[197] + mi := &file_openshell_proto_msgTypes[196] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -15858,7 +15769,7 @@ func (x *SubmitPolicyAnalysisResponse) String() string { func (*SubmitPolicyAnalysisResponse) ProtoMessage() {} func (x *SubmitPolicyAnalysisResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[197] + mi := &file_openshell_proto_msgTypes[196] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15871,7 +15782,7 @@ func (x *SubmitPolicyAnalysisResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use SubmitPolicyAnalysisResponse.ProtoReflect.Descriptor instead. func (*SubmitPolicyAnalysisResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{197} + return file_openshell_proto_rawDescGZIP(), []int{196} } func (x *SubmitPolicyAnalysisResponse) GetAcceptedChunks() uint32 { @@ -15916,7 +15827,7 @@ type GetDraftPolicyRequest struct { func (x *GetDraftPolicyRequest) Reset() { *x = GetDraftPolicyRequest{} - mi := &file_openshell_proto_msgTypes[198] + mi := &file_openshell_proto_msgTypes[197] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -15928,7 +15839,7 @@ func (x *GetDraftPolicyRequest) String() string { func (*GetDraftPolicyRequest) ProtoMessage() {} func (x *GetDraftPolicyRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[198] + mi := &file_openshell_proto_msgTypes[197] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15941,7 +15852,7 @@ func (x *GetDraftPolicyRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetDraftPolicyRequest.ProtoReflect.Descriptor instead. func (*GetDraftPolicyRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{198} + return file_openshell_proto_rawDescGZIP(), []int{197} } func (x *GetDraftPolicyRequest) GetWorkspaceScope() *datamodelv1.WorkspaceSelector { @@ -15981,7 +15892,7 @@ type GetDraftPolicyResponse struct { func (x *GetDraftPolicyResponse) Reset() { *x = GetDraftPolicyResponse{} - mi := &file_openshell_proto_msgTypes[199] + mi := &file_openshell_proto_msgTypes[198] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -15993,7 +15904,7 @@ func (x *GetDraftPolicyResponse) String() string { func (*GetDraftPolicyResponse) ProtoMessage() {} func (x *GetDraftPolicyResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[199] + mi := &file_openshell_proto_msgTypes[198] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16006,7 +15917,7 @@ func (x *GetDraftPolicyResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use GetDraftPolicyResponse.ProtoReflect.Descriptor instead. func (*GetDraftPolicyResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{199} + return file_openshell_proto_rawDescGZIP(), []int{198} } func (x *GetDraftPolicyResponse) GetChunks() []*PolicyChunk { @@ -16057,7 +15968,7 @@ type ApproveDraftChunkRequest struct { func (x *ApproveDraftChunkRequest) Reset() { *x = ApproveDraftChunkRequest{} - mi := &file_openshell_proto_msgTypes[200] + mi := &file_openshell_proto_msgTypes[199] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -16069,7 +15980,7 @@ func (x *ApproveDraftChunkRequest) String() string { func (*ApproveDraftChunkRequest) ProtoMessage() {} func (x *ApproveDraftChunkRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[200] + mi := &file_openshell_proto_msgTypes[199] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16082,7 +15993,7 @@ func (x *ApproveDraftChunkRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ApproveDraftChunkRequest.ProtoReflect.Descriptor instead. func (*ApproveDraftChunkRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{200} + return file_openshell_proto_rawDescGZIP(), []int{199} } func (x *ApproveDraftChunkRequest) GetWorkspaceScope() *datamodelv1.WorkspaceSelector { @@ -16132,7 +16043,7 @@ type ApproveDraftChunkResponse struct { func (x *ApproveDraftChunkResponse) Reset() { *x = ApproveDraftChunkResponse{} - mi := &file_openshell_proto_msgTypes[201] + mi := &file_openshell_proto_msgTypes[200] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -16144,7 +16055,7 @@ func (x *ApproveDraftChunkResponse) String() string { func (*ApproveDraftChunkResponse) ProtoMessage() {} func (x *ApproveDraftChunkResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[201] + mi := &file_openshell_proto_msgTypes[200] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16157,7 +16068,7 @@ func (x *ApproveDraftChunkResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ApproveDraftChunkResponse.ProtoReflect.Descriptor instead. func (*ApproveDraftChunkResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{201} + return file_openshell_proto_rawDescGZIP(), []int{200} } func (x *ApproveDraftChunkResponse) GetPolicyVersion() uint32 { @@ -16193,7 +16104,7 @@ type RejectDraftChunkRequest struct { func (x *RejectDraftChunkRequest) Reset() { *x = RejectDraftChunkRequest{} - mi := &file_openshell_proto_msgTypes[202] + mi := &file_openshell_proto_msgTypes[201] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -16205,7 +16116,7 @@ func (x *RejectDraftChunkRequest) String() string { func (*RejectDraftChunkRequest) ProtoMessage() {} func (x *RejectDraftChunkRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[202] + mi := &file_openshell_proto_msgTypes[201] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16218,7 +16129,7 @@ func (x *RejectDraftChunkRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use RejectDraftChunkRequest.ProtoReflect.Descriptor instead. func (*RejectDraftChunkRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{202} + return file_openshell_proto_rawDescGZIP(), []int{201} } func (x *RejectDraftChunkRequest) GetWorkspaceScope() *datamodelv1.WorkspaceSelector { @@ -16264,7 +16175,7 @@ type RejectDraftChunkResponse struct { func (x *RejectDraftChunkResponse) Reset() { *x = RejectDraftChunkResponse{} - mi := &file_openshell_proto_msgTypes[203] + mi := &file_openshell_proto_msgTypes[202] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -16276,7 +16187,7 @@ func (x *RejectDraftChunkResponse) String() string { func (*RejectDraftChunkResponse) ProtoMessage() {} func (x *RejectDraftChunkResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[203] + mi := &file_openshell_proto_msgTypes[202] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16289,7 +16200,7 @@ func (x *RejectDraftChunkResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use RejectDraftChunkResponse.ProtoReflect.Descriptor instead. func (*RejectDraftChunkResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{203} + return file_openshell_proto_rawDescGZIP(), []int{202} } // Approve all pending chunks. @@ -16303,7 +16214,7 @@ type DraftChunkApproval struct { func (x *DraftChunkApproval) Reset() { *x = DraftChunkApproval{} - mi := &file_openshell_proto_msgTypes[204] + mi := &file_openshell_proto_msgTypes[203] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -16315,7 +16226,7 @@ func (x *DraftChunkApproval) String() string { func (*DraftChunkApproval) ProtoMessage() {} func (x *DraftChunkApproval) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[204] + mi := &file_openshell_proto_msgTypes[203] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16328,7 +16239,7 @@ func (x *DraftChunkApproval) ProtoReflect() protoreflect.Message { // Deprecated: Use DraftChunkApproval.ProtoReflect.Descriptor instead. func (*DraftChunkApproval) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{204} + return file_openshell_proto_rawDescGZIP(), []int{203} } func (x *DraftChunkApproval) GetChunkId() string { @@ -16364,7 +16275,7 @@ type ApproveAllDraftChunksRequest struct { func (x *ApproveAllDraftChunksRequest) Reset() { *x = ApproveAllDraftChunksRequest{} - mi := &file_openshell_proto_msgTypes[205] + mi := &file_openshell_proto_msgTypes[204] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -16376,7 +16287,7 @@ func (x *ApproveAllDraftChunksRequest) String() string { func (*ApproveAllDraftChunksRequest) ProtoMessage() {} func (x *ApproveAllDraftChunksRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[205] + mi := &file_openshell_proto_msgTypes[204] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16389,7 +16300,7 @@ func (x *ApproveAllDraftChunksRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ApproveAllDraftChunksRequest.ProtoReflect.Descriptor instead. func (*ApproveAllDraftChunksRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{205} + return file_openshell_proto_rawDescGZIP(), []int{204} } func (x *ApproveAllDraftChunksRequest) GetWorkspaceScope() *datamodelv1.WorkspaceSelector { @@ -16444,7 +16355,7 @@ type ApproveAllDraftChunksResponse struct { func (x *ApproveAllDraftChunksResponse) Reset() { *x = ApproveAllDraftChunksResponse{} - mi := &file_openshell_proto_msgTypes[206] + mi := &file_openshell_proto_msgTypes[205] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -16456,7 +16367,7 @@ func (x *ApproveAllDraftChunksResponse) String() string { func (*ApproveAllDraftChunksResponse) ProtoMessage() {} func (x *ApproveAllDraftChunksResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[206] + mi := &file_openshell_proto_msgTypes[205] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16469,7 +16380,7 @@ func (x *ApproveAllDraftChunksResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ApproveAllDraftChunksResponse.ProtoReflect.Descriptor instead. func (*ApproveAllDraftChunksResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{206} + return file_openshell_proto_rawDescGZIP(), []int{205} } func (x *ApproveAllDraftChunksResponse) GetPolicyVersion() uint32 { @@ -16519,7 +16430,7 @@ type EditDraftChunkRequest struct { func (x *EditDraftChunkRequest) Reset() { *x = EditDraftChunkRequest{} - mi := &file_openshell_proto_msgTypes[207] + mi := &file_openshell_proto_msgTypes[206] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -16531,7 +16442,7 @@ func (x *EditDraftChunkRequest) String() string { func (*EditDraftChunkRequest) ProtoMessage() {} func (x *EditDraftChunkRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[207] + mi := &file_openshell_proto_msgTypes[206] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16544,7 +16455,7 @@ func (x *EditDraftChunkRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use EditDraftChunkRequest.ProtoReflect.Descriptor instead. func (*EditDraftChunkRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{207} + return file_openshell_proto_rawDescGZIP(), []int{206} } func (x *EditDraftChunkRequest) GetWorkspaceScope() *datamodelv1.WorkspaceSelector { @@ -16590,7 +16501,7 @@ type EditDraftChunkResponse struct { func (x *EditDraftChunkResponse) Reset() { *x = EditDraftChunkResponse{} - mi := &file_openshell_proto_msgTypes[208] + mi := &file_openshell_proto_msgTypes[207] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -16602,7 +16513,7 @@ func (x *EditDraftChunkResponse) String() string { func (*EditDraftChunkResponse) ProtoMessage() {} func (x *EditDraftChunkResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[208] + mi := &file_openshell_proto_msgTypes[207] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16615,7 +16526,7 @@ func (x *EditDraftChunkResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use EditDraftChunkResponse.ProtoReflect.Descriptor instead. func (*EditDraftChunkResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{208} + return file_openshell_proto_rawDescGZIP(), []int{207} } // Reverse an approval (remove merged rule from active policy). @@ -16635,7 +16546,7 @@ type UndoDraftChunkRequest struct { func (x *UndoDraftChunkRequest) Reset() { *x = UndoDraftChunkRequest{} - mi := &file_openshell_proto_msgTypes[209] + mi := &file_openshell_proto_msgTypes[208] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -16647,7 +16558,7 @@ func (x *UndoDraftChunkRequest) String() string { func (*UndoDraftChunkRequest) ProtoMessage() {} func (x *UndoDraftChunkRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[209] + mi := &file_openshell_proto_msgTypes[208] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16660,7 +16571,7 @@ func (x *UndoDraftChunkRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use UndoDraftChunkRequest.ProtoReflect.Descriptor instead. func (*UndoDraftChunkRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{209} + return file_openshell_proto_rawDescGZIP(), []int{208} } func (x *UndoDraftChunkRequest) GetWorkspaceScope() *datamodelv1.WorkspaceSelector { @@ -16703,7 +16614,7 @@ type UndoDraftChunkResponse struct { func (x *UndoDraftChunkResponse) Reset() { *x = UndoDraftChunkResponse{} - mi := &file_openshell_proto_msgTypes[210] + mi := &file_openshell_proto_msgTypes[209] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -16715,7 +16626,7 @@ func (x *UndoDraftChunkResponse) String() string { func (*UndoDraftChunkResponse) ProtoMessage() {} func (x *UndoDraftChunkResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[210] + mi := &file_openshell_proto_msgTypes[209] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16728,7 +16639,7 @@ func (x *UndoDraftChunkResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use UndoDraftChunkResponse.ProtoReflect.Descriptor instead. func (*UndoDraftChunkResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{210} + return file_openshell_proto_rawDescGZIP(), []int{209} } func (x *UndoDraftChunkResponse) GetPolicyVersion() uint32 { @@ -16760,7 +16671,7 @@ type ClearDraftChunksRequest struct { func (x *ClearDraftChunksRequest) Reset() { *x = ClearDraftChunksRequest{} - mi := &file_openshell_proto_msgTypes[211] + mi := &file_openshell_proto_msgTypes[210] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -16772,7 +16683,7 @@ func (x *ClearDraftChunksRequest) String() string { func (*ClearDraftChunksRequest) ProtoMessage() {} func (x *ClearDraftChunksRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[211] + mi := &file_openshell_proto_msgTypes[210] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16785,7 +16696,7 @@ func (x *ClearDraftChunksRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ClearDraftChunksRequest.ProtoReflect.Descriptor instead. func (*ClearDraftChunksRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{211} + return file_openshell_proto_rawDescGZIP(), []int{210} } func (x *ClearDraftChunksRequest) GetWorkspaceScope() *datamodelv1.WorkspaceSelector { @@ -16819,7 +16730,7 @@ type ClearDraftChunksResponse struct { func (x *ClearDraftChunksResponse) Reset() { *x = ClearDraftChunksResponse{} - mi := &file_openshell_proto_msgTypes[212] + mi := &file_openshell_proto_msgTypes[211] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -16831,7 +16742,7 @@ func (x *ClearDraftChunksResponse) String() string { func (*ClearDraftChunksResponse) ProtoMessage() {} func (x *ClearDraftChunksResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[212] + mi := &file_openshell_proto_msgTypes[211] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16844,7 +16755,7 @@ func (x *ClearDraftChunksResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ClearDraftChunksResponse.ProtoReflect.Descriptor instead. func (*ClearDraftChunksResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{212} + return file_openshell_proto_rawDescGZIP(), []int{211} } func (x *ClearDraftChunksResponse) GetChunksCleared() uint32 { @@ -16866,7 +16777,7 @@ type GetDraftHistoryRequest struct { func (x *GetDraftHistoryRequest) Reset() { *x = GetDraftHistoryRequest{} - mi := &file_openshell_proto_msgTypes[213] + mi := &file_openshell_proto_msgTypes[212] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -16878,7 +16789,7 @@ func (x *GetDraftHistoryRequest) String() string { func (*GetDraftHistoryRequest) ProtoMessage() {} func (x *GetDraftHistoryRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[213] + mi := &file_openshell_proto_msgTypes[212] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16891,7 +16802,7 @@ func (x *GetDraftHistoryRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetDraftHistoryRequest.ProtoReflect.Descriptor instead. func (*GetDraftHistoryRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{213} + return file_openshell_proto_rawDescGZIP(), []int{212} } func (x *GetDraftHistoryRequest) GetWorkspaceScope() *datamodelv1.WorkspaceSelector { @@ -16925,7 +16836,7 @@ type DraftHistoryEntry struct { func (x *DraftHistoryEntry) Reset() { *x = DraftHistoryEntry{} - mi := &file_openshell_proto_msgTypes[214] + mi := &file_openshell_proto_msgTypes[213] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -16937,7 +16848,7 @@ func (x *DraftHistoryEntry) String() string { func (*DraftHistoryEntry) ProtoMessage() {} func (x *DraftHistoryEntry) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[214] + mi := &file_openshell_proto_msgTypes[213] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16950,7 +16861,7 @@ func (x *DraftHistoryEntry) ProtoReflect() protoreflect.Message { // Deprecated: Use DraftHistoryEntry.ProtoReflect.Descriptor instead. func (*DraftHistoryEntry) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{214} + return file_openshell_proto_rawDescGZIP(), []int{213} } func (x *DraftHistoryEntry) GetEventTime() *timestamppb.Timestamp { @@ -16991,7 +16902,7 @@ type GetDraftHistoryResponse struct { func (x *GetDraftHistoryResponse) Reset() { *x = GetDraftHistoryResponse{} - mi := &file_openshell_proto_msgTypes[215] + mi := &file_openshell_proto_msgTypes[214] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -17003,7 +16914,7 @@ func (x *GetDraftHistoryResponse) String() string { func (*GetDraftHistoryResponse) ProtoMessage() {} func (x *GetDraftHistoryResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[215] + mi := &file_openshell_proto_msgTypes[214] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -17016,7 +16927,7 @@ func (x *GetDraftHistoryResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use GetDraftHistoryResponse.ProtoReflect.Descriptor instead. func (*GetDraftHistoryResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{215} + return file_openshell_proto_rawDescGZIP(), []int{214} } func (x *GetDraftHistoryResponse) GetEntries() []*DraftHistoryEntry { @@ -17041,7 +16952,7 @@ type CreateWorkspaceRequest struct { func (x *CreateWorkspaceRequest) Reset() { *x = CreateWorkspaceRequest{} - mi := &file_openshell_proto_msgTypes[216] + mi := &file_openshell_proto_msgTypes[215] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -17053,7 +16964,7 @@ func (x *CreateWorkspaceRequest) String() string { func (*CreateWorkspaceRequest) ProtoMessage() {} func (x *CreateWorkspaceRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[216] + mi := &file_openshell_proto_msgTypes[215] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -17066,7 +16977,7 @@ func (x *CreateWorkspaceRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use CreateWorkspaceRequest.ProtoReflect.Descriptor instead. func (*CreateWorkspaceRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{216} + return file_openshell_proto_rawDescGZIP(), []int{215} } func (x *CreateWorkspaceRequest) GetName() string { @@ -17100,7 +17011,7 @@ type CreateWorkspaceResponse struct { func (x *CreateWorkspaceResponse) Reset() { *x = CreateWorkspaceResponse{} - mi := &file_openshell_proto_msgTypes[217] + mi := &file_openshell_proto_msgTypes[216] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -17112,7 +17023,7 @@ func (x *CreateWorkspaceResponse) String() string { func (*CreateWorkspaceResponse) ProtoMessage() {} func (x *CreateWorkspaceResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[217] + mi := &file_openshell_proto_msgTypes[216] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -17125,7 +17036,7 @@ func (x *CreateWorkspaceResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use CreateWorkspaceResponse.ProtoReflect.Descriptor instead. func (*CreateWorkspaceResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{217} + return file_openshell_proto_rawDescGZIP(), []int{216} } func (x *CreateWorkspaceResponse) GetWorkspace() *datamodelv1.Workspace { @@ -17146,7 +17057,7 @@ type GetWorkspaceRequest struct { func (x *GetWorkspaceRequest) Reset() { *x = GetWorkspaceRequest{} - mi := &file_openshell_proto_msgTypes[218] + mi := &file_openshell_proto_msgTypes[217] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -17158,7 +17069,7 @@ func (x *GetWorkspaceRequest) String() string { func (*GetWorkspaceRequest) ProtoMessage() {} func (x *GetWorkspaceRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[218] + mi := &file_openshell_proto_msgTypes[217] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -17171,7 +17082,7 @@ func (x *GetWorkspaceRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetWorkspaceRequest.ProtoReflect.Descriptor instead. func (*GetWorkspaceRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{218} + return file_openshell_proto_rawDescGZIP(), []int{217} } func (x *GetWorkspaceRequest) GetName() string { @@ -17191,7 +17102,7 @@ type GetWorkspaceResponse struct { func (x *GetWorkspaceResponse) Reset() { *x = GetWorkspaceResponse{} - mi := &file_openshell_proto_msgTypes[219] + mi := &file_openshell_proto_msgTypes[218] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -17203,7 +17114,7 @@ func (x *GetWorkspaceResponse) String() string { func (*GetWorkspaceResponse) ProtoMessage() {} func (x *GetWorkspaceResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[219] + mi := &file_openshell_proto_msgTypes[218] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -17216,7 +17127,7 @@ func (x *GetWorkspaceResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use GetWorkspaceResponse.ProtoReflect.Descriptor instead. func (*GetWorkspaceResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{219} + return file_openshell_proto_rawDescGZIP(), []int{218} } func (x *GetWorkspaceResponse) GetWorkspace() *datamodelv1.Workspace { @@ -17243,7 +17154,7 @@ type ListWorkspacesRequest struct { func (x *ListWorkspacesRequest) Reset() { *x = ListWorkspacesRequest{} - mi := &file_openshell_proto_msgTypes[220] + mi := &file_openshell_proto_msgTypes[219] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -17255,7 +17166,7 @@ func (x *ListWorkspacesRequest) String() string { func (*ListWorkspacesRequest) ProtoMessage() {} func (x *ListWorkspacesRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[220] + mi := &file_openshell_proto_msgTypes[219] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -17268,7 +17179,7 @@ func (x *ListWorkspacesRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListWorkspacesRequest.ProtoReflect.Descriptor instead. func (*ListWorkspacesRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{220} + return file_openshell_proto_rawDescGZIP(), []int{219} } func (x *ListWorkspacesRequest) GetPageSize() int32 { @@ -17304,7 +17215,7 @@ type ListWorkspacesResponse struct { func (x *ListWorkspacesResponse) Reset() { *x = ListWorkspacesResponse{} - mi := &file_openshell_proto_msgTypes[221] + mi := &file_openshell_proto_msgTypes[220] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -17316,7 +17227,7 @@ func (x *ListWorkspacesResponse) String() string { func (*ListWorkspacesResponse) ProtoMessage() {} func (x *ListWorkspacesResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[221] + mi := &file_openshell_proto_msgTypes[220] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -17329,7 +17240,7 @@ func (x *ListWorkspacesResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListWorkspacesResponse.ProtoReflect.Descriptor instead. func (*ListWorkspacesResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{221} + return file_openshell_proto_rawDescGZIP(), []int{220} } func (x *ListWorkspacesResponse) GetWorkspaces() []*datamodelv1.Workspace { @@ -17360,7 +17271,7 @@ type DeleteWorkspaceRequest struct { func (x *DeleteWorkspaceRequest) Reset() { *x = DeleteWorkspaceRequest{} - mi := &file_openshell_proto_msgTypes[222] + mi := &file_openshell_proto_msgTypes[221] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -17372,7 +17283,7 @@ func (x *DeleteWorkspaceRequest) String() string { func (*DeleteWorkspaceRequest) ProtoMessage() {} func (x *DeleteWorkspaceRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[222] + mi := &file_openshell_proto_msgTypes[221] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -17385,7 +17296,7 @@ func (x *DeleteWorkspaceRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteWorkspaceRequest.ProtoReflect.Descriptor instead. func (*DeleteWorkspaceRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{222} + return file_openshell_proto_rawDescGZIP(), []int{221} } func (x *DeleteWorkspaceRequest) GetName() string { @@ -17419,7 +17330,7 @@ type DeleteWorkspaceResponse struct { func (x *DeleteWorkspaceResponse) Reset() { *x = DeleteWorkspaceResponse{} - mi := &file_openshell_proto_msgTypes[223] + mi := &file_openshell_proto_msgTypes[222] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -17431,7 +17342,7 @@ func (x *DeleteWorkspaceResponse) String() string { func (*DeleteWorkspaceResponse) ProtoMessage() {} func (x *DeleteWorkspaceResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[223] + mi := &file_openshell_proto_msgTypes[222] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -17444,7 +17355,7 @@ func (x *DeleteWorkspaceResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteWorkspaceResponse.ProtoReflect.Descriptor instead. func (*DeleteWorkspaceResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{223} + return file_openshell_proto_rawDescGZIP(), []int{222} } func (x *DeleteWorkspaceResponse) GetOutcome() DeletionOutcome { @@ -17468,7 +17379,7 @@ type WorkspaceMember struct { func (x *WorkspaceMember) Reset() { *x = WorkspaceMember{} - mi := &file_openshell_proto_msgTypes[224] + mi := &file_openshell_proto_msgTypes[223] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -17480,7 +17391,7 @@ func (x *WorkspaceMember) String() string { func (*WorkspaceMember) ProtoMessage() {} func (x *WorkspaceMember) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[224] + mi := &file_openshell_proto_msgTypes[223] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -17493,7 +17404,7 @@ func (x *WorkspaceMember) ProtoReflect() protoreflect.Message { // Deprecated: Use WorkspaceMember.ProtoReflect.Descriptor instead. func (*WorkspaceMember) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{224} + return file_openshell_proto_rawDescGZIP(), []int{223} } func (x *WorkspaceMember) GetMetadata() *datamodelv1.ObjectMeta { @@ -17534,7 +17445,7 @@ type AddWorkspaceMemberRequest struct { func (x *AddWorkspaceMemberRequest) Reset() { *x = AddWorkspaceMemberRequest{} - mi := &file_openshell_proto_msgTypes[225] + mi := &file_openshell_proto_msgTypes[224] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -17546,7 +17457,7 @@ func (x *AddWorkspaceMemberRequest) String() string { func (*AddWorkspaceMemberRequest) ProtoMessage() {} func (x *AddWorkspaceMemberRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[225] + mi := &file_openshell_proto_msgTypes[224] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -17559,7 +17470,7 @@ func (x *AddWorkspaceMemberRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use AddWorkspaceMemberRequest.ProtoReflect.Descriptor instead. func (*AddWorkspaceMemberRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{225} + return file_openshell_proto_rawDescGZIP(), []int{224} } func (x *AddWorkspaceMemberRequest) GetWorkspaceScope() *datamodelv1.WorkspaceSelector { @@ -17600,7 +17511,7 @@ type AddWorkspaceMemberResponse struct { func (x *AddWorkspaceMemberResponse) Reset() { *x = AddWorkspaceMemberResponse{} - mi := &file_openshell_proto_msgTypes[226] + mi := &file_openshell_proto_msgTypes[225] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -17612,7 +17523,7 @@ func (x *AddWorkspaceMemberResponse) String() string { func (*AddWorkspaceMemberResponse) ProtoMessage() {} func (x *AddWorkspaceMemberResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[226] + mi := &file_openshell_proto_msgTypes[225] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -17625,7 +17536,7 @@ func (x *AddWorkspaceMemberResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use AddWorkspaceMemberResponse.ProtoReflect.Descriptor instead. func (*AddWorkspaceMemberResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{226} + return file_openshell_proto_rawDescGZIP(), []int{225} } func (x *AddWorkspaceMemberResponse) GetMember() *WorkspaceMember { @@ -17651,7 +17562,7 @@ type RemoveWorkspaceMemberRequest struct { func (x *RemoveWorkspaceMemberRequest) Reset() { *x = RemoveWorkspaceMemberRequest{} - mi := &file_openshell_proto_msgTypes[227] + mi := &file_openshell_proto_msgTypes[226] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -17663,7 +17574,7 @@ func (x *RemoveWorkspaceMemberRequest) String() string { func (*RemoveWorkspaceMemberRequest) ProtoMessage() {} func (x *RemoveWorkspaceMemberRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[227] + mi := &file_openshell_proto_msgTypes[226] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -17676,7 +17587,7 @@ func (x *RemoveWorkspaceMemberRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use RemoveWorkspaceMemberRequest.ProtoReflect.Descriptor instead. func (*RemoveWorkspaceMemberRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{227} + return file_openshell_proto_rawDescGZIP(), []int{226} } func (x *RemoveWorkspaceMemberRequest) GetWorkspaceScope() *datamodelv1.WorkspaceSelector { @@ -17717,7 +17628,7 @@ type RemoveWorkspaceMemberResponse struct { func (x *RemoveWorkspaceMemberResponse) Reset() { *x = RemoveWorkspaceMemberResponse{} - mi := &file_openshell_proto_msgTypes[228] + mi := &file_openshell_proto_msgTypes[227] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -17729,7 +17640,7 @@ func (x *RemoveWorkspaceMemberResponse) String() string { func (*RemoveWorkspaceMemberResponse) ProtoMessage() {} func (x *RemoveWorkspaceMemberResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[228] + mi := &file_openshell_proto_msgTypes[227] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -17742,7 +17653,7 @@ func (x *RemoveWorkspaceMemberResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use RemoveWorkspaceMemberResponse.ProtoReflect.Descriptor instead. func (*RemoveWorkspaceMemberResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{228} + return file_openshell_proto_rawDescGZIP(), []int{227} } func (x *RemoveWorkspaceMemberResponse) GetOutcome() DeletionOutcome { @@ -17769,7 +17680,7 @@ type ListWorkspaceMembersRequest struct { func (x *ListWorkspaceMembersRequest) Reset() { *x = ListWorkspaceMembersRequest{} - mi := &file_openshell_proto_msgTypes[229] + mi := &file_openshell_proto_msgTypes[228] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -17781,7 +17692,7 @@ func (x *ListWorkspaceMembersRequest) String() string { func (*ListWorkspaceMembersRequest) ProtoMessage() {} func (x *ListWorkspaceMembersRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[229] + mi := &file_openshell_proto_msgTypes[228] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -17794,7 +17705,7 @@ func (x *ListWorkspaceMembersRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListWorkspaceMembersRequest.ProtoReflect.Descriptor instead. func (*ListWorkspaceMembersRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{229} + return file_openshell_proto_rawDescGZIP(), []int{228} } func (x *ListWorkspaceMembersRequest) GetWorkspaceScope() *datamodelv1.WorkspaceSelector { @@ -17830,7 +17741,7 @@ type ListWorkspaceMembersResponse struct { func (x *ListWorkspaceMembersResponse) Reset() { *x = ListWorkspaceMembersResponse{} - mi := &file_openshell_proto_msgTypes[230] + mi := &file_openshell_proto_msgTypes[229] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -17842,7 +17753,7 @@ func (x *ListWorkspaceMembersResponse) String() string { func (*ListWorkspaceMembersResponse) ProtoMessage() {} func (x *ListWorkspaceMembersResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[230] + mi := &file_openshell_proto_msgTypes[229] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -17855,7 +17766,7 @@ func (x *ListWorkspaceMembersResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListWorkspaceMembersResponse.ProtoReflect.Descriptor instead. func (*ListWorkspaceMembersResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{230} + return file_openshell_proto_rawDescGZIP(), []int{229} } func (x *ListWorkspaceMembersResponse) GetMembers() []*WorkspaceMember { @@ -17890,7 +17801,7 @@ type ExtensionServiceCredential struct { func (x *ExtensionServiceCredential) Reset() { *x = ExtensionServiceCredential{} - mi := &file_openshell_proto_msgTypes[231] + mi := &file_openshell_proto_msgTypes[230] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -17902,7 +17813,7 @@ func (x *ExtensionServiceCredential) String() string { func (*ExtensionServiceCredential) ProtoMessage() {} func (x *ExtensionServiceCredential) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[231] + mi := &file_openshell_proto_msgTypes[230] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -17915,7 +17826,7 @@ func (x *ExtensionServiceCredential) ProtoReflect() protoreflect.Message { // Deprecated: Use ExtensionServiceCredential.ProtoReflect.Descriptor instead. func (*ExtensionServiceCredential) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{231} + return file_openshell_proto_rawDescGZIP(), []int{230} } func (x *ExtensionServiceCredential) GetServiceName() string { @@ -17955,7 +17866,7 @@ type EndpointObservation struct { func (x *EndpointObservation) Reset() { *x = EndpointObservation{} - mi := &file_openshell_proto_msgTypes[232] + mi := &file_openshell_proto_msgTypes[231] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -17967,7 +17878,7 @@ func (x *EndpointObservation) String() string { func (*EndpointObservation) ProtoMessage() {} func (x *EndpointObservation) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[232] + mi := &file_openshell_proto_msgTypes[231] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -17980,7 +17891,7 @@ func (x *EndpointObservation) ProtoReflect() protoreflect.Message { // Deprecated: Use EndpointObservation.ProtoReflect.Descriptor instead. func (*EndpointObservation) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{232} + return file_openshell_proto_rawDescGZIP(), []int{231} } func (x *EndpointObservation) GetEndpointId() string { @@ -18033,7 +17944,7 @@ type ReportEndpointStatusRequest struct { func (x *ReportEndpointStatusRequest) Reset() { *x = ReportEndpointStatusRequest{} - mi := &file_openshell_proto_msgTypes[233] + mi := &file_openshell_proto_msgTypes[232] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -18045,7 +17956,7 @@ func (x *ReportEndpointStatusRequest) String() string { func (*ReportEndpointStatusRequest) ProtoMessage() {} func (x *ReportEndpointStatusRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[233] + mi := &file_openshell_proto_msgTypes[232] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -18058,7 +17969,7 @@ func (x *ReportEndpointStatusRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ReportEndpointStatusRequest.ProtoReflect.Descriptor instead. func (*ReportEndpointStatusRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{233} + return file_openshell_proto_rawDescGZIP(), []int{232} } func (x *ReportEndpointStatusRequest) GetSandboxId() string { @@ -18127,7 +18038,7 @@ type TokenGrantStatus struct { func (x *TokenGrantStatus) Reset() { *x = TokenGrantStatus{} - mi := &file_openshell_proto_msgTypes[234] + mi := &file_openshell_proto_msgTypes[233] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -18139,7 +18050,7 @@ func (x *TokenGrantStatus) String() string { func (*TokenGrantStatus) ProtoMessage() {} func (x *TokenGrantStatus) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[234] + mi := &file_openshell_proto_msgTypes[233] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -18152,7 +18063,7 @@ func (x *TokenGrantStatus) ProtoReflect() protoreflect.Message { // Deprecated: Use TokenGrantStatus.ProtoReflect.Descriptor instead. func (*TokenGrantStatus) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{234} + return file_openshell_proto_rawDescGZIP(), []int{233} } func (x *TokenGrantStatus) GetLastFailure() *TokenGrantFailureObservation { @@ -18179,7 +18090,7 @@ type TokenGrantFailureObservation struct { func (x *TokenGrantFailureObservation) Reset() { *x = TokenGrantFailureObservation{} - mi := &file_openshell_proto_msgTypes[235] + mi := &file_openshell_proto_msgTypes[234] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -18191,7 +18102,7 @@ func (x *TokenGrantFailureObservation) String() string { func (*TokenGrantFailureObservation) ProtoMessage() {} func (x *TokenGrantFailureObservation) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[235] + mi := &file_openshell_proto_msgTypes[234] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -18204,7 +18115,7 @@ func (x *TokenGrantFailureObservation) ProtoReflect() protoreflect.Message { // Deprecated: Use TokenGrantFailureObservation.ProtoReflect.Descriptor instead. func (*TokenGrantFailureObservation) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{235} + return file_openshell_proto_rawDescGZIP(), []int{234} } func (x *TokenGrantFailureObservation) GetDestinationHost() string { @@ -18237,7 +18148,7 @@ type ReportEndpointStatusResponse struct { func (x *ReportEndpointStatusResponse) Reset() { *x = ReportEndpointStatusResponse{} - mi := &file_openshell_proto_msgTypes[236] + mi := &file_openshell_proto_msgTypes[235] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -18249,7 +18160,7 @@ func (x *ReportEndpointStatusResponse) String() string { func (*ReportEndpointStatusResponse) ProtoMessage() {} func (x *ReportEndpointStatusResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[236] + mi := &file_openshell_proto_msgTypes[235] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -18262,7 +18173,7 @@ func (x *ReportEndpointStatusResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ReportEndpointStatusResponse.ProtoReflect.Descriptor instead. func (*ReportEndpointStatusResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{236} + return file_openshell_proto_rawDescGZIP(), []int{235} } // A configured endpoint and its last accepted network result in one record. @@ -18296,7 +18207,7 @@ type EndpointStatus struct { func (x *EndpointStatus) Reset() { *x = EndpointStatus{} - mi := &file_openshell_proto_msgTypes[237] + mi := &file_openshell_proto_msgTypes[236] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -18308,7 +18219,7 @@ func (x *EndpointStatus) String() string { func (*EndpointStatus) ProtoMessage() {} func (x *EndpointStatus) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[237] + mi := &file_openshell_proto_msgTypes[236] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -18321,7 +18232,7 @@ func (x *EndpointStatus) ProtoReflect() protoreflect.Message { // Deprecated: Use EndpointStatus.ProtoReflect.Descriptor instead. func (*EndpointStatus) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{237} + return file_openshell_proto_rawDescGZIP(), []int{236} } func (x *EndpointStatus) GetEndpointId() string { @@ -18416,7 +18327,7 @@ type SandboxProvisioning struct { func (x *SandboxProvisioning) Reset() { *x = SandboxProvisioning{} - mi := &file_openshell_proto_msgTypes[238] + mi := &file_openshell_proto_msgTypes[237] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -18428,7 +18339,7 @@ func (x *SandboxProvisioning) String() string { func (*SandboxProvisioning) ProtoMessage() {} func (x *SandboxProvisioning) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[238] + mi := &file_openshell_proto_msgTypes[237] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -18441,7 +18352,7 @@ func (x *SandboxProvisioning) ProtoReflect() protoreflect.Message { // Deprecated: Use SandboxProvisioning.ProtoReflect.Descriptor instead. func (*SandboxProvisioning) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{238} + return file_openshell_proto_rawDescGZIP(), []int{237} } func (x *SandboxProvisioning) GetAttemptId() string { @@ -18564,7 +18475,7 @@ type SandboxServiceExposure struct { func (x *SandboxServiceExposure) Reset() { *x = SandboxServiceExposure{} - mi := &file_openshell_proto_msgTypes[239] + mi := &file_openshell_proto_msgTypes[238] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -18576,7 +18487,7 @@ func (x *SandboxServiceExposure) String() string { func (*SandboxServiceExposure) ProtoMessage() {} func (x *SandboxServiceExposure) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[239] + mi := &file_openshell_proto_msgTypes[238] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -18589,7 +18500,7 @@ func (x *SandboxServiceExposure) ProtoReflect() protoreflect.Message { // Deprecated: Use SandboxServiceExposure.ProtoReflect.Descriptor instead. func (*SandboxServiceExposure) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{239} + return file_openshell_proto_rawDescGZIP(), []int{238} } func (x *SandboxServiceExposure) GetService() string { @@ -18643,7 +18554,7 @@ type EndpointFailure struct { func (x *EndpointFailure) Reset() { *x = EndpointFailure{} - mi := &file_openshell_proto_msgTypes[240] + mi := &file_openshell_proto_msgTypes[239] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -18655,7 +18566,7 @@ func (x *EndpointFailure) String() string { func (*EndpointFailure) ProtoMessage() {} func (x *EndpointFailure) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[240] + mi := &file_openshell_proto_msgTypes[239] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -18668,7 +18579,7 @@ func (x *EndpointFailure) ProtoReflect() protoreflect.Message { // Deprecated: Use EndpointFailure.ProtoReflect.Descriptor instead. func (*EndpointFailure) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{240} + return file_openshell_proto_rawDescGZIP(), []int{239} } func (x *EndpointFailure) GetDomain() EndpointFailureDomain { @@ -18868,7 +18779,7 @@ const file_openshell_proto_rawDesc = "" + "\tmax_burst\x18\x02 \x01(\rR\bmaxBurst\"b\n" + "!SandboxWorkloadTemplateProvenance\x12\x12\n" + "\x04name\x18\x01 \x01(\tR\x04name\x12)\n" + - "\x10resource_version\x18\x02 \x01(\tR\x0fresourceVersion\"\xde\b\n" + + "\x10resource_version\x18\x02 \x01(\tR\x0fresourceVersion\"\xf2\a\n" + "\rSandboxStatus\x12\x1b\n" + "\tagent_pod\x18\x02 \x01(\tR\bagentPod\x12\x19\n" + "\bagent_fd\x18\x03 \x01(\tR\aagentFd\x12\x1d\n" + @@ -18889,17 +18800,10 @@ const file_openshell_proto_rawDesc = "" + "\rrestart_count\x18\x0e \x01(\rR\frestartCount\x12F\n" + "\x11next_restart_time\x18\x0f \x01(\v2\x1a.google.protobuf.TimestampR\x0fnextRestartTime\x12U\n" + "\x19main_process_started_time\x18\x10 \x01(\v2\x1a.google.protobuf.TimestampR\x16mainProcessStartedTime\x12c\n" + - "\x18last_token_grant_failure\x18\x11 \x01(\v2*.openshell.v1.TokenGrantFailureObservationR\x15lastTokenGrantFailure\x12C\n" + - "\fimage_update\x18\x12 \x01(\v2 .openshell.v1.SandboxImageUpdateR\vimageUpdate\x12%\n" + - "\x0eimage_revision\x18\x13 \x01(\x04R\rimageRevisionB\f\n" + + "\x18last_token_grant_failure\x18\x11 \x01(\v2*.openshell.v1.TokenGrantFailureObservationR\x15lastTokenGrantFailureB\f\n" + "\n" + "_exit_codeB\x1a\n" + - "\x18_configuration_activated\"\x90\x01\n" + - "\x12SandboxImageUpdate\x12!\n" + - "\foperation_id\x18\x01 \x01(\tR\voperationId\x12%\n" + - "\x0eprevious_image\x18\x02 \x01(\tR\rpreviousImage\x12\x14\n" + - "\x05image\x18\x03 \x01(\tR\x05image\x12\x1a\n" + - "\brevision\x18\x04 \x01(\x04R\brevision\"\xd1\x01\n" + + "\x18_configuration_activated\"\xd1\x01\n" + "\x10SandboxCondition\x12\x12\n" + "\x04type\x18\x01 \x01(\tR\x04type\x12\x16\n" + "\x06status\x18\x02 \x01(\tR\x06status\x12\x16\n" + @@ -20278,7 +20182,7 @@ const file_openshell_proto_rawDesc = "" + "-SERVICE_AUTHORIZATION_MODE_BEARER_PASSTHROUGH\x10\x02*i\n" + "\x15EndpointFailureDomain\x12'\n" + "#ENDPOINT_FAILURE_DOMAIN_UNSPECIFIED\x10\x00\x12'\n" + - "#ENDPOINT_FAILURE_DOMAIN_TOKEN_GRANT\x10\x012\xacW\n" + + "#ENDPOINT_FAILURE_DOMAIN_TOKEN_GRANT\x10\x012\xb5V\n" + "\tOpenShell\x12Z\n" + "\x06Health\x12\x1b.openshell.v1.HealthRequest\x1a\x1c.openshell.v1.HealthResponse\"\x15\x82\xb5\x18\x11\n" + "\x0funauthenticated\x12i\n" + @@ -20287,8 +20191,6 @@ const file_openshell_proto_rawDesc = "" + "\x0eGetGatewayInfo\x12#.openshell.v1.GetGatewayInfoRequest\x1a$.openshell.v1.GetGatewayInfoResponse\")\x82\xb5\x18%\n" + "\x06bearer\x1a\x0eplatform_admin\"\vconfig:read\x12u\n" + "\rCreateSandbox\x12\".openshell.v1.CreateSandboxRequest\x1a\x1d.openshell.v1.SandboxResponse\"!\x82\xb5\x18\x1d\n" + - "\x06bearer\x12\x04user\"\rsandbox:write\x12u\n" + - "\rUpdateSandbox\x12\".openshell.v1.UpdateSandboxRequest\x1a\x1d.openshell.v1.SandboxResponse\"!\x82\xb5\x18\x1d\n" + "\x06bearer\x12\x04user\"\rsandbox:write\x12\x93\x01\n" + "\x15BeginRootfsTarStaging\x12*.openshell.v1.BeginRootfsTarStagingRequest\x1a+.openshell.v1.BeginRootfsTarStagingResponse\"!\x82\xb5\x18\x1d\n" + "\x06bearer\x12\x04user\"\rsandbox:write\x12n\n" + @@ -20455,7 +20357,10 @@ const file_openshell_proto_rawDesc = "" + "\x15RemoveWorkspaceMember\x12*.openshell.v1.RemoveWorkspaceMemberRequest\x1a+.openshell.v1.RemoveWorkspaceMemberResponse\"$\x82\xb5\x18 \n" + "\x06bearer\x12\x05admin\"\x0fworkspace:write\x12\x91\x01\n" + "\x14ListWorkspaceMembers\x12).openshell.v1.ListWorkspaceMembersRequest\x1a*.openshell.v1.ListWorkspaceMembersResponse\"\"\x82\xb5\x18\x1e\n" + - "\x06bearer\x12\x04user\"\x0eworkspace:readb\x06proto3" + "\x06bearer\x12\x04user\"\x0eworkspace:read2\x87\x01\n" + + "\x0eSandboxUpdates\x12u\n" + + "\rUpdateSandbox\x12\".openshell.v1.UpdateSandboxRequest\x1a\x1d.openshell.v1.SandboxResponse\"!\x82\xb5\x18\x1d\n" + + "\x06bearer\x12\x04user\"\rsandbox:writeb\x06proto3" var ( file_openshell_proto_rawDescOnce sync.Once @@ -20470,7 +20375,7 @@ func file_openshell_proto_rawDescGZIP() []byte { } var file_openshell_proto_enumTypes = make([]protoimpl.EnumInfo, 21) -var file_openshell_proto_msgTypes = make([]protoimpl.MessageInfo, 265) +var file_openshell_proto_msgTypes = make([]protoimpl.MessageInfo, 264) var file_openshell_proto_goTypes = []any{ (ExtensionKind)(0), // 0: openshell.v1.ExtensionKind (SandboxPhase)(0), // 1: openshell.v1.SandboxPhase @@ -20523,266 +20428,265 @@ var file_openshell_proto_goTypes = []any{ (*SandboxStartup)(nil), // 48: openshell.v1.SandboxStartup (*SandboxWorkloadTemplateProvenance)(nil), // 49: openshell.v1.SandboxWorkloadTemplateProvenance (*SandboxStatus)(nil), // 50: openshell.v1.SandboxStatus - (*SandboxImageUpdate)(nil), // 51: openshell.v1.SandboxImageUpdate - (*SandboxCondition)(nil), // 52: openshell.v1.SandboxCondition - (*PlatformEvent)(nil), // 53: openshell.v1.PlatformEvent - (*CreateSandboxRequest)(nil), // 54: openshell.v1.CreateSandboxRequest - (*UpdateSandboxRequest)(nil), // 55: openshell.v1.UpdateSandboxRequest - (*CreateSandboxTemplateRequest)(nil), // 56: openshell.v1.CreateSandboxTemplateRequest - (*GetSandboxTemplateRequest)(nil), // 57: openshell.v1.GetSandboxTemplateRequest - (*ListSandboxTemplatesRequest)(nil), // 58: openshell.v1.ListSandboxTemplatesRequest - (*DeleteSandboxTemplateRequest)(nil), // 59: openshell.v1.DeleteSandboxTemplateRequest - (*SandboxTemplateResponse)(nil), // 60: openshell.v1.SandboxTemplateResponse - (*ListSandboxTemplatesResponse)(nil), // 61: openshell.v1.ListSandboxTemplatesResponse - (*DeleteSandboxTemplateResponse)(nil), // 62: openshell.v1.DeleteSandboxTemplateResponse - (*BeginRootfsTarStagingRequest)(nil), // 63: openshell.v1.BeginRootfsTarStagingRequest - (*BeginRootfsTarStagingResponse)(nil), // 64: openshell.v1.BeginRootfsTarStagingResponse - (*GetSandboxRequest)(nil), // 65: openshell.v1.GetSandboxRequest - (*ListSandboxesRequest)(nil), // 66: openshell.v1.ListSandboxesRequest - (*ListSandboxProvidersRequest)(nil), // 67: openshell.v1.ListSandboxProvidersRequest - (*AttachSandboxProviderRequest)(nil), // 68: openshell.v1.AttachSandboxProviderRequest - (*DetachSandboxProviderRequest)(nil), // 69: openshell.v1.DetachSandboxProviderRequest - (*DeleteSandboxRequest)(nil), // 70: openshell.v1.DeleteSandboxRequest - (*StopSandboxRequest)(nil), // 71: openshell.v1.StopSandboxRequest - (*StartSandboxRequest)(nil), // 72: openshell.v1.StartSandboxRequest - (*SandboxResponse)(nil), // 73: openshell.v1.SandboxResponse - (*ListSandboxesResponse)(nil), // 74: openshell.v1.ListSandboxesResponse - (*ListSandboxProvidersResponse)(nil), // 75: openshell.v1.ListSandboxProvidersResponse - (*AttachSandboxProviderResponse)(nil), // 76: openshell.v1.AttachSandboxProviderResponse - (*DetachSandboxProviderResponse)(nil), // 77: openshell.v1.DetachSandboxProviderResponse - (*ProviderDesiredIdentity)(nil), // 78: openshell.v1.ProviderDesiredIdentity - (*ConfigSnapshotRevision)(nil), // 79: openshell.v1.ConfigSnapshotRevision - (*SandboxConfigRevision)(nil), // 80: openshell.v1.SandboxConfigRevision - (*ConfigUpdateOperation)(nil), // 81: openshell.v1.ConfigUpdateOperation - (*ProviderMutationReceipt)(nil), // 82: openshell.v1.ProviderMutationReceipt - (*ProviderReadinessObservation)(nil), // 83: openshell.v1.ProviderReadinessObservation - (*ProviderReadinessStatus)(nil), // 84: openshell.v1.ProviderReadinessStatus - (*GetSandboxProviderStatusRequest)(nil), // 85: openshell.v1.GetSandboxProviderStatusRequest - (*GetSandboxProviderStatusResponse)(nil), // 86: openshell.v1.GetSandboxProviderStatusResponse - (*ReportProviderReadinessRequest)(nil), // 87: openshell.v1.ReportProviderReadinessRequest - (*ReportProviderReadinessResponse)(nil), // 88: openshell.v1.ReportProviderReadinessResponse - (*DeleteSandboxResponse)(nil), // 89: openshell.v1.DeleteSandboxResponse - (*CreateSshSessionRequest)(nil), // 90: openshell.v1.CreateSshSessionRequest - (*CreateSshSessionResponse)(nil), // 91: openshell.v1.CreateSshSessionResponse - (*ExposeServiceRequest)(nil), // 92: openshell.v1.ExposeServiceRequest - (*GetServiceRequest)(nil), // 93: openshell.v1.GetServiceRequest - (*ListServicesRequest)(nil), // 94: openshell.v1.ListServicesRequest - (*ListServicesResponse)(nil), // 95: openshell.v1.ListServicesResponse - (*DeleteServiceRequest)(nil), // 96: openshell.v1.DeleteServiceRequest - (*DeleteServiceResponse)(nil), // 97: openshell.v1.DeleteServiceResponse - (*ServiceEndpoint)(nil), // 98: openshell.v1.ServiceEndpoint - (*ServiceEndpointResponse)(nil), // 99: openshell.v1.ServiceEndpointResponse - (*RevokeSshSessionRequest)(nil), // 100: openshell.v1.RevokeSshSessionRequest - (*RevokeSshSessionResponse)(nil), // 101: openshell.v1.RevokeSshSessionResponse - (*ExecSandboxRequest)(nil), // 102: openshell.v1.ExecSandboxRequest - (*ExecSandboxStdout)(nil), // 103: openshell.v1.ExecSandboxStdout - (*ExecSandboxStderr)(nil), // 104: openshell.v1.ExecSandboxStderr - (*ExecSandboxExit)(nil), // 105: openshell.v1.ExecSandboxExit - (*ExecSandboxEvent)(nil), // 106: openshell.v1.ExecSandboxEvent - (*TcpForwardInit)(nil), // 107: openshell.v1.TcpForwardInit - (*TcpForwardFrame)(nil), // 108: openshell.v1.TcpForwardFrame - (*ExecSandboxInput)(nil), // 109: openshell.v1.ExecSandboxInput - (*ExecSandboxWindowResize)(nil), // 110: openshell.v1.ExecSandboxWindowResize - (*SshSession)(nil), // 111: openshell.v1.SshSession - (*WatchSandboxRequest)(nil), // 112: openshell.v1.WatchSandboxRequest - (*SandboxStreamEvent)(nil), // 113: openshell.v1.SandboxStreamEvent - (*SandboxLogLine)(nil), // 114: openshell.v1.SandboxLogLine - (*SandboxStreamWarning)(nil), // 115: openshell.v1.SandboxStreamWarning - (*CreateProviderRequest)(nil), // 116: openshell.v1.CreateProviderRequest - (*GetProviderRequest)(nil), // 117: openshell.v1.GetProviderRequest - (*GetProviderCredentialsRequest)(nil), // 118: openshell.v1.GetProviderCredentialsRequest - (*ProviderCredentialValue)(nil), // 119: openshell.v1.ProviderCredentialValue - (*GetProviderCredentialsResponse)(nil), // 120: openshell.v1.GetProviderCredentialsResponse - (*ListProvidersRequest)(nil), // 121: openshell.v1.ListProvidersRequest - (*UpdateProviderRequest)(nil), // 122: openshell.v1.UpdateProviderRequest - (*DeleteProviderRequest)(nil), // 123: openshell.v1.DeleteProviderRequest - (*ProviderResponse)(nil), // 124: openshell.v1.ProviderResponse - (*ListProvidersResponse)(nil), // 125: openshell.v1.ListProvidersResponse - (*ListProviderProfilesRequest)(nil), // 126: openshell.v1.ListProviderProfilesRequest - (*GetProviderProfileRequest)(nil), // 127: openshell.v1.GetProviderProfileRequest - (*ProviderProfileImportItem)(nil), // 128: openshell.v1.ProviderProfileImportItem - (*ProviderProfileDiagnostic)(nil), // 129: openshell.v1.ProviderProfileDiagnostic - (*ProviderCredentialTokenGrantAudienceOverride)(nil), // 130: openshell.v1.ProviderCredentialTokenGrantAudienceOverride - (*ProviderCredentialTokenGrantSubjectToken)(nil), // 131: openshell.v1.ProviderCredentialTokenGrantSubjectToken - (*ProviderCredentialTokenGrant)(nil), // 132: openshell.v1.ProviderCredentialTokenGrant - (*ProviderProfileCredential)(nil), // 133: openshell.v1.ProviderProfileCredential - (*ProviderCredentialRefreshMaterial)(nil), // 134: openshell.v1.ProviderCredentialRefreshMaterial - (*ProviderCredentialRefreshOutput)(nil), // 135: openshell.v1.ProviderCredentialRefreshOutput - (*ProviderCredentialRefresh)(nil), // 136: openshell.v1.ProviderCredentialRefresh - (*ProviderCredentialRefreshStatus)(nil), // 137: openshell.v1.ProviderCredentialRefreshStatus - (*ProviderProfileDiscovery)(nil), // 138: openshell.v1.ProviderProfileDiscovery - (*GetProviderRefreshStatusRequest)(nil), // 139: openshell.v1.GetProviderRefreshStatusRequest - (*GetProviderRefreshStatusResponse)(nil), // 140: openshell.v1.GetProviderRefreshStatusResponse - (*ConfigureProviderRefreshRequest)(nil), // 141: openshell.v1.ConfigureProviderRefreshRequest - (*ConfigureProviderRefreshResponse)(nil), // 142: openshell.v1.ConfigureProviderRefreshResponse - (*RotateProviderCredentialRequest)(nil), // 143: openshell.v1.RotateProviderCredentialRequest - (*RotateProviderCredentialResponse)(nil), // 144: openshell.v1.RotateProviderCredentialResponse - (*DeleteProviderRefreshRequest)(nil), // 145: openshell.v1.DeleteProviderRefreshRequest - (*DeleteProviderRefreshResponse)(nil), // 146: openshell.v1.DeleteProviderRefreshResponse - (*ProviderProfile)(nil), // 147: openshell.v1.ProviderProfile - (*ProviderProfileFile)(nil), // 148: openshell.v1.ProviderProfileFile - (*ProviderProfileResponse)(nil), // 149: openshell.v1.ProviderProfileResponse - (*ListProviderProfilesResponse)(nil), // 150: openshell.v1.ListProviderProfilesResponse - (*ImportProviderProfilesRequest)(nil), // 151: openshell.v1.ImportProviderProfilesRequest - (*ImportProviderProfilesResponse)(nil), // 152: openshell.v1.ImportProviderProfilesResponse - (*UpdateProviderProfilesRequest)(nil), // 153: openshell.v1.UpdateProviderProfilesRequest - (*UpdateProviderProfilesResponse)(nil), // 154: openshell.v1.UpdateProviderProfilesResponse - (*LintProviderProfilesRequest)(nil), // 155: openshell.v1.LintProviderProfilesRequest - (*LintProviderProfilesResponse)(nil), // 156: openshell.v1.LintProviderProfilesResponse - (*DeleteProviderResponse)(nil), // 157: openshell.v1.DeleteProviderResponse - (*DeleteProviderProfileRequest)(nil), // 158: openshell.v1.DeleteProviderProfileRequest - (*DeleteProviderProfileResponse)(nil), // 159: openshell.v1.DeleteProviderProfileResponse - (*GetSandboxProviderEnvironmentRequest)(nil), // 160: openshell.v1.GetSandboxProviderEnvironmentRequest - (*StaticCredentialEndpointBinding)(nil), // 161: openshell.v1.StaticCredentialEndpointBinding - (*StaticCredentialBinding)(nil), // 162: openshell.v1.StaticCredentialBinding - (*GetSandboxProviderEnvironmentResponse)(nil), // 163: openshell.v1.GetSandboxProviderEnvironmentResponse - (*ExchangeProviderSubjectTokenRequest)(nil), // 164: openshell.v1.ExchangeProviderSubjectTokenRequest - (*ExchangeProviderSubjectTokenResponse)(nil), // 165: openshell.v1.ExchangeProviderSubjectTokenResponse - (*UpdateConfigRequest)(nil), // 166: openshell.v1.UpdateConfigRequest - (*PolicyMergeOperation)(nil), // 167: openshell.v1.PolicyMergeOperation - (*AddNetworkRule)(nil), // 168: openshell.v1.AddNetworkRule - (*RemoveNetworkEndpoint)(nil), // 169: openshell.v1.RemoveNetworkEndpoint - (*RemoveNetworkRule)(nil), // 170: openshell.v1.RemoveNetworkRule - (*L7RuleTarget)(nil), // 171: openshell.v1.L7RuleTarget - (*AddDenyRules)(nil), // 172: openshell.v1.AddDenyRules - (*AddAllowRules)(nil), // 173: openshell.v1.AddAllowRules - (*RemoveNetworkBinary)(nil), // 174: openshell.v1.RemoveNetworkBinary - (*UpdateConfigResponse)(nil), // 175: openshell.v1.UpdateConfigResponse - (*GetSandboxPolicyStatusRequest)(nil), // 176: openshell.v1.GetSandboxPolicyStatusRequest - (*GetSandboxPolicyStatusResponse)(nil), // 177: openshell.v1.GetSandboxPolicyStatusResponse - (*ListSandboxPoliciesRequest)(nil), // 178: openshell.v1.ListSandboxPoliciesRequest - (*ListSandboxPoliciesResponse)(nil), // 179: openshell.v1.ListSandboxPoliciesResponse - (*ReportPolicyStatusRequest)(nil), // 180: openshell.v1.ReportPolicyStatusRequest - (*ReportPolicyStatusResponse)(nil), // 181: openshell.v1.ReportPolicyStatusResponse - (*SandboxConfigurationAdmission)(nil), // 182: openshell.v1.SandboxConfigurationAdmission - (*ReportSandboxConfigurationRequest)(nil), // 183: openshell.v1.ReportSandboxConfigurationRequest - (*ReportSandboxConfigurationResponse)(nil), // 184: openshell.v1.ReportSandboxConfigurationResponse - (*SandboxPolicyRevision)(nil), // 185: openshell.v1.SandboxPolicyRevision - (*GetSandboxLogsRequest)(nil), // 186: openshell.v1.GetSandboxLogsRequest - (*PushSandboxLogsRequest)(nil), // 187: openshell.v1.PushSandboxLogsRequest - (*PushSandboxLogsResponse)(nil), // 188: openshell.v1.PushSandboxLogsResponse - (*GetSandboxLogsResponse)(nil), // 189: openshell.v1.GetSandboxLogsResponse - (*SupervisorMessage)(nil), // 190: openshell.v1.SupervisorMessage - (*GatewayMessage)(nil), // 191: openshell.v1.GatewayMessage - (*SupervisorHello)(nil), // 192: openshell.v1.SupervisorHello - (*SessionAccepted)(nil), // 193: openshell.v1.SessionAccepted - (*SessionRejected)(nil), // 194: openshell.v1.SessionRejected - (*SessionRedirect)(nil), // 195: openshell.v1.SessionRedirect - (*SupervisorHeartbeat)(nil), // 196: openshell.v1.SupervisorHeartbeat - (*GatewayHeartbeat)(nil), // 197: openshell.v1.GatewayHeartbeat - (*ReportMainProcessExitRequest)(nil), // 198: openshell.v1.ReportMainProcessExitRequest - (*ReportMainProcessExitResponse)(nil), // 199: openshell.v1.ReportMainProcessExitResponse - (*FinalizeMainProcessExitRequest)(nil), // 200: openshell.v1.FinalizeMainProcessExitRequest - (*FinalizeMainProcessExitResponse)(nil), // 201: openshell.v1.FinalizeMainProcessExitResponse - (*RelayOpen)(nil), // 202: openshell.v1.RelayOpen - (*SshRelayTarget)(nil), // 203: openshell.v1.SshRelayTarget - (*TcpRelayTarget)(nil), // 204: openshell.v1.TcpRelayTarget - (*RelayInit)(nil), // 205: openshell.v1.RelayInit - (*RelayFrame)(nil), // 206: openshell.v1.RelayFrame - (*PeerRelayInit)(nil), // 207: openshell.v1.PeerRelayInit - (*PeerRelayFrame)(nil), // 208: openshell.v1.PeerRelayFrame - (*RelayOpenResult)(nil), // 209: openshell.v1.RelayOpenResult - (*RelayClose)(nil), // 210: openshell.v1.RelayClose - (*L7RequestSample)(nil), // 211: openshell.v1.L7RequestSample - (*DenialSummary)(nil), // 212: openshell.v1.DenialSummary - (*DenialGroupCount)(nil), // 213: openshell.v1.DenialGroupCount - (*NetworkActivitySummary)(nil), // 214: openshell.v1.NetworkActivitySummary - (*PolicyChunk)(nil), // 215: openshell.v1.PolicyChunk - (*DraftPolicyUpdate)(nil), // 216: openshell.v1.DraftPolicyUpdate - (*SubmitPolicyAnalysisRequest)(nil), // 217: openshell.v1.SubmitPolicyAnalysisRequest - (*SubmitPolicyAnalysisResponse)(nil), // 218: openshell.v1.SubmitPolicyAnalysisResponse - (*GetDraftPolicyRequest)(nil), // 219: openshell.v1.GetDraftPolicyRequest - (*GetDraftPolicyResponse)(nil), // 220: openshell.v1.GetDraftPolicyResponse - (*ApproveDraftChunkRequest)(nil), // 221: openshell.v1.ApproveDraftChunkRequest - (*ApproveDraftChunkResponse)(nil), // 222: openshell.v1.ApproveDraftChunkResponse - (*RejectDraftChunkRequest)(nil), // 223: openshell.v1.RejectDraftChunkRequest - (*RejectDraftChunkResponse)(nil), // 224: openshell.v1.RejectDraftChunkResponse - (*DraftChunkApproval)(nil), // 225: openshell.v1.DraftChunkApproval - (*ApproveAllDraftChunksRequest)(nil), // 226: openshell.v1.ApproveAllDraftChunksRequest - (*ApproveAllDraftChunksResponse)(nil), // 227: openshell.v1.ApproveAllDraftChunksResponse - (*EditDraftChunkRequest)(nil), // 228: openshell.v1.EditDraftChunkRequest - (*EditDraftChunkResponse)(nil), // 229: openshell.v1.EditDraftChunkResponse - (*UndoDraftChunkRequest)(nil), // 230: openshell.v1.UndoDraftChunkRequest - (*UndoDraftChunkResponse)(nil), // 231: openshell.v1.UndoDraftChunkResponse - (*ClearDraftChunksRequest)(nil), // 232: openshell.v1.ClearDraftChunksRequest - (*ClearDraftChunksResponse)(nil), // 233: openshell.v1.ClearDraftChunksResponse - (*GetDraftHistoryRequest)(nil), // 234: openshell.v1.GetDraftHistoryRequest - (*DraftHistoryEntry)(nil), // 235: openshell.v1.DraftHistoryEntry - (*GetDraftHistoryResponse)(nil), // 236: openshell.v1.GetDraftHistoryResponse - (*CreateWorkspaceRequest)(nil), // 237: openshell.v1.CreateWorkspaceRequest - (*CreateWorkspaceResponse)(nil), // 238: openshell.v1.CreateWorkspaceResponse - (*GetWorkspaceRequest)(nil), // 239: openshell.v1.GetWorkspaceRequest - (*GetWorkspaceResponse)(nil), // 240: openshell.v1.GetWorkspaceResponse - (*ListWorkspacesRequest)(nil), // 241: openshell.v1.ListWorkspacesRequest - (*ListWorkspacesResponse)(nil), // 242: openshell.v1.ListWorkspacesResponse - (*DeleteWorkspaceRequest)(nil), // 243: openshell.v1.DeleteWorkspaceRequest - (*DeleteWorkspaceResponse)(nil), // 244: openshell.v1.DeleteWorkspaceResponse - (*WorkspaceMember)(nil), // 245: openshell.v1.WorkspaceMember - (*AddWorkspaceMemberRequest)(nil), // 246: openshell.v1.AddWorkspaceMemberRequest - (*AddWorkspaceMemberResponse)(nil), // 247: openshell.v1.AddWorkspaceMemberResponse - (*RemoveWorkspaceMemberRequest)(nil), // 248: openshell.v1.RemoveWorkspaceMemberRequest - (*RemoveWorkspaceMemberResponse)(nil), // 249: openshell.v1.RemoveWorkspaceMemberResponse - (*ListWorkspaceMembersRequest)(nil), // 250: openshell.v1.ListWorkspaceMembersRequest - (*ListWorkspaceMembersResponse)(nil), // 251: openshell.v1.ListWorkspaceMembersResponse - (*ExtensionServiceCredential)(nil), // 252: openshell.v1.ExtensionServiceCredential - (*EndpointObservation)(nil), // 253: openshell.v1.EndpointObservation - (*ReportEndpointStatusRequest)(nil), // 254: openshell.v1.ReportEndpointStatusRequest - (*TokenGrantStatus)(nil), // 255: openshell.v1.TokenGrantStatus - (*TokenGrantFailureObservation)(nil), // 256: openshell.v1.TokenGrantFailureObservation - (*ReportEndpointStatusResponse)(nil), // 257: openshell.v1.ReportEndpointStatusResponse - (*EndpointStatus)(nil), // 258: openshell.v1.EndpointStatus - (*SandboxProvisioning)(nil), // 259: openshell.v1.SandboxProvisioning - (*SandboxServiceExposure)(nil), // 260: openshell.v1.SandboxServiceExposure - (*EndpointFailure)(nil), // 261: openshell.v1.EndpointFailure - nil, // 262: openshell.v1.SandboxSpec.EnvironmentEntry - nil, // 263: openshell.v1.SandboxTemplate.LabelsEntry - nil, // 264: openshell.v1.SandboxTemplate.AnnotationsEntry - nil, // 265: openshell.v1.SandboxTemplate.EnvironmentEntry - nil, // 266: openshell.v1.SandboxWorkloadConfig.EnvironmentEntry - nil, // 267: openshell.v1.PlatformEvent.MetadataEntry - nil, // 268: openshell.v1.CreateSandboxRequest.LabelsEntry - nil, // 269: openshell.v1.CreateSandboxRequest.AnnotationsEntry - nil, // 270: openshell.v1.SandboxResponse.ServiceUrlsEntry - nil, // 271: openshell.v1.ExecSandboxRequest.EnvironmentEntry - nil, // 272: openshell.v1.SandboxLogLine.FieldsEntry - nil, // 273: openshell.v1.GetProviderCredentialsResponse.CredentialsEntry - nil, // 274: openshell.v1.UpdateProviderRequest.CredentialExpirationTimesEntry - nil, // 275: openshell.v1.ConfigureProviderRefreshRequest.MaterialEntry - nil, // 276: openshell.v1.ProviderProfile.AnnotationsEntry - nil, // 277: openshell.v1.GetSandboxProviderEnvironmentResponse.EnvironmentEntry - nil, // 278: openshell.v1.GetSandboxProviderEnvironmentResponse.CredentialExpirationTimesEntry - nil, // 279: openshell.v1.GetSandboxProviderEnvironmentResponse.DynamicCredentialsEntry - nil, // 280: openshell.v1.GetSandboxProviderEnvironmentResponse.StaticCredentialBindingsEntry - nil, // 281: openshell.v1.GetSandboxProviderEnvironmentResponse.FilesEntry - nil, // 282: openshell.v1.UpdateConfigRequest.AnnotationsEntry - nil, // 283: openshell.v1.UpdateConfigResponse.AnnotationsEntry - nil, // 284: openshell.v1.SandboxPolicyRevision.ProvenanceEntry - nil, // 285: openshell.v1.CreateWorkspaceRequest.LabelsEntry - (*timestamppb.Timestamp)(nil), // 286: google.protobuf.Timestamp - (*datamodelv1.ObjectMeta)(nil), // 287: openshell.datamodel.v1.ObjectMeta - (*sandboxv1.SandboxPolicy)(nil), // 288: openshell.sandbox.v1.SandboxPolicy - (*structpb.Struct)(nil), // 289: google.protobuf.Struct - (*durationpb.Duration)(nil), // 290: google.protobuf.Duration - (*datamodelv1.WorkspaceSelector)(nil), // 291: openshell.datamodel.v1.WorkspaceSelector - (*datamodelv1.Provider)(nil), // 292: openshell.datamodel.v1.Provider - (sandboxv1.PolicySource)(0), // 293: openshell.sandbox.v1.PolicySource - (*sandboxv1.NetworkEndpoint)(nil), // 294: openshell.sandbox.v1.NetworkEndpoint - (*sandboxv1.NetworkBinary)(nil), // 295: openshell.sandbox.v1.NetworkBinary - (*sandboxv1.SettingValue)(nil), // 296: openshell.sandbox.v1.SettingValue - (*sandboxv1.NetworkPolicyRule)(nil), // 297: openshell.sandbox.v1.NetworkPolicyRule - (*sandboxv1.L7DenyRule)(nil), // 298: openshell.sandbox.v1.L7DenyRule - (*sandboxv1.L7Rule)(nil), // 299: openshell.sandbox.v1.L7Rule - (*datamodelv1.Workspace)(nil), // 300: openshell.datamodel.v1.Workspace - (*sandboxv1.GetSandboxConfigRequest)(nil), // 301: openshell.sandbox.v1.GetSandboxConfigRequest - (*sandboxv1.GetGatewayConfigRequest)(nil), // 302: openshell.sandbox.v1.GetGatewayConfigRequest - (*sandboxv1.GetSandboxConfigResponse)(nil), // 303: openshell.sandbox.v1.GetSandboxConfigResponse - (*sandboxv1.GetGatewayConfigResponse)(nil), // 304: openshell.sandbox.v1.GetGatewayConfigResponse + (*SandboxCondition)(nil), // 51: openshell.v1.SandboxCondition + (*PlatformEvent)(nil), // 52: openshell.v1.PlatformEvent + (*CreateSandboxRequest)(nil), // 53: openshell.v1.CreateSandboxRequest + (*UpdateSandboxRequest)(nil), // 54: openshell.v1.UpdateSandboxRequest + (*CreateSandboxTemplateRequest)(nil), // 55: openshell.v1.CreateSandboxTemplateRequest + (*GetSandboxTemplateRequest)(nil), // 56: openshell.v1.GetSandboxTemplateRequest + (*ListSandboxTemplatesRequest)(nil), // 57: openshell.v1.ListSandboxTemplatesRequest + (*DeleteSandboxTemplateRequest)(nil), // 58: openshell.v1.DeleteSandboxTemplateRequest + (*SandboxTemplateResponse)(nil), // 59: openshell.v1.SandboxTemplateResponse + (*ListSandboxTemplatesResponse)(nil), // 60: openshell.v1.ListSandboxTemplatesResponse + (*DeleteSandboxTemplateResponse)(nil), // 61: openshell.v1.DeleteSandboxTemplateResponse + (*BeginRootfsTarStagingRequest)(nil), // 62: openshell.v1.BeginRootfsTarStagingRequest + (*BeginRootfsTarStagingResponse)(nil), // 63: openshell.v1.BeginRootfsTarStagingResponse + (*GetSandboxRequest)(nil), // 64: openshell.v1.GetSandboxRequest + (*ListSandboxesRequest)(nil), // 65: openshell.v1.ListSandboxesRequest + (*ListSandboxProvidersRequest)(nil), // 66: openshell.v1.ListSandboxProvidersRequest + (*AttachSandboxProviderRequest)(nil), // 67: openshell.v1.AttachSandboxProviderRequest + (*DetachSandboxProviderRequest)(nil), // 68: openshell.v1.DetachSandboxProviderRequest + (*DeleteSandboxRequest)(nil), // 69: openshell.v1.DeleteSandboxRequest + (*StopSandboxRequest)(nil), // 70: openshell.v1.StopSandboxRequest + (*StartSandboxRequest)(nil), // 71: openshell.v1.StartSandboxRequest + (*SandboxResponse)(nil), // 72: openshell.v1.SandboxResponse + (*ListSandboxesResponse)(nil), // 73: openshell.v1.ListSandboxesResponse + (*ListSandboxProvidersResponse)(nil), // 74: openshell.v1.ListSandboxProvidersResponse + (*AttachSandboxProviderResponse)(nil), // 75: openshell.v1.AttachSandboxProviderResponse + (*DetachSandboxProviderResponse)(nil), // 76: openshell.v1.DetachSandboxProviderResponse + (*ProviderDesiredIdentity)(nil), // 77: openshell.v1.ProviderDesiredIdentity + (*ConfigSnapshotRevision)(nil), // 78: openshell.v1.ConfigSnapshotRevision + (*SandboxConfigRevision)(nil), // 79: openshell.v1.SandboxConfigRevision + (*ConfigUpdateOperation)(nil), // 80: openshell.v1.ConfigUpdateOperation + (*ProviderMutationReceipt)(nil), // 81: openshell.v1.ProviderMutationReceipt + (*ProviderReadinessObservation)(nil), // 82: openshell.v1.ProviderReadinessObservation + (*ProviderReadinessStatus)(nil), // 83: openshell.v1.ProviderReadinessStatus + (*GetSandboxProviderStatusRequest)(nil), // 84: openshell.v1.GetSandboxProviderStatusRequest + (*GetSandboxProviderStatusResponse)(nil), // 85: openshell.v1.GetSandboxProviderStatusResponse + (*ReportProviderReadinessRequest)(nil), // 86: openshell.v1.ReportProviderReadinessRequest + (*ReportProviderReadinessResponse)(nil), // 87: openshell.v1.ReportProviderReadinessResponse + (*DeleteSandboxResponse)(nil), // 88: openshell.v1.DeleteSandboxResponse + (*CreateSshSessionRequest)(nil), // 89: openshell.v1.CreateSshSessionRequest + (*CreateSshSessionResponse)(nil), // 90: openshell.v1.CreateSshSessionResponse + (*ExposeServiceRequest)(nil), // 91: openshell.v1.ExposeServiceRequest + (*GetServiceRequest)(nil), // 92: openshell.v1.GetServiceRequest + (*ListServicesRequest)(nil), // 93: openshell.v1.ListServicesRequest + (*ListServicesResponse)(nil), // 94: openshell.v1.ListServicesResponse + (*DeleteServiceRequest)(nil), // 95: openshell.v1.DeleteServiceRequest + (*DeleteServiceResponse)(nil), // 96: openshell.v1.DeleteServiceResponse + (*ServiceEndpoint)(nil), // 97: openshell.v1.ServiceEndpoint + (*ServiceEndpointResponse)(nil), // 98: openshell.v1.ServiceEndpointResponse + (*RevokeSshSessionRequest)(nil), // 99: openshell.v1.RevokeSshSessionRequest + (*RevokeSshSessionResponse)(nil), // 100: openshell.v1.RevokeSshSessionResponse + (*ExecSandboxRequest)(nil), // 101: openshell.v1.ExecSandboxRequest + (*ExecSandboxStdout)(nil), // 102: openshell.v1.ExecSandboxStdout + (*ExecSandboxStderr)(nil), // 103: openshell.v1.ExecSandboxStderr + (*ExecSandboxExit)(nil), // 104: openshell.v1.ExecSandboxExit + (*ExecSandboxEvent)(nil), // 105: openshell.v1.ExecSandboxEvent + (*TcpForwardInit)(nil), // 106: openshell.v1.TcpForwardInit + (*TcpForwardFrame)(nil), // 107: openshell.v1.TcpForwardFrame + (*ExecSandboxInput)(nil), // 108: openshell.v1.ExecSandboxInput + (*ExecSandboxWindowResize)(nil), // 109: openshell.v1.ExecSandboxWindowResize + (*SshSession)(nil), // 110: openshell.v1.SshSession + (*WatchSandboxRequest)(nil), // 111: openshell.v1.WatchSandboxRequest + (*SandboxStreamEvent)(nil), // 112: openshell.v1.SandboxStreamEvent + (*SandboxLogLine)(nil), // 113: openshell.v1.SandboxLogLine + (*SandboxStreamWarning)(nil), // 114: openshell.v1.SandboxStreamWarning + (*CreateProviderRequest)(nil), // 115: openshell.v1.CreateProviderRequest + (*GetProviderRequest)(nil), // 116: openshell.v1.GetProviderRequest + (*GetProviderCredentialsRequest)(nil), // 117: openshell.v1.GetProviderCredentialsRequest + (*ProviderCredentialValue)(nil), // 118: openshell.v1.ProviderCredentialValue + (*GetProviderCredentialsResponse)(nil), // 119: openshell.v1.GetProviderCredentialsResponse + (*ListProvidersRequest)(nil), // 120: openshell.v1.ListProvidersRequest + (*UpdateProviderRequest)(nil), // 121: openshell.v1.UpdateProviderRequest + (*DeleteProviderRequest)(nil), // 122: openshell.v1.DeleteProviderRequest + (*ProviderResponse)(nil), // 123: openshell.v1.ProviderResponse + (*ListProvidersResponse)(nil), // 124: openshell.v1.ListProvidersResponse + (*ListProviderProfilesRequest)(nil), // 125: openshell.v1.ListProviderProfilesRequest + (*GetProviderProfileRequest)(nil), // 126: openshell.v1.GetProviderProfileRequest + (*ProviderProfileImportItem)(nil), // 127: openshell.v1.ProviderProfileImportItem + (*ProviderProfileDiagnostic)(nil), // 128: openshell.v1.ProviderProfileDiagnostic + (*ProviderCredentialTokenGrantAudienceOverride)(nil), // 129: openshell.v1.ProviderCredentialTokenGrantAudienceOverride + (*ProviderCredentialTokenGrantSubjectToken)(nil), // 130: openshell.v1.ProviderCredentialTokenGrantSubjectToken + (*ProviderCredentialTokenGrant)(nil), // 131: openshell.v1.ProviderCredentialTokenGrant + (*ProviderProfileCredential)(nil), // 132: openshell.v1.ProviderProfileCredential + (*ProviderCredentialRefreshMaterial)(nil), // 133: openshell.v1.ProviderCredentialRefreshMaterial + (*ProviderCredentialRefreshOutput)(nil), // 134: openshell.v1.ProviderCredentialRefreshOutput + (*ProviderCredentialRefresh)(nil), // 135: openshell.v1.ProviderCredentialRefresh + (*ProviderCredentialRefreshStatus)(nil), // 136: openshell.v1.ProviderCredentialRefreshStatus + (*ProviderProfileDiscovery)(nil), // 137: openshell.v1.ProviderProfileDiscovery + (*GetProviderRefreshStatusRequest)(nil), // 138: openshell.v1.GetProviderRefreshStatusRequest + (*GetProviderRefreshStatusResponse)(nil), // 139: openshell.v1.GetProviderRefreshStatusResponse + (*ConfigureProviderRefreshRequest)(nil), // 140: openshell.v1.ConfigureProviderRefreshRequest + (*ConfigureProviderRefreshResponse)(nil), // 141: openshell.v1.ConfigureProviderRefreshResponse + (*RotateProviderCredentialRequest)(nil), // 142: openshell.v1.RotateProviderCredentialRequest + (*RotateProviderCredentialResponse)(nil), // 143: openshell.v1.RotateProviderCredentialResponse + (*DeleteProviderRefreshRequest)(nil), // 144: openshell.v1.DeleteProviderRefreshRequest + (*DeleteProviderRefreshResponse)(nil), // 145: openshell.v1.DeleteProviderRefreshResponse + (*ProviderProfile)(nil), // 146: openshell.v1.ProviderProfile + (*ProviderProfileFile)(nil), // 147: openshell.v1.ProviderProfileFile + (*ProviderProfileResponse)(nil), // 148: openshell.v1.ProviderProfileResponse + (*ListProviderProfilesResponse)(nil), // 149: openshell.v1.ListProviderProfilesResponse + (*ImportProviderProfilesRequest)(nil), // 150: openshell.v1.ImportProviderProfilesRequest + (*ImportProviderProfilesResponse)(nil), // 151: openshell.v1.ImportProviderProfilesResponse + (*UpdateProviderProfilesRequest)(nil), // 152: openshell.v1.UpdateProviderProfilesRequest + (*UpdateProviderProfilesResponse)(nil), // 153: openshell.v1.UpdateProviderProfilesResponse + (*LintProviderProfilesRequest)(nil), // 154: openshell.v1.LintProviderProfilesRequest + (*LintProviderProfilesResponse)(nil), // 155: openshell.v1.LintProviderProfilesResponse + (*DeleteProviderResponse)(nil), // 156: openshell.v1.DeleteProviderResponse + (*DeleteProviderProfileRequest)(nil), // 157: openshell.v1.DeleteProviderProfileRequest + (*DeleteProviderProfileResponse)(nil), // 158: openshell.v1.DeleteProviderProfileResponse + (*GetSandboxProviderEnvironmentRequest)(nil), // 159: openshell.v1.GetSandboxProviderEnvironmentRequest + (*StaticCredentialEndpointBinding)(nil), // 160: openshell.v1.StaticCredentialEndpointBinding + (*StaticCredentialBinding)(nil), // 161: openshell.v1.StaticCredentialBinding + (*GetSandboxProviderEnvironmentResponse)(nil), // 162: openshell.v1.GetSandboxProviderEnvironmentResponse + (*ExchangeProviderSubjectTokenRequest)(nil), // 163: openshell.v1.ExchangeProviderSubjectTokenRequest + (*ExchangeProviderSubjectTokenResponse)(nil), // 164: openshell.v1.ExchangeProviderSubjectTokenResponse + (*UpdateConfigRequest)(nil), // 165: openshell.v1.UpdateConfigRequest + (*PolicyMergeOperation)(nil), // 166: openshell.v1.PolicyMergeOperation + (*AddNetworkRule)(nil), // 167: openshell.v1.AddNetworkRule + (*RemoveNetworkEndpoint)(nil), // 168: openshell.v1.RemoveNetworkEndpoint + (*RemoveNetworkRule)(nil), // 169: openshell.v1.RemoveNetworkRule + (*L7RuleTarget)(nil), // 170: openshell.v1.L7RuleTarget + (*AddDenyRules)(nil), // 171: openshell.v1.AddDenyRules + (*AddAllowRules)(nil), // 172: openshell.v1.AddAllowRules + (*RemoveNetworkBinary)(nil), // 173: openshell.v1.RemoveNetworkBinary + (*UpdateConfigResponse)(nil), // 174: openshell.v1.UpdateConfigResponse + (*GetSandboxPolicyStatusRequest)(nil), // 175: openshell.v1.GetSandboxPolicyStatusRequest + (*GetSandboxPolicyStatusResponse)(nil), // 176: openshell.v1.GetSandboxPolicyStatusResponse + (*ListSandboxPoliciesRequest)(nil), // 177: openshell.v1.ListSandboxPoliciesRequest + (*ListSandboxPoliciesResponse)(nil), // 178: openshell.v1.ListSandboxPoliciesResponse + (*ReportPolicyStatusRequest)(nil), // 179: openshell.v1.ReportPolicyStatusRequest + (*ReportPolicyStatusResponse)(nil), // 180: openshell.v1.ReportPolicyStatusResponse + (*SandboxConfigurationAdmission)(nil), // 181: openshell.v1.SandboxConfigurationAdmission + (*ReportSandboxConfigurationRequest)(nil), // 182: openshell.v1.ReportSandboxConfigurationRequest + (*ReportSandboxConfigurationResponse)(nil), // 183: openshell.v1.ReportSandboxConfigurationResponse + (*SandboxPolicyRevision)(nil), // 184: openshell.v1.SandboxPolicyRevision + (*GetSandboxLogsRequest)(nil), // 185: openshell.v1.GetSandboxLogsRequest + (*PushSandboxLogsRequest)(nil), // 186: openshell.v1.PushSandboxLogsRequest + (*PushSandboxLogsResponse)(nil), // 187: openshell.v1.PushSandboxLogsResponse + (*GetSandboxLogsResponse)(nil), // 188: openshell.v1.GetSandboxLogsResponse + (*SupervisorMessage)(nil), // 189: openshell.v1.SupervisorMessage + (*GatewayMessage)(nil), // 190: openshell.v1.GatewayMessage + (*SupervisorHello)(nil), // 191: openshell.v1.SupervisorHello + (*SessionAccepted)(nil), // 192: openshell.v1.SessionAccepted + (*SessionRejected)(nil), // 193: openshell.v1.SessionRejected + (*SessionRedirect)(nil), // 194: openshell.v1.SessionRedirect + (*SupervisorHeartbeat)(nil), // 195: openshell.v1.SupervisorHeartbeat + (*GatewayHeartbeat)(nil), // 196: openshell.v1.GatewayHeartbeat + (*ReportMainProcessExitRequest)(nil), // 197: openshell.v1.ReportMainProcessExitRequest + (*ReportMainProcessExitResponse)(nil), // 198: openshell.v1.ReportMainProcessExitResponse + (*FinalizeMainProcessExitRequest)(nil), // 199: openshell.v1.FinalizeMainProcessExitRequest + (*FinalizeMainProcessExitResponse)(nil), // 200: openshell.v1.FinalizeMainProcessExitResponse + (*RelayOpen)(nil), // 201: openshell.v1.RelayOpen + (*SshRelayTarget)(nil), // 202: openshell.v1.SshRelayTarget + (*TcpRelayTarget)(nil), // 203: openshell.v1.TcpRelayTarget + (*RelayInit)(nil), // 204: openshell.v1.RelayInit + (*RelayFrame)(nil), // 205: openshell.v1.RelayFrame + (*PeerRelayInit)(nil), // 206: openshell.v1.PeerRelayInit + (*PeerRelayFrame)(nil), // 207: openshell.v1.PeerRelayFrame + (*RelayOpenResult)(nil), // 208: openshell.v1.RelayOpenResult + (*RelayClose)(nil), // 209: openshell.v1.RelayClose + (*L7RequestSample)(nil), // 210: openshell.v1.L7RequestSample + (*DenialSummary)(nil), // 211: openshell.v1.DenialSummary + (*DenialGroupCount)(nil), // 212: openshell.v1.DenialGroupCount + (*NetworkActivitySummary)(nil), // 213: openshell.v1.NetworkActivitySummary + (*PolicyChunk)(nil), // 214: openshell.v1.PolicyChunk + (*DraftPolicyUpdate)(nil), // 215: openshell.v1.DraftPolicyUpdate + (*SubmitPolicyAnalysisRequest)(nil), // 216: openshell.v1.SubmitPolicyAnalysisRequest + (*SubmitPolicyAnalysisResponse)(nil), // 217: openshell.v1.SubmitPolicyAnalysisResponse + (*GetDraftPolicyRequest)(nil), // 218: openshell.v1.GetDraftPolicyRequest + (*GetDraftPolicyResponse)(nil), // 219: openshell.v1.GetDraftPolicyResponse + (*ApproveDraftChunkRequest)(nil), // 220: openshell.v1.ApproveDraftChunkRequest + (*ApproveDraftChunkResponse)(nil), // 221: openshell.v1.ApproveDraftChunkResponse + (*RejectDraftChunkRequest)(nil), // 222: openshell.v1.RejectDraftChunkRequest + (*RejectDraftChunkResponse)(nil), // 223: openshell.v1.RejectDraftChunkResponse + (*DraftChunkApproval)(nil), // 224: openshell.v1.DraftChunkApproval + (*ApproveAllDraftChunksRequest)(nil), // 225: openshell.v1.ApproveAllDraftChunksRequest + (*ApproveAllDraftChunksResponse)(nil), // 226: openshell.v1.ApproveAllDraftChunksResponse + (*EditDraftChunkRequest)(nil), // 227: openshell.v1.EditDraftChunkRequest + (*EditDraftChunkResponse)(nil), // 228: openshell.v1.EditDraftChunkResponse + (*UndoDraftChunkRequest)(nil), // 229: openshell.v1.UndoDraftChunkRequest + (*UndoDraftChunkResponse)(nil), // 230: openshell.v1.UndoDraftChunkResponse + (*ClearDraftChunksRequest)(nil), // 231: openshell.v1.ClearDraftChunksRequest + (*ClearDraftChunksResponse)(nil), // 232: openshell.v1.ClearDraftChunksResponse + (*GetDraftHistoryRequest)(nil), // 233: openshell.v1.GetDraftHistoryRequest + (*DraftHistoryEntry)(nil), // 234: openshell.v1.DraftHistoryEntry + (*GetDraftHistoryResponse)(nil), // 235: openshell.v1.GetDraftHistoryResponse + (*CreateWorkspaceRequest)(nil), // 236: openshell.v1.CreateWorkspaceRequest + (*CreateWorkspaceResponse)(nil), // 237: openshell.v1.CreateWorkspaceResponse + (*GetWorkspaceRequest)(nil), // 238: openshell.v1.GetWorkspaceRequest + (*GetWorkspaceResponse)(nil), // 239: openshell.v1.GetWorkspaceResponse + (*ListWorkspacesRequest)(nil), // 240: openshell.v1.ListWorkspacesRequest + (*ListWorkspacesResponse)(nil), // 241: openshell.v1.ListWorkspacesResponse + (*DeleteWorkspaceRequest)(nil), // 242: openshell.v1.DeleteWorkspaceRequest + (*DeleteWorkspaceResponse)(nil), // 243: openshell.v1.DeleteWorkspaceResponse + (*WorkspaceMember)(nil), // 244: openshell.v1.WorkspaceMember + (*AddWorkspaceMemberRequest)(nil), // 245: openshell.v1.AddWorkspaceMemberRequest + (*AddWorkspaceMemberResponse)(nil), // 246: openshell.v1.AddWorkspaceMemberResponse + (*RemoveWorkspaceMemberRequest)(nil), // 247: openshell.v1.RemoveWorkspaceMemberRequest + (*RemoveWorkspaceMemberResponse)(nil), // 248: openshell.v1.RemoveWorkspaceMemberResponse + (*ListWorkspaceMembersRequest)(nil), // 249: openshell.v1.ListWorkspaceMembersRequest + (*ListWorkspaceMembersResponse)(nil), // 250: openshell.v1.ListWorkspaceMembersResponse + (*ExtensionServiceCredential)(nil), // 251: openshell.v1.ExtensionServiceCredential + (*EndpointObservation)(nil), // 252: openshell.v1.EndpointObservation + (*ReportEndpointStatusRequest)(nil), // 253: openshell.v1.ReportEndpointStatusRequest + (*TokenGrantStatus)(nil), // 254: openshell.v1.TokenGrantStatus + (*TokenGrantFailureObservation)(nil), // 255: openshell.v1.TokenGrantFailureObservation + (*ReportEndpointStatusResponse)(nil), // 256: openshell.v1.ReportEndpointStatusResponse + (*EndpointStatus)(nil), // 257: openshell.v1.EndpointStatus + (*SandboxProvisioning)(nil), // 258: openshell.v1.SandboxProvisioning + (*SandboxServiceExposure)(nil), // 259: openshell.v1.SandboxServiceExposure + (*EndpointFailure)(nil), // 260: openshell.v1.EndpointFailure + nil, // 261: openshell.v1.SandboxSpec.EnvironmentEntry + nil, // 262: openshell.v1.SandboxTemplate.LabelsEntry + nil, // 263: openshell.v1.SandboxTemplate.AnnotationsEntry + nil, // 264: openshell.v1.SandboxTemplate.EnvironmentEntry + nil, // 265: openshell.v1.SandboxWorkloadConfig.EnvironmentEntry + nil, // 266: openshell.v1.PlatformEvent.MetadataEntry + nil, // 267: openshell.v1.CreateSandboxRequest.LabelsEntry + nil, // 268: openshell.v1.CreateSandboxRequest.AnnotationsEntry + nil, // 269: openshell.v1.SandboxResponse.ServiceUrlsEntry + nil, // 270: openshell.v1.ExecSandboxRequest.EnvironmentEntry + nil, // 271: openshell.v1.SandboxLogLine.FieldsEntry + nil, // 272: openshell.v1.GetProviderCredentialsResponse.CredentialsEntry + nil, // 273: openshell.v1.UpdateProviderRequest.CredentialExpirationTimesEntry + nil, // 274: openshell.v1.ConfigureProviderRefreshRequest.MaterialEntry + nil, // 275: openshell.v1.ProviderProfile.AnnotationsEntry + nil, // 276: openshell.v1.GetSandboxProviderEnvironmentResponse.EnvironmentEntry + nil, // 277: openshell.v1.GetSandboxProviderEnvironmentResponse.CredentialExpirationTimesEntry + nil, // 278: openshell.v1.GetSandboxProviderEnvironmentResponse.DynamicCredentialsEntry + nil, // 279: openshell.v1.GetSandboxProviderEnvironmentResponse.StaticCredentialBindingsEntry + nil, // 280: openshell.v1.GetSandboxProviderEnvironmentResponse.FilesEntry + nil, // 281: openshell.v1.UpdateConfigRequest.AnnotationsEntry + nil, // 282: openshell.v1.UpdateConfigResponse.AnnotationsEntry + nil, // 283: openshell.v1.SandboxPolicyRevision.ProvenanceEntry + nil, // 284: openshell.v1.CreateWorkspaceRequest.LabelsEntry + (*timestamppb.Timestamp)(nil), // 285: google.protobuf.Timestamp + (*datamodelv1.ObjectMeta)(nil), // 286: openshell.datamodel.v1.ObjectMeta + (*sandboxv1.SandboxPolicy)(nil), // 287: openshell.sandbox.v1.SandboxPolicy + (*structpb.Struct)(nil), // 288: google.protobuf.Struct + (*durationpb.Duration)(nil), // 289: google.protobuf.Duration + (*datamodelv1.WorkspaceSelector)(nil), // 290: openshell.datamodel.v1.WorkspaceSelector + (*datamodelv1.Provider)(nil), // 291: openshell.datamodel.v1.Provider + (sandboxv1.PolicySource)(0), // 292: openshell.sandbox.v1.PolicySource + (*sandboxv1.NetworkEndpoint)(nil), // 293: openshell.sandbox.v1.NetworkEndpoint + (*sandboxv1.NetworkBinary)(nil), // 294: openshell.sandbox.v1.NetworkBinary + (*sandboxv1.SettingValue)(nil), // 295: openshell.sandbox.v1.SettingValue + (*sandboxv1.NetworkPolicyRule)(nil), // 296: openshell.sandbox.v1.NetworkPolicyRule + (*sandboxv1.L7DenyRule)(nil), // 297: openshell.sandbox.v1.L7DenyRule + (*sandboxv1.L7Rule)(nil), // 298: openshell.sandbox.v1.L7Rule + (*datamodelv1.Workspace)(nil), // 299: openshell.datamodel.v1.Workspace + (*sandboxv1.GetSandboxConfigRequest)(nil), // 300: openshell.sandbox.v1.GetSandboxConfigRequest + (*sandboxv1.GetGatewayConfigRequest)(nil), // 301: openshell.sandbox.v1.GetGatewayConfigRequest + (*sandboxv1.GetSandboxConfigResponse)(nil), // 302: openshell.sandbox.v1.GetSandboxConfigResponse + (*sandboxv1.GetGatewayConfigResponse)(nil), // 303: openshell.sandbox.v1.GetGatewayConfigResponse } var file_openshell_proto_depIdxs = []int32{ - 286, // 0: openshell.v1.IssueSandboxTokenResponse.expiration_time:type_name -> google.protobuf.Timestamp - 286, // 1: openshell.v1.RefreshSandboxTokenResponse.expiration_time:type_name -> google.protobuf.Timestamp - 252, // 2: openshell.v1.RefreshSandboxTokenResponse.extension_credentials:type_name -> openshell.v1.ExtensionServiceCredential - 286, // 3: openshell.v1.RefreshSandboxTokenResponse.sandbox_expiration_time:type_name -> google.protobuf.Timestamp + 285, // 0: openshell.v1.IssueSandboxTokenResponse.expiration_time:type_name -> google.protobuf.Timestamp + 285, // 1: openshell.v1.RefreshSandboxTokenResponse.expiration_time:type_name -> google.protobuf.Timestamp + 251, // 2: openshell.v1.RefreshSandboxTokenResponse.extension_credentials:type_name -> openshell.v1.ExtensionServiceCredential + 285, // 3: openshell.v1.RefreshSandboxTokenResponse.sandbox_expiration_time:type_name -> google.protobuf.Timestamp 13, // 4: openshell.v1.HealthResponse.status:type_name -> openshell.v1.ServiceStatus 13, // 5: openshell.v1.GetGatewayInfoResponse.status:type_name -> openshell.v1.ServiceStatus 32, // 6: openshell.v1.GetGatewayInfoResponse.compute_drivers:type_name -> openshell.v1.ComputeDriverInfo @@ -20793,507 +20697,506 @@ var file_openshell_proto_depIdxs = []int32{ 35, // 11: openshell.v1.ResourceCapabilities.cpu:type_name -> openshell.v1.CpuResourceCapabilities 36, // 12: openshell.v1.ResourceCapabilities.memory:type_name -> openshell.v1.MemoryResourceCapabilities 37, // 13: openshell.v1.ResourceCapabilities.gpu:type_name -> openshell.v1.GpuResourceCapabilities - 287, // 14: openshell.v1.Sandbox.metadata:type_name -> openshell.datamodel.v1.ObjectMeta + 286, // 14: openshell.v1.Sandbox.metadata:type_name -> openshell.datamodel.v1.ObjectMeta 39, // 15: openshell.v1.Sandbox.spec:type_name -> openshell.v1.SandboxSpec 50, // 16: openshell.v1.Sandbox.status:type_name -> openshell.v1.SandboxStatus 49, // 17: openshell.v1.Sandbox.created_from_workload_template:type_name -> openshell.v1.SandboxWorkloadTemplateProvenance - 262, // 18: openshell.v1.SandboxSpec.environment:type_name -> openshell.v1.SandboxSpec.EnvironmentEntry + 261, // 18: openshell.v1.SandboxSpec.environment:type_name -> openshell.v1.SandboxSpec.EnvironmentEntry 42, // 19: openshell.v1.SandboxSpec.template:type_name -> openshell.v1.SandboxTemplate - 288, // 20: openshell.v1.SandboxSpec.policy:type_name -> openshell.sandbox.v1.SandboxPolicy + 287, // 20: openshell.v1.SandboxSpec.policy:type_name -> openshell.sandbox.v1.SandboxPolicy 40, // 21: openshell.v1.SandboxSpec.resource_requirements:type_name -> openshell.v1.ResourceRequirements 16, // 22: openshell.v1.SandboxSpec.restart_policy:type_name -> openshell.v1.SandboxRestartPolicy 41, // 23: openshell.v1.ResourceRequirements.gpu:type_name -> openshell.v1.GpuResourceRequirements - 263, // 24: openshell.v1.SandboxTemplate.labels:type_name -> openshell.v1.SandboxTemplate.LabelsEntry - 264, // 25: openshell.v1.SandboxTemplate.annotations:type_name -> openshell.v1.SandboxTemplate.AnnotationsEntry - 265, // 26: openshell.v1.SandboxTemplate.environment:type_name -> openshell.v1.SandboxTemplate.EnvironmentEntry - 289, // 27: openshell.v1.SandboxTemplate.resources:type_name -> google.protobuf.Struct - 289, // 28: openshell.v1.SandboxTemplate.driver_config:type_name -> google.protobuf.Struct - 287, // 29: openshell.v1.SandboxWorkloadTemplate.metadata:type_name -> openshell.datamodel.v1.ObjectMeta + 262, // 24: openshell.v1.SandboxTemplate.labels:type_name -> openshell.v1.SandboxTemplate.LabelsEntry + 263, // 25: openshell.v1.SandboxTemplate.annotations:type_name -> openshell.v1.SandboxTemplate.AnnotationsEntry + 264, // 26: openshell.v1.SandboxTemplate.environment:type_name -> openshell.v1.SandboxTemplate.EnvironmentEntry + 288, // 27: openshell.v1.SandboxTemplate.resources:type_name -> google.protobuf.Struct + 288, // 28: openshell.v1.SandboxTemplate.driver_config:type_name -> google.protobuf.Struct + 286, // 29: openshell.v1.SandboxWorkloadTemplate.metadata:type_name -> openshell.datamodel.v1.ObjectMeta 44, // 30: openshell.v1.SandboxWorkloadTemplate.spec:type_name -> openshell.v1.SandboxWorkloadTemplateSpec 45, // 31: openshell.v1.SandboxWorkloadTemplateSpec.workload:type_name -> openshell.v1.SandboxWorkloadConfig - 289, // 32: openshell.v1.SandboxWorkloadTemplateSpec.driver_config:type_name -> google.protobuf.Struct + 288, // 32: openshell.v1.SandboxWorkloadTemplateSpec.driver_config:type_name -> google.protobuf.Struct 47, // 33: openshell.v1.SandboxWorkloadTemplateSpec.desired_service_level:type_name -> openshell.v1.SandboxServiceLevel - 266, // 34: openshell.v1.SandboxWorkloadConfig.environment:type_name -> openshell.v1.SandboxWorkloadConfig.EnvironmentEntry + 265, // 34: openshell.v1.SandboxWorkloadConfig.environment:type_name -> openshell.v1.SandboxWorkloadConfig.EnvironmentEntry 46, // 35: openshell.v1.SandboxWorkloadConfig.resources:type_name -> openshell.v1.SandboxResources 41, // 36: openshell.v1.SandboxResources.gpu:type_name -> openshell.v1.GpuResourceRequirements 48, // 37: openshell.v1.SandboxServiceLevel.startup:type_name -> openshell.v1.SandboxStartup - 290, // 38: openshell.v1.SandboxStartup.ready_within:type_name -> google.protobuf.Duration - 52, // 39: openshell.v1.SandboxStatus.conditions:type_name -> openshell.v1.SandboxCondition + 289, // 38: openshell.v1.SandboxStartup.ready_within:type_name -> google.protobuf.Duration + 51, // 39: openshell.v1.SandboxStatus.conditions:type_name -> openshell.v1.SandboxCondition 1, // 40: openshell.v1.SandboxStatus.phase:type_name -> openshell.v1.SandboxPhase - 258, // 41: openshell.v1.SandboxStatus.endpoint_statuses:type_name -> openshell.v1.EndpointStatus - 182, // 42: openshell.v1.SandboxStatus.configuration_admission:type_name -> openshell.v1.SandboxConfigurationAdmission - 259, // 43: openshell.v1.SandboxStatus.provisioning:type_name -> openshell.v1.SandboxProvisioning - 286, // 44: openshell.v1.SandboxStatus.next_restart_time:type_name -> google.protobuf.Timestamp - 286, // 45: openshell.v1.SandboxStatus.main_process_started_time:type_name -> google.protobuf.Timestamp - 256, // 46: openshell.v1.SandboxStatus.last_token_grant_failure:type_name -> openshell.v1.TokenGrantFailureObservation - 51, // 47: openshell.v1.SandboxStatus.image_update:type_name -> openshell.v1.SandboxImageUpdate - 286, // 48: openshell.v1.SandboxCondition.transition_time:type_name -> google.protobuf.Timestamp - 286, // 49: openshell.v1.PlatformEvent.event_time:type_name -> google.protobuf.Timestamp - 267, // 50: openshell.v1.PlatformEvent.metadata:type_name -> openshell.v1.PlatformEvent.MetadataEntry - 291, // 51: openshell.v1.CreateSandboxRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 39, // 52: openshell.v1.CreateSandboxRequest.spec:type_name -> openshell.v1.SandboxSpec - 268, // 53: openshell.v1.CreateSandboxRequest.labels:type_name -> openshell.v1.CreateSandboxRequest.LabelsEntry - 269, // 54: openshell.v1.CreateSandboxRequest.annotations:type_name -> openshell.v1.CreateSandboxRequest.AnnotationsEntry - 260, // 55: openshell.v1.CreateSandboxRequest.service_exposures:type_name -> openshell.v1.SandboxServiceExposure - 291, // 56: openshell.v1.UpdateSandboxRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 291, // 57: openshell.v1.CreateSandboxTemplateRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 43, // 58: openshell.v1.CreateSandboxTemplateRequest.template:type_name -> openshell.v1.SandboxWorkloadTemplate - 291, // 59: openshell.v1.GetSandboxTemplateRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 291, // 60: openshell.v1.ListSandboxTemplatesRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 291, // 61: openshell.v1.DeleteSandboxTemplateRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 43, // 62: openshell.v1.SandboxTemplateResponse.template:type_name -> openshell.v1.SandboxWorkloadTemplate - 43, // 63: openshell.v1.ListSandboxTemplatesResponse.templates:type_name -> openshell.v1.SandboxWorkloadTemplate - 17, // 64: openshell.v1.DeleteSandboxTemplateResponse.outcome:type_name -> openshell.v1.DeletionOutcome - 291, // 65: openshell.v1.BeginRootfsTarStagingRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 286, // 66: openshell.v1.BeginRootfsTarStagingResponse.expiration_time:type_name -> google.protobuf.Timestamp - 291, // 67: openshell.v1.GetSandboxRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 291, // 68: openshell.v1.ListSandboxesRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 291, // 69: openshell.v1.ListSandboxProvidersRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 291, // 70: openshell.v1.AttachSandboxProviderRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 291, // 71: openshell.v1.DetachSandboxProviderRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 291, // 72: openshell.v1.DeleteSandboxRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 291, // 73: openshell.v1.StopSandboxRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 291, // 74: openshell.v1.StartSandboxRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 38, // 75: openshell.v1.SandboxResponse.sandbox:type_name -> openshell.v1.Sandbox - 270, // 76: openshell.v1.SandboxResponse.service_urls:type_name -> openshell.v1.SandboxResponse.ServiceUrlsEntry - 38, // 77: openshell.v1.ListSandboxesResponse.sandboxes:type_name -> openshell.v1.Sandbox - 292, // 78: openshell.v1.ListSandboxProvidersResponse.providers:type_name -> openshell.datamodel.v1.Provider - 38, // 79: openshell.v1.AttachSandboxProviderResponse.sandbox:type_name -> openshell.v1.Sandbox - 82, // 80: openshell.v1.AttachSandboxProviderResponse.receipt:type_name -> openshell.v1.ProviderMutationReceipt - 38, // 81: openshell.v1.DetachSandboxProviderResponse.sandbox:type_name -> openshell.v1.Sandbox - 82, // 82: openshell.v1.DetachSandboxProviderResponse.receipt:type_name -> openshell.v1.ProviderMutationReceipt - 80, // 83: openshell.v1.ConfigSnapshotRevision.sandbox_config:type_name -> openshell.v1.SandboxConfigRevision - 78, // 84: openshell.v1.ConfigSnapshotRevision.provider_target:type_name -> openshell.v1.ProviderDesiredIdentity - 293, // 85: openshell.v1.SandboxConfigRevision.policy_source:type_name -> openshell.sandbox.v1.PolicySource - 5, // 86: openshell.v1.ConfigUpdateOperation.component:type_name -> openshell.v1.ConfigComponent - 79, // 87: openshell.v1.ConfigUpdateOperation.target_revision:type_name -> openshell.v1.ConfigSnapshotRevision - 7, // 88: openshell.v1.ConfigUpdateOperation.state:type_name -> openshell.v1.ConfigUpdateOperationState - 6, // 89: openshell.v1.ConfigUpdateOperation.outcome:type_name -> openshell.v1.ConfigApplyOutcome - 286, // 90: openshell.v1.ConfigUpdateOperation.created_time:type_name -> google.protobuf.Timestamp - 286, // 91: openshell.v1.ConfigUpdateOperation.updated_time:type_name -> google.protobuf.Timestamp - 286, // 92: openshell.v1.ConfigUpdateOperation.completed_time:type_name -> google.protobuf.Timestamp - 2, // 93: openshell.v1.ProviderMutationReceipt.kind:type_name -> openshell.v1.ProviderMutationKind - 78, // 94: openshell.v1.ProviderMutationReceipt.desired:type_name -> openshell.v1.ProviderDesiredIdentity - 286, // 95: openshell.v1.ProviderMutationReceipt.persisted_time:type_name -> google.protobuf.Timestamp - 4, // 96: openshell.v1.ProviderReadinessObservation.reason:type_name -> openshell.v1.ProviderReadinessReason - 82, // 97: openshell.v1.ProviderReadinessStatus.receipt:type_name -> openshell.v1.ProviderMutationReceipt - 3, // 98: openshell.v1.ProviderReadinessStatus.state:type_name -> openshell.v1.ProviderReadinessState - 4, // 99: openshell.v1.ProviderReadinessStatus.reason:type_name -> openshell.v1.ProviderReadinessReason - 83, // 100: openshell.v1.ProviderReadinessStatus.observed:type_name -> openshell.v1.ProviderReadinessObservation - 286, // 101: openshell.v1.ProviderReadinessStatus.observed_time:type_name -> google.protobuf.Timestamp - 286, // 102: openshell.v1.ProviderReadinessStatus.evaluated_time:type_name -> google.protobuf.Timestamp - 81, // 103: openshell.v1.ProviderReadinessStatus.operation:type_name -> openshell.v1.ConfigUpdateOperation - 291, // 104: openshell.v1.GetSandboxProviderStatusRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 84, // 105: openshell.v1.GetSandboxProviderStatusResponse.status:type_name -> openshell.v1.ProviderReadinessStatus - 83, // 106: openshell.v1.ReportProviderReadinessRequest.observation:type_name -> openshell.v1.ProviderReadinessObservation - 290, // 107: openshell.v1.ReportProviderReadinessResponse.report_interval:type_name -> google.protobuf.Duration - 290, // 108: openshell.v1.ReportProviderReadinessResponse.observation_ttl:type_name -> google.protobuf.Duration - 17, // 109: openshell.v1.DeleteSandboxResponse.outcome:type_name -> openshell.v1.DeletionOutcome - 291, // 110: openshell.v1.CreateSshSessionRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 286, // 111: openshell.v1.CreateSshSessionResponse.expiration_time:type_name -> google.protobuf.Timestamp - 291, // 112: openshell.v1.ExposeServiceRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 19, // 113: openshell.v1.ExposeServiceRequest.authorization_mode:type_name -> openshell.v1.ServiceAuthorizationMode - 291, // 114: openshell.v1.GetServiceRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 291, // 115: openshell.v1.ListServicesRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 99, // 116: openshell.v1.ListServicesResponse.services:type_name -> openshell.v1.ServiceEndpointResponse - 291, // 117: openshell.v1.DeleteServiceRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 17, // 118: openshell.v1.DeleteServiceResponse.outcome:type_name -> openshell.v1.DeletionOutcome - 287, // 119: openshell.v1.ServiceEndpoint.metadata:type_name -> openshell.datamodel.v1.ObjectMeta - 19, // 120: openshell.v1.ServiceEndpoint.authorization_mode:type_name -> openshell.v1.ServiceAuthorizationMode - 98, // 121: openshell.v1.ServiceEndpointResponse.endpoint:type_name -> openshell.v1.ServiceEndpoint - 17, // 122: openshell.v1.RevokeSshSessionResponse.outcome:type_name -> openshell.v1.DeletionOutcome - 291, // 123: openshell.v1.ExecSandboxRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 271, // 124: openshell.v1.ExecSandboxRequest.environment:type_name -> openshell.v1.ExecSandboxRequest.EnvironmentEntry - 290, // 125: openshell.v1.ExecSandboxRequest.execution_timeout:type_name -> google.protobuf.Duration - 103, // 126: openshell.v1.ExecSandboxEvent.stdout:type_name -> openshell.v1.ExecSandboxStdout - 104, // 127: openshell.v1.ExecSandboxEvent.stderr:type_name -> openshell.v1.ExecSandboxStderr - 105, // 128: openshell.v1.ExecSandboxEvent.exit:type_name -> openshell.v1.ExecSandboxExit - 203, // 129: openshell.v1.TcpForwardInit.ssh:type_name -> openshell.v1.SshRelayTarget - 204, // 130: openshell.v1.TcpForwardInit.tcp:type_name -> openshell.v1.TcpRelayTarget - 107, // 131: openshell.v1.TcpForwardFrame.init:type_name -> openshell.v1.TcpForwardInit - 102, // 132: openshell.v1.ExecSandboxInput.start:type_name -> openshell.v1.ExecSandboxRequest - 110, // 133: openshell.v1.ExecSandboxInput.resize:type_name -> openshell.v1.ExecSandboxWindowResize - 287, // 134: openshell.v1.SshSession.metadata:type_name -> openshell.datamodel.v1.ObjectMeta - 286, // 135: openshell.v1.SshSession.expiration_time:type_name -> google.protobuf.Timestamp - 291, // 136: openshell.v1.WatchSandboxRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 286, // 137: openshell.v1.WatchSandboxRequest.since_time:type_name -> google.protobuf.Timestamp - 38, // 138: openshell.v1.SandboxStreamEvent.sandbox:type_name -> openshell.v1.Sandbox - 114, // 139: openshell.v1.SandboxStreamEvent.log:type_name -> openshell.v1.SandboxLogLine - 53, // 140: openshell.v1.SandboxStreamEvent.event:type_name -> openshell.v1.PlatformEvent - 115, // 141: openshell.v1.SandboxStreamEvent.warning:type_name -> openshell.v1.SandboxStreamWarning - 216, // 142: openshell.v1.SandboxStreamEvent.draft_policy_update:type_name -> openshell.v1.DraftPolicyUpdate - 286, // 143: openshell.v1.SandboxLogLine.event_time:type_name -> google.protobuf.Timestamp - 272, // 144: openshell.v1.SandboxLogLine.fields:type_name -> openshell.v1.SandboxLogLine.FieldsEntry - 291, // 145: openshell.v1.CreateProviderRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 292, // 146: openshell.v1.CreateProviderRequest.provider:type_name -> openshell.datamodel.v1.Provider - 291, // 147: openshell.v1.GetProviderRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 291, // 148: openshell.v1.GetProviderCredentialsRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 290, // 149: openshell.v1.GetProviderCredentialsRequest.minimum_remaining_lifetime:type_name -> google.protobuf.Duration - 286, // 150: openshell.v1.ProviderCredentialValue.expiration_time:type_name -> google.protobuf.Timestamp - 273, // 151: openshell.v1.GetProviderCredentialsResponse.credentials:type_name -> openshell.v1.GetProviderCredentialsResponse.CredentialsEntry - 291, // 152: openshell.v1.ListProvidersRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 291, // 153: openshell.v1.UpdateProviderRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 292, // 154: openshell.v1.UpdateProviderRequest.provider:type_name -> openshell.datamodel.v1.Provider - 274, // 155: openshell.v1.UpdateProviderRequest.credential_expiration_times:type_name -> openshell.v1.UpdateProviderRequest.CredentialExpirationTimesEntry - 291, // 156: openshell.v1.DeleteProviderRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 292, // 157: openshell.v1.ProviderResponse.provider:type_name -> openshell.datamodel.v1.Provider - 82, // 158: openshell.v1.ProviderResponse.target_receipts:type_name -> openshell.v1.ProviderMutationReceipt - 292, // 159: openshell.v1.ListProvidersResponse.providers:type_name -> openshell.datamodel.v1.Provider - 291, // 160: openshell.v1.ListProviderProfilesRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 291, // 161: openshell.v1.GetProviderProfileRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 147, // 162: openshell.v1.ProviderProfileImportItem.profile:type_name -> openshell.v1.ProviderProfile - 290, // 163: openshell.v1.ProviderCredentialTokenGrant.cache_ttl:type_name -> google.protobuf.Duration - 130, // 164: openshell.v1.ProviderCredentialTokenGrant.audience_overrides:type_name -> openshell.v1.ProviderCredentialTokenGrantAudienceOverride - 8, // 165: openshell.v1.ProviderCredentialTokenGrant.grant_type:type_name -> openshell.v1.ProviderCredentialTokenGrantType - 131, // 166: openshell.v1.ProviderCredentialTokenGrant.subject_token:type_name -> openshell.v1.ProviderCredentialTokenGrantSubjectToken - 136, // 167: openshell.v1.ProviderProfileCredential.refresh:type_name -> openshell.v1.ProviderCredentialRefresh - 132, // 168: openshell.v1.ProviderProfileCredential.token_grant:type_name -> openshell.v1.ProviderCredentialTokenGrant - 9, // 169: openshell.v1.ProviderCredentialRefresh.strategy:type_name -> openshell.v1.ProviderCredentialRefreshStrategy - 290, // 170: openshell.v1.ProviderCredentialRefresh.refresh_before:type_name -> google.protobuf.Duration - 290, // 171: openshell.v1.ProviderCredentialRefresh.max_lifetime:type_name -> google.protobuf.Duration - 134, // 172: openshell.v1.ProviderCredentialRefresh.material:type_name -> openshell.v1.ProviderCredentialRefreshMaterial - 135, // 173: openshell.v1.ProviderCredentialRefresh.additional_outputs:type_name -> openshell.v1.ProviderCredentialRefreshOutput - 9, // 174: openshell.v1.ProviderCredentialRefreshStatus.strategy:type_name -> openshell.v1.ProviderCredentialRefreshStrategy - 286, // 175: openshell.v1.ProviderCredentialRefreshStatus.expiration_time:type_name -> google.protobuf.Timestamp - 286, // 176: openshell.v1.ProviderCredentialRefreshStatus.next_refresh_time:type_name -> google.protobuf.Timestamp - 286, // 177: openshell.v1.ProviderCredentialRefreshStatus.last_refresh_time:type_name -> google.protobuf.Timestamp - 15, // 178: openshell.v1.ProviderCredentialRefreshStatus.recovery_action:type_name -> openshell.v1.ProviderCredentialRefreshRecoveryAction - 286, // 179: openshell.v1.ProviderCredentialRefreshStatus.last_error_time:type_name -> google.protobuf.Timestamp - 291, // 180: openshell.v1.GetProviderRefreshStatusRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 137, // 181: openshell.v1.GetProviderRefreshStatusResponse.credentials:type_name -> openshell.v1.ProviderCredentialRefreshStatus - 291, // 182: openshell.v1.ConfigureProviderRefreshRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 9, // 183: openshell.v1.ConfigureProviderRefreshRequest.strategy:type_name -> openshell.v1.ProviderCredentialRefreshStrategy - 275, // 184: openshell.v1.ConfigureProviderRefreshRequest.material:type_name -> openshell.v1.ConfigureProviderRefreshRequest.MaterialEntry - 286, // 185: openshell.v1.ConfigureProviderRefreshRequest.expiration_time:type_name -> google.protobuf.Timestamp - 137, // 186: openshell.v1.ConfigureProviderRefreshResponse.status:type_name -> openshell.v1.ProviderCredentialRefreshStatus - 291, // 187: openshell.v1.RotateProviderCredentialRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 137, // 188: openshell.v1.RotateProviderCredentialResponse.status:type_name -> openshell.v1.ProviderCredentialRefreshStatus - 291, // 189: openshell.v1.DeleteProviderRefreshRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 17, // 190: openshell.v1.DeleteProviderRefreshResponse.outcome:type_name -> openshell.v1.DeletionOutcome - 10, // 191: openshell.v1.ProviderProfile.category:type_name -> openshell.v1.ProviderProfileCategory - 133, // 192: openshell.v1.ProviderProfile.credentials:type_name -> openshell.v1.ProviderProfileCredential - 294, // 193: openshell.v1.ProviderProfile.endpoints:type_name -> openshell.sandbox.v1.NetworkEndpoint - 295, // 194: openshell.v1.ProviderProfile.binaries:type_name -> openshell.sandbox.v1.NetworkBinary - 138, // 195: openshell.v1.ProviderProfile.discovery:type_name -> openshell.v1.ProviderProfileDiscovery - 276, // 196: openshell.v1.ProviderProfile.annotations:type_name -> openshell.v1.ProviderProfile.AnnotationsEntry - 148, // 197: openshell.v1.ProviderProfile.files:type_name -> openshell.v1.ProviderProfileFile - 147, // 198: openshell.v1.ProviderProfileResponse.profile:type_name -> openshell.v1.ProviderProfile - 147, // 199: openshell.v1.ListProviderProfilesResponse.profiles:type_name -> openshell.v1.ProviderProfile - 291, // 200: openshell.v1.ImportProviderProfilesRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 128, // 201: openshell.v1.ImportProviderProfilesRequest.profiles:type_name -> openshell.v1.ProviderProfileImportItem - 129, // 202: openshell.v1.ImportProviderProfilesResponse.diagnostics:type_name -> openshell.v1.ProviderProfileDiagnostic - 147, // 203: openshell.v1.ImportProviderProfilesResponse.profiles:type_name -> openshell.v1.ProviderProfile - 291, // 204: openshell.v1.UpdateProviderProfilesRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 128, // 205: openshell.v1.UpdateProviderProfilesRequest.profile:type_name -> openshell.v1.ProviderProfileImportItem - 129, // 206: openshell.v1.UpdateProviderProfilesResponse.diagnostics:type_name -> openshell.v1.ProviderProfileDiagnostic - 147, // 207: openshell.v1.UpdateProviderProfilesResponse.profile:type_name -> openshell.v1.ProviderProfile - 291, // 208: openshell.v1.LintProviderProfilesRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 128, // 209: openshell.v1.LintProviderProfilesRequest.profiles:type_name -> openshell.v1.ProviderProfileImportItem - 129, // 210: openshell.v1.LintProviderProfilesResponse.diagnostics:type_name -> openshell.v1.ProviderProfileDiagnostic - 17, // 211: openshell.v1.DeleteProviderResponse.outcome:type_name -> openshell.v1.DeletionOutcome - 291, // 212: openshell.v1.DeleteProviderProfileRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 17, // 213: openshell.v1.DeleteProviderProfileResponse.outcome:type_name -> openshell.v1.DeletionOutcome - 161, // 214: openshell.v1.StaticCredentialBinding.endpoints:type_name -> openshell.v1.StaticCredentialEndpointBinding - 277, // 215: openshell.v1.GetSandboxProviderEnvironmentResponse.environment:type_name -> openshell.v1.GetSandboxProviderEnvironmentResponse.EnvironmentEntry - 278, // 216: openshell.v1.GetSandboxProviderEnvironmentResponse.credential_expiration_times:type_name -> openshell.v1.GetSandboxProviderEnvironmentResponse.CredentialExpirationTimesEntry - 279, // 217: openshell.v1.GetSandboxProviderEnvironmentResponse.dynamic_credentials:type_name -> openshell.v1.GetSandboxProviderEnvironmentResponse.DynamicCredentialsEntry - 280, // 218: openshell.v1.GetSandboxProviderEnvironmentResponse.static_credential_bindings:type_name -> openshell.v1.GetSandboxProviderEnvironmentResponse.StaticCredentialBindingsEntry - 4, // 219: openshell.v1.GetSandboxProviderEnvironmentResponse.readiness_reason:type_name -> openshell.v1.ProviderReadinessReason - 281, // 220: openshell.v1.GetSandboxProviderEnvironmentResponse.files:type_name -> openshell.v1.GetSandboxProviderEnvironmentResponse.FilesEntry - 290, // 221: openshell.v1.ExchangeProviderSubjectTokenResponse.expires_after:type_name -> google.protobuf.Duration - 291, // 222: openshell.v1.UpdateConfigRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 288, // 223: openshell.v1.UpdateConfigRequest.policy:type_name -> openshell.sandbox.v1.SandboxPolicy - 296, // 224: openshell.v1.UpdateConfigRequest.setting_value:type_name -> openshell.sandbox.v1.SettingValue - 167, // 225: openshell.v1.UpdateConfigRequest.merge_operations:type_name -> openshell.v1.PolicyMergeOperation - 282, // 226: openshell.v1.UpdateConfigRequest.annotations:type_name -> openshell.v1.UpdateConfigRequest.AnnotationsEntry - 168, // 227: openshell.v1.PolicyMergeOperation.add_rule:type_name -> openshell.v1.AddNetworkRule - 169, // 228: openshell.v1.PolicyMergeOperation.remove_endpoint:type_name -> openshell.v1.RemoveNetworkEndpoint - 170, // 229: openshell.v1.PolicyMergeOperation.remove_rule:type_name -> openshell.v1.RemoveNetworkRule - 172, // 230: openshell.v1.PolicyMergeOperation.add_deny_rules:type_name -> openshell.v1.AddDenyRules - 173, // 231: openshell.v1.PolicyMergeOperation.add_allow_rules:type_name -> openshell.v1.AddAllowRules - 174, // 232: openshell.v1.PolicyMergeOperation.remove_binary:type_name -> openshell.v1.RemoveNetworkBinary - 297, // 233: openshell.v1.AddNetworkRule.rule:type_name -> openshell.sandbox.v1.NetworkPolicyRule - 295, // 234: openshell.v1.L7RuleTarget.binaries:type_name -> openshell.sandbox.v1.NetworkBinary - 298, // 235: openshell.v1.AddDenyRules.deny_rules:type_name -> openshell.sandbox.v1.L7DenyRule - 171, // 236: openshell.v1.AddDenyRules.target:type_name -> openshell.v1.L7RuleTarget - 299, // 237: openshell.v1.AddAllowRules.rules:type_name -> openshell.sandbox.v1.L7Rule - 171, // 238: openshell.v1.AddAllowRules.target:type_name -> openshell.v1.L7RuleTarget - 283, // 239: openshell.v1.UpdateConfigResponse.annotations:type_name -> openshell.v1.UpdateConfigResponse.AnnotationsEntry - 291, // 240: openshell.v1.GetSandboxPolicyStatusRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 185, // 241: openshell.v1.GetSandboxPolicyStatusResponse.revision:type_name -> openshell.v1.SandboxPolicyRevision - 291, // 242: openshell.v1.ListSandboxPoliciesRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 185, // 243: openshell.v1.ListSandboxPoliciesResponse.revisions:type_name -> openshell.v1.SandboxPolicyRevision - 12, // 244: openshell.v1.ReportPolicyStatusRequest.status:type_name -> openshell.v1.PolicyStatus - 11, // 245: openshell.v1.SandboxConfigurationAdmission.state:type_name -> openshell.v1.ConfigurationAdmissionState - 182, // 246: openshell.v1.ReportSandboxConfigurationRequest.admission:type_name -> openshell.v1.SandboxConfigurationAdmission - 12, // 247: openshell.v1.SandboxPolicyRevision.status:type_name -> openshell.v1.PolicyStatus - 286, // 248: openshell.v1.SandboxPolicyRevision.created_time:type_name -> google.protobuf.Timestamp - 286, // 249: openshell.v1.SandboxPolicyRevision.loaded_time:type_name -> google.protobuf.Timestamp - 288, // 250: openshell.v1.SandboxPolicyRevision.policy:type_name -> openshell.sandbox.v1.SandboxPolicy - 284, // 251: openshell.v1.SandboxPolicyRevision.provenance:type_name -> openshell.v1.SandboxPolicyRevision.ProvenanceEntry - 291, // 252: openshell.v1.GetSandboxLogsRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 286, // 253: openshell.v1.GetSandboxLogsRequest.since_time:type_name -> google.protobuf.Timestamp - 114, // 254: openshell.v1.PushSandboxLogsRequest.logs:type_name -> openshell.v1.SandboxLogLine - 114, // 255: openshell.v1.GetSandboxLogsResponse.logs:type_name -> openshell.v1.SandboxLogLine - 192, // 256: openshell.v1.SupervisorMessage.hello:type_name -> openshell.v1.SupervisorHello - 196, // 257: openshell.v1.SupervisorMessage.heartbeat:type_name -> openshell.v1.SupervisorHeartbeat - 209, // 258: openshell.v1.SupervisorMessage.relay_open_result:type_name -> openshell.v1.RelayOpenResult - 210, // 259: openshell.v1.SupervisorMessage.relay_close:type_name -> openshell.v1.RelayClose - 193, // 260: openshell.v1.GatewayMessage.session_accepted:type_name -> openshell.v1.SessionAccepted - 194, // 261: openshell.v1.GatewayMessage.session_rejected:type_name -> openshell.v1.SessionRejected - 197, // 262: openshell.v1.GatewayMessage.heartbeat:type_name -> openshell.v1.GatewayHeartbeat - 202, // 263: openshell.v1.GatewayMessage.relay_open:type_name -> openshell.v1.RelayOpen - 210, // 264: openshell.v1.GatewayMessage.relay_close:type_name -> openshell.v1.RelayClose - 195, // 265: openshell.v1.GatewayMessage.session_redirect:type_name -> openshell.v1.SessionRedirect - 290, // 266: openshell.v1.SessionAccepted.heartbeat_interval:type_name -> google.protobuf.Duration - 203, // 267: openshell.v1.RelayOpen.ssh:type_name -> openshell.v1.SshRelayTarget - 204, // 268: openshell.v1.RelayOpen.tcp:type_name -> openshell.v1.TcpRelayTarget - 205, // 269: openshell.v1.RelayFrame.init:type_name -> openshell.v1.RelayInit - 202, // 270: openshell.v1.PeerRelayInit.relay_open:type_name -> openshell.v1.RelayOpen - 207, // 271: openshell.v1.PeerRelayFrame.init:type_name -> openshell.v1.PeerRelayInit - 286, // 272: openshell.v1.DenialSummary.first_seen_time:type_name -> google.protobuf.Timestamp - 286, // 273: openshell.v1.DenialSummary.last_seen_time:type_name -> google.protobuf.Timestamp - 211, // 274: openshell.v1.DenialSummary.l7_request_samples:type_name -> openshell.v1.L7RequestSample - 213, // 275: openshell.v1.NetworkActivitySummary.denials_by_group:type_name -> openshell.v1.DenialGroupCount - 297, // 276: openshell.v1.PolicyChunk.proposed_rule:type_name -> openshell.sandbox.v1.NetworkPolicyRule - 286, // 277: openshell.v1.PolicyChunk.created_time:type_name -> google.protobuf.Timestamp - 286, // 278: openshell.v1.PolicyChunk.decided_time:type_name -> google.protobuf.Timestamp - 286, // 279: openshell.v1.PolicyChunk.first_seen_time:type_name -> google.protobuf.Timestamp - 286, // 280: openshell.v1.PolicyChunk.last_seen_time:type_name -> google.protobuf.Timestamp - 288, // 281: openshell.v1.PolicyChunk.current_effective_policy:type_name -> openshell.sandbox.v1.SandboxPolicy - 288, // 282: openshell.v1.PolicyChunk.candidate_effective_policy:type_name -> openshell.sandbox.v1.SandboxPolicy - 291, // 283: openshell.v1.SubmitPolicyAnalysisRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 212, // 284: openshell.v1.SubmitPolicyAnalysisRequest.summaries:type_name -> openshell.v1.DenialSummary - 215, // 285: openshell.v1.SubmitPolicyAnalysisRequest.proposed_chunks:type_name -> openshell.v1.PolicyChunk - 214, // 286: openshell.v1.SubmitPolicyAnalysisRequest.network_activity_summaries:type_name -> openshell.v1.NetworkActivitySummary - 291, // 287: openshell.v1.GetDraftPolicyRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 215, // 288: openshell.v1.GetDraftPolicyResponse.chunks:type_name -> openshell.v1.PolicyChunk - 286, // 289: openshell.v1.GetDraftPolicyResponse.last_analyzed_time:type_name -> google.protobuf.Timestamp - 291, // 290: openshell.v1.ApproveDraftChunkRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 291, // 291: openshell.v1.RejectDraftChunkRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 291, // 292: openshell.v1.ApproveAllDraftChunksRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 225, // 293: openshell.v1.ApproveAllDraftChunksRequest.approvals:type_name -> openshell.v1.DraftChunkApproval - 291, // 294: openshell.v1.EditDraftChunkRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 297, // 295: openshell.v1.EditDraftChunkRequest.proposed_rule:type_name -> openshell.sandbox.v1.NetworkPolicyRule - 291, // 296: openshell.v1.UndoDraftChunkRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 291, // 297: openshell.v1.ClearDraftChunksRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 291, // 298: openshell.v1.GetDraftHistoryRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 286, // 299: openshell.v1.DraftHistoryEntry.event_time:type_name -> google.protobuf.Timestamp - 235, // 300: openshell.v1.GetDraftHistoryResponse.entries:type_name -> openshell.v1.DraftHistoryEntry - 285, // 301: openshell.v1.CreateWorkspaceRequest.labels:type_name -> openshell.v1.CreateWorkspaceRequest.LabelsEntry - 300, // 302: openshell.v1.CreateWorkspaceResponse.workspace:type_name -> openshell.datamodel.v1.Workspace - 300, // 303: openshell.v1.GetWorkspaceResponse.workspace:type_name -> openshell.datamodel.v1.Workspace - 300, // 304: openshell.v1.ListWorkspacesResponse.workspaces:type_name -> openshell.datamodel.v1.Workspace - 17, // 305: openshell.v1.DeleteWorkspaceResponse.outcome:type_name -> openshell.v1.DeletionOutcome - 287, // 306: openshell.v1.WorkspaceMember.metadata:type_name -> openshell.datamodel.v1.ObjectMeta - 14, // 307: openshell.v1.WorkspaceMember.role:type_name -> openshell.v1.WorkspaceRole - 291, // 308: openshell.v1.AddWorkspaceMemberRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 14, // 309: openshell.v1.AddWorkspaceMemberRequest.role:type_name -> openshell.v1.WorkspaceRole - 245, // 310: openshell.v1.AddWorkspaceMemberResponse.member:type_name -> openshell.v1.WorkspaceMember - 291, // 311: openshell.v1.RemoveWorkspaceMemberRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 17, // 312: openshell.v1.RemoveWorkspaceMemberResponse.outcome:type_name -> openshell.v1.DeletionOutcome - 291, // 313: openshell.v1.ListWorkspaceMembersRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 245, // 314: openshell.v1.ListWorkspaceMembersResponse.members:type_name -> openshell.v1.WorkspaceMember - 286, // 315: openshell.v1.ExtensionServiceCredential.expiration_time:type_name -> google.protobuf.Timestamp - 18, // 316: openshell.v1.EndpointObservation.result:type_name -> openshell.v1.EndpointResult - 261, // 317: openshell.v1.EndpointObservation.failure:type_name -> openshell.v1.EndpointFailure - 253, // 318: openshell.v1.ReportEndpointStatusRequest.observations:type_name -> openshell.v1.EndpointObservation - 255, // 319: openshell.v1.ReportEndpointStatusRequest.token_grant_status:type_name -> openshell.v1.TokenGrantStatus - 256, // 320: openshell.v1.TokenGrantStatus.last_failure:type_name -> openshell.v1.TokenGrantFailureObservation - 261, // 321: openshell.v1.TokenGrantFailureObservation.failure:type_name -> openshell.v1.EndpointFailure - 18, // 322: openshell.v1.EndpointStatus.last_result:type_name -> openshell.v1.EndpointResult - 286, // 323: openshell.v1.EndpointStatus.last_reported_time:type_name -> google.protobuf.Timestamp - 261, // 324: openshell.v1.EndpointStatus.last_failure:type_name -> openshell.v1.EndpointFailure - 286, // 325: openshell.v1.SandboxProvisioning.configuration_change_time:type_name -> google.protobuf.Timestamp - 286, // 326: openshell.v1.SandboxProvisioning.first_rejection_time:type_name -> google.protobuf.Timestamp - 286, // 327: openshell.v1.SandboxProvisioning.deadline:type_name -> google.protobuf.Timestamp - 286, // 328: openshell.v1.SandboxProvisioning.timeout_time:type_name -> google.protobuf.Timestamp - 286, // 329: openshell.v1.SandboxProvisioning.cleanup_completed_time:type_name -> google.protobuf.Timestamp - 286, // 330: openshell.v1.SandboxProvisioning.cleanup_retry_time:type_name -> google.protobuf.Timestamp - 286, // 331: openshell.v1.SandboxProvisioning.attachment_change_time:type_name -> google.protobuf.Timestamp - 286, // 332: openshell.v1.SandboxProvisioning.preparation_deadline:type_name -> google.protobuf.Timestamp - 286, // 333: openshell.v1.SandboxProvisioning.admission_start_time:type_name -> google.protobuf.Timestamp - 19, // 334: openshell.v1.SandboxServiceExposure.authorization_mode:type_name -> openshell.v1.ServiceAuthorizationMode - 20, // 335: openshell.v1.EndpointFailure.domain:type_name -> openshell.v1.EndpointFailureDomain - 15, // 336: openshell.v1.EndpointFailure.recovery_action:type_name -> openshell.v1.ProviderCredentialRefreshRecoveryAction - 119, // 337: openshell.v1.GetProviderCredentialsResponse.CredentialsEntry.value:type_name -> openshell.v1.ProviderCredentialValue - 286, // 338: openshell.v1.UpdateProviderRequest.CredentialExpirationTimesEntry.value:type_name -> google.protobuf.Timestamp - 286, // 339: openshell.v1.GetSandboxProviderEnvironmentResponse.CredentialExpirationTimesEntry.value:type_name -> google.protobuf.Timestamp - 133, // 340: openshell.v1.GetSandboxProviderEnvironmentResponse.DynamicCredentialsEntry.value:type_name -> openshell.v1.ProviderProfileCredential - 162, // 341: openshell.v1.GetSandboxProviderEnvironmentResponse.StaticCredentialBindingsEntry.value:type_name -> openshell.v1.StaticCredentialBinding - 25, // 342: openshell.v1.OpenShell.Health:input_type -> openshell.v1.HealthRequest - 27, // 343: openshell.v1.OpenShell.GetCurrentUser:input_type -> openshell.v1.GetCurrentUserRequest - 29, // 344: openshell.v1.OpenShell.GetGatewayInfo:input_type -> openshell.v1.GetGatewayInfoRequest - 54, // 345: openshell.v1.OpenShell.CreateSandbox:input_type -> openshell.v1.CreateSandboxRequest - 55, // 346: openshell.v1.OpenShell.UpdateSandbox:input_type -> openshell.v1.UpdateSandboxRequest - 63, // 347: openshell.v1.OpenShell.BeginRootfsTarStaging:input_type -> openshell.v1.BeginRootfsTarStagingRequest - 65, // 348: openshell.v1.OpenShell.GetSandbox:input_type -> openshell.v1.GetSandboxRequest - 66, // 349: openshell.v1.OpenShell.ListSandboxes:input_type -> openshell.v1.ListSandboxesRequest - 56, // 350: openshell.v1.OpenShell.CreateSandboxTemplate:input_type -> openshell.v1.CreateSandboxTemplateRequest - 57, // 351: openshell.v1.OpenShell.GetSandboxTemplate:input_type -> openshell.v1.GetSandboxTemplateRequest - 58, // 352: openshell.v1.OpenShell.ListSandboxTemplates:input_type -> openshell.v1.ListSandboxTemplatesRequest - 59, // 353: openshell.v1.OpenShell.DeleteSandboxTemplate:input_type -> openshell.v1.DeleteSandboxTemplateRequest - 67, // 354: openshell.v1.OpenShell.ListSandboxProviders:input_type -> openshell.v1.ListSandboxProvidersRequest - 68, // 355: openshell.v1.OpenShell.AttachSandboxProvider:input_type -> openshell.v1.AttachSandboxProviderRequest - 69, // 356: openshell.v1.OpenShell.DetachSandboxProvider:input_type -> openshell.v1.DetachSandboxProviderRequest - 85, // 357: openshell.v1.OpenShell.GetSandboxProviderStatus:input_type -> openshell.v1.GetSandboxProviderStatusRequest - 70, // 358: openshell.v1.OpenShell.DeleteSandbox:input_type -> openshell.v1.DeleteSandboxRequest - 71, // 359: openshell.v1.OpenShell.StopSandbox:input_type -> openshell.v1.StopSandboxRequest - 72, // 360: openshell.v1.OpenShell.StartSandbox:input_type -> openshell.v1.StartSandboxRequest - 90, // 361: openshell.v1.OpenShell.CreateSshSession:input_type -> openshell.v1.CreateSshSessionRequest - 92, // 362: openshell.v1.OpenShell.ExposeService:input_type -> openshell.v1.ExposeServiceRequest - 93, // 363: openshell.v1.OpenShell.GetService:input_type -> openshell.v1.GetServiceRequest - 94, // 364: openshell.v1.OpenShell.ListServices:input_type -> openshell.v1.ListServicesRequest - 96, // 365: openshell.v1.OpenShell.DeleteService:input_type -> openshell.v1.DeleteServiceRequest - 100, // 366: openshell.v1.OpenShell.RevokeSshSession:input_type -> openshell.v1.RevokeSshSessionRequest - 102, // 367: openshell.v1.OpenShell.ExecSandbox:input_type -> openshell.v1.ExecSandboxRequest - 108, // 368: openshell.v1.OpenShell.ForwardTcp:input_type -> openshell.v1.TcpForwardFrame - 109, // 369: openshell.v1.OpenShell.ExecSandboxInteractive:input_type -> openshell.v1.ExecSandboxInput - 116, // 370: openshell.v1.OpenShell.CreateProvider:input_type -> openshell.v1.CreateProviderRequest - 117, // 371: openshell.v1.OpenShell.GetProvider:input_type -> openshell.v1.GetProviderRequest - 118, // 372: openshell.v1.OpenShell.GetProviderCredentials:input_type -> openshell.v1.GetProviderCredentialsRequest - 121, // 373: openshell.v1.OpenShell.ListProviders:input_type -> openshell.v1.ListProvidersRequest - 126, // 374: openshell.v1.OpenShell.ListProviderProfiles:input_type -> openshell.v1.ListProviderProfilesRequest - 127, // 375: openshell.v1.OpenShell.GetProviderProfile:input_type -> openshell.v1.GetProviderProfileRequest - 151, // 376: openshell.v1.OpenShell.ImportProviderProfiles:input_type -> openshell.v1.ImportProviderProfilesRequest - 153, // 377: openshell.v1.OpenShell.UpdateProviderProfiles:input_type -> openshell.v1.UpdateProviderProfilesRequest - 155, // 378: openshell.v1.OpenShell.LintProviderProfiles:input_type -> openshell.v1.LintProviderProfilesRequest - 122, // 379: openshell.v1.OpenShell.UpdateProvider:input_type -> openshell.v1.UpdateProviderRequest - 139, // 380: openshell.v1.OpenShell.GetProviderRefreshStatus:input_type -> openshell.v1.GetProviderRefreshStatusRequest - 141, // 381: openshell.v1.OpenShell.ConfigureProviderRefresh:input_type -> openshell.v1.ConfigureProviderRefreshRequest - 143, // 382: openshell.v1.OpenShell.RotateProviderCredential:input_type -> openshell.v1.RotateProviderCredentialRequest - 145, // 383: openshell.v1.OpenShell.DeleteProviderRefresh:input_type -> openshell.v1.DeleteProviderRefreshRequest - 123, // 384: openshell.v1.OpenShell.DeleteProvider:input_type -> openshell.v1.DeleteProviderRequest - 158, // 385: openshell.v1.OpenShell.DeleteProviderProfile:input_type -> openshell.v1.DeleteProviderProfileRequest - 301, // 386: openshell.v1.OpenShell.GetSandboxConfig:input_type -> openshell.sandbox.v1.GetSandboxConfigRequest - 302, // 387: openshell.v1.OpenShell.GetGatewayConfig:input_type -> openshell.sandbox.v1.GetGatewayConfigRequest - 166, // 388: openshell.v1.OpenShell.UpdateConfig:input_type -> openshell.v1.UpdateConfigRequest - 176, // 389: openshell.v1.OpenShell.GetSandboxPolicyStatus:input_type -> openshell.v1.GetSandboxPolicyStatusRequest - 178, // 390: openshell.v1.OpenShell.ListSandboxPolicies:input_type -> openshell.v1.ListSandboxPoliciesRequest - 180, // 391: openshell.v1.OpenShell.ReportPolicyStatus:input_type -> openshell.v1.ReportPolicyStatusRequest - 254, // 392: openshell.v1.OpenShell.ReportEndpointStatus:input_type -> openshell.v1.ReportEndpointStatusRequest - 87, // 393: openshell.v1.OpenShell.ReportProviderReadiness:input_type -> openshell.v1.ReportProviderReadinessRequest - 183, // 394: openshell.v1.OpenShell.ReportSandboxConfiguration:input_type -> openshell.v1.ReportSandboxConfigurationRequest - 160, // 395: openshell.v1.OpenShell.GetSandboxProviderEnvironment:input_type -> openshell.v1.GetSandboxProviderEnvironmentRequest - 164, // 396: openshell.v1.OpenShell.ExchangeProviderSubjectToken:input_type -> openshell.v1.ExchangeProviderSubjectTokenRequest - 186, // 397: openshell.v1.OpenShell.GetSandboxLogs:input_type -> openshell.v1.GetSandboxLogsRequest - 187, // 398: openshell.v1.OpenShell.PushSandboxLogs:input_type -> openshell.v1.PushSandboxLogsRequest - 190, // 399: openshell.v1.OpenShell.ConnectSupervisor:input_type -> openshell.v1.SupervisorMessage - 198, // 400: openshell.v1.OpenShell.ReportMainProcessExit:input_type -> openshell.v1.ReportMainProcessExitRequest - 200, // 401: openshell.v1.OpenShell.FinalizeMainProcessExit:input_type -> openshell.v1.FinalizeMainProcessExitRequest - 206, // 402: openshell.v1.OpenShell.RelayStream:input_type -> openshell.v1.RelayFrame - 208, // 403: openshell.v1.OpenShell.PeerRelay:input_type -> openshell.v1.PeerRelayFrame - 87, // 404: openshell.v1.OpenShell.PeerReportProviderReadiness:input_type -> openshell.v1.ReportProviderReadinessRequest - 254, // 405: openshell.v1.OpenShell.PeerReportEndpointStatus:input_type -> openshell.v1.ReportEndpointStatusRequest - 85, // 406: openshell.v1.OpenShell.PeerGetSandboxProviderStatus:input_type -> openshell.v1.GetSandboxProviderStatusRequest - 112, // 407: openshell.v1.OpenShell.WatchSandbox:input_type -> openshell.v1.WatchSandboxRequest - 217, // 408: openshell.v1.OpenShell.SubmitPolicyAnalysis:input_type -> openshell.v1.SubmitPolicyAnalysisRequest - 219, // 409: openshell.v1.OpenShell.GetDraftPolicy:input_type -> openshell.v1.GetDraftPolicyRequest - 221, // 410: openshell.v1.OpenShell.ApproveDraftChunk:input_type -> openshell.v1.ApproveDraftChunkRequest - 223, // 411: openshell.v1.OpenShell.RejectDraftChunk:input_type -> openshell.v1.RejectDraftChunkRequest - 226, // 412: openshell.v1.OpenShell.ApproveAllDraftChunks:input_type -> openshell.v1.ApproveAllDraftChunksRequest - 228, // 413: openshell.v1.OpenShell.EditDraftChunk:input_type -> openshell.v1.EditDraftChunkRequest - 230, // 414: openshell.v1.OpenShell.UndoDraftChunk:input_type -> openshell.v1.UndoDraftChunkRequest - 232, // 415: openshell.v1.OpenShell.ClearDraftChunks:input_type -> openshell.v1.ClearDraftChunksRequest - 234, // 416: openshell.v1.OpenShell.GetDraftHistory:input_type -> openshell.v1.GetDraftHistoryRequest - 21, // 417: openshell.v1.OpenShell.IssueSandboxToken:input_type -> openshell.v1.IssueSandboxTokenRequest - 23, // 418: openshell.v1.OpenShell.RefreshSandboxToken:input_type -> openshell.v1.RefreshSandboxTokenRequest - 237, // 419: openshell.v1.OpenShell.CreateWorkspace:input_type -> openshell.v1.CreateWorkspaceRequest - 239, // 420: openshell.v1.OpenShell.GetWorkspace:input_type -> openshell.v1.GetWorkspaceRequest - 241, // 421: openshell.v1.OpenShell.ListWorkspaces:input_type -> openshell.v1.ListWorkspacesRequest - 243, // 422: openshell.v1.OpenShell.DeleteWorkspace:input_type -> openshell.v1.DeleteWorkspaceRequest - 246, // 423: openshell.v1.OpenShell.AddWorkspaceMember:input_type -> openshell.v1.AddWorkspaceMemberRequest - 248, // 424: openshell.v1.OpenShell.RemoveWorkspaceMember:input_type -> openshell.v1.RemoveWorkspaceMemberRequest - 250, // 425: openshell.v1.OpenShell.ListWorkspaceMembers:input_type -> openshell.v1.ListWorkspaceMembersRequest - 26, // 426: openshell.v1.OpenShell.Health:output_type -> openshell.v1.HealthResponse - 28, // 427: openshell.v1.OpenShell.GetCurrentUser:output_type -> openshell.v1.GetCurrentUserResponse - 30, // 428: openshell.v1.OpenShell.GetGatewayInfo:output_type -> openshell.v1.GetGatewayInfoResponse - 73, // 429: openshell.v1.OpenShell.CreateSandbox:output_type -> openshell.v1.SandboxResponse - 73, // 430: openshell.v1.OpenShell.UpdateSandbox:output_type -> openshell.v1.SandboxResponse - 64, // 431: openshell.v1.OpenShell.BeginRootfsTarStaging:output_type -> openshell.v1.BeginRootfsTarStagingResponse - 73, // 432: openshell.v1.OpenShell.GetSandbox:output_type -> openshell.v1.SandboxResponse - 74, // 433: openshell.v1.OpenShell.ListSandboxes:output_type -> openshell.v1.ListSandboxesResponse - 60, // 434: openshell.v1.OpenShell.CreateSandboxTemplate:output_type -> openshell.v1.SandboxTemplateResponse - 60, // 435: openshell.v1.OpenShell.GetSandboxTemplate:output_type -> openshell.v1.SandboxTemplateResponse - 61, // 436: openshell.v1.OpenShell.ListSandboxTemplates:output_type -> openshell.v1.ListSandboxTemplatesResponse - 62, // 437: openshell.v1.OpenShell.DeleteSandboxTemplate:output_type -> openshell.v1.DeleteSandboxTemplateResponse - 75, // 438: openshell.v1.OpenShell.ListSandboxProviders:output_type -> openshell.v1.ListSandboxProvidersResponse - 76, // 439: openshell.v1.OpenShell.AttachSandboxProvider:output_type -> openshell.v1.AttachSandboxProviderResponse - 77, // 440: openshell.v1.OpenShell.DetachSandboxProvider:output_type -> openshell.v1.DetachSandboxProviderResponse - 86, // 441: openshell.v1.OpenShell.GetSandboxProviderStatus:output_type -> openshell.v1.GetSandboxProviderStatusResponse - 89, // 442: openshell.v1.OpenShell.DeleteSandbox:output_type -> openshell.v1.DeleteSandboxResponse - 73, // 443: openshell.v1.OpenShell.StopSandbox:output_type -> openshell.v1.SandboxResponse - 73, // 444: openshell.v1.OpenShell.StartSandbox:output_type -> openshell.v1.SandboxResponse - 91, // 445: openshell.v1.OpenShell.CreateSshSession:output_type -> openshell.v1.CreateSshSessionResponse - 99, // 446: openshell.v1.OpenShell.ExposeService:output_type -> openshell.v1.ServiceEndpointResponse - 99, // 447: openshell.v1.OpenShell.GetService:output_type -> openshell.v1.ServiceEndpointResponse - 95, // 448: openshell.v1.OpenShell.ListServices:output_type -> openshell.v1.ListServicesResponse - 97, // 449: openshell.v1.OpenShell.DeleteService:output_type -> openshell.v1.DeleteServiceResponse - 101, // 450: openshell.v1.OpenShell.RevokeSshSession:output_type -> openshell.v1.RevokeSshSessionResponse - 106, // 451: openshell.v1.OpenShell.ExecSandbox:output_type -> openshell.v1.ExecSandboxEvent - 108, // 452: openshell.v1.OpenShell.ForwardTcp:output_type -> openshell.v1.TcpForwardFrame - 106, // 453: openshell.v1.OpenShell.ExecSandboxInteractive:output_type -> openshell.v1.ExecSandboxEvent - 124, // 454: openshell.v1.OpenShell.CreateProvider:output_type -> openshell.v1.ProviderResponse - 124, // 455: openshell.v1.OpenShell.GetProvider:output_type -> openshell.v1.ProviderResponse - 120, // 456: openshell.v1.OpenShell.GetProviderCredentials:output_type -> openshell.v1.GetProviderCredentialsResponse - 125, // 457: openshell.v1.OpenShell.ListProviders:output_type -> openshell.v1.ListProvidersResponse - 150, // 458: openshell.v1.OpenShell.ListProviderProfiles:output_type -> openshell.v1.ListProviderProfilesResponse - 149, // 459: openshell.v1.OpenShell.GetProviderProfile:output_type -> openshell.v1.ProviderProfileResponse - 152, // 460: openshell.v1.OpenShell.ImportProviderProfiles:output_type -> openshell.v1.ImportProviderProfilesResponse - 154, // 461: openshell.v1.OpenShell.UpdateProviderProfiles:output_type -> openshell.v1.UpdateProviderProfilesResponse - 156, // 462: openshell.v1.OpenShell.LintProviderProfiles:output_type -> openshell.v1.LintProviderProfilesResponse - 124, // 463: openshell.v1.OpenShell.UpdateProvider:output_type -> openshell.v1.ProviderResponse - 140, // 464: openshell.v1.OpenShell.GetProviderRefreshStatus:output_type -> openshell.v1.GetProviderRefreshStatusResponse - 142, // 465: openshell.v1.OpenShell.ConfigureProviderRefresh:output_type -> openshell.v1.ConfigureProviderRefreshResponse - 144, // 466: openshell.v1.OpenShell.RotateProviderCredential:output_type -> openshell.v1.RotateProviderCredentialResponse - 146, // 467: openshell.v1.OpenShell.DeleteProviderRefresh:output_type -> openshell.v1.DeleteProviderRefreshResponse - 157, // 468: openshell.v1.OpenShell.DeleteProvider:output_type -> openshell.v1.DeleteProviderResponse - 159, // 469: openshell.v1.OpenShell.DeleteProviderProfile:output_type -> openshell.v1.DeleteProviderProfileResponse - 303, // 470: openshell.v1.OpenShell.GetSandboxConfig:output_type -> openshell.sandbox.v1.GetSandboxConfigResponse - 304, // 471: openshell.v1.OpenShell.GetGatewayConfig:output_type -> openshell.sandbox.v1.GetGatewayConfigResponse - 175, // 472: openshell.v1.OpenShell.UpdateConfig:output_type -> openshell.v1.UpdateConfigResponse - 177, // 473: openshell.v1.OpenShell.GetSandboxPolicyStatus:output_type -> openshell.v1.GetSandboxPolicyStatusResponse - 179, // 474: openshell.v1.OpenShell.ListSandboxPolicies:output_type -> openshell.v1.ListSandboxPoliciesResponse - 181, // 475: openshell.v1.OpenShell.ReportPolicyStatus:output_type -> openshell.v1.ReportPolicyStatusResponse - 257, // 476: openshell.v1.OpenShell.ReportEndpointStatus:output_type -> openshell.v1.ReportEndpointStatusResponse - 88, // 477: openshell.v1.OpenShell.ReportProviderReadiness:output_type -> openshell.v1.ReportProviderReadinessResponse - 184, // 478: openshell.v1.OpenShell.ReportSandboxConfiguration:output_type -> openshell.v1.ReportSandboxConfigurationResponse - 163, // 479: openshell.v1.OpenShell.GetSandboxProviderEnvironment:output_type -> openshell.v1.GetSandboxProviderEnvironmentResponse - 165, // 480: openshell.v1.OpenShell.ExchangeProviderSubjectToken:output_type -> openshell.v1.ExchangeProviderSubjectTokenResponse - 189, // 481: openshell.v1.OpenShell.GetSandboxLogs:output_type -> openshell.v1.GetSandboxLogsResponse - 188, // 482: openshell.v1.OpenShell.PushSandboxLogs:output_type -> openshell.v1.PushSandboxLogsResponse - 191, // 483: openshell.v1.OpenShell.ConnectSupervisor:output_type -> openshell.v1.GatewayMessage - 199, // 484: openshell.v1.OpenShell.ReportMainProcessExit:output_type -> openshell.v1.ReportMainProcessExitResponse - 201, // 485: openshell.v1.OpenShell.FinalizeMainProcessExit:output_type -> openshell.v1.FinalizeMainProcessExitResponse - 206, // 486: openshell.v1.OpenShell.RelayStream:output_type -> openshell.v1.RelayFrame - 208, // 487: openshell.v1.OpenShell.PeerRelay:output_type -> openshell.v1.PeerRelayFrame - 88, // 488: openshell.v1.OpenShell.PeerReportProviderReadiness:output_type -> openshell.v1.ReportProviderReadinessResponse - 257, // 489: openshell.v1.OpenShell.PeerReportEndpointStatus:output_type -> openshell.v1.ReportEndpointStatusResponse - 86, // 490: openshell.v1.OpenShell.PeerGetSandboxProviderStatus:output_type -> openshell.v1.GetSandboxProviderStatusResponse - 113, // 491: openshell.v1.OpenShell.WatchSandbox:output_type -> openshell.v1.SandboxStreamEvent - 218, // 492: openshell.v1.OpenShell.SubmitPolicyAnalysis:output_type -> openshell.v1.SubmitPolicyAnalysisResponse - 220, // 493: openshell.v1.OpenShell.GetDraftPolicy:output_type -> openshell.v1.GetDraftPolicyResponse - 222, // 494: openshell.v1.OpenShell.ApproveDraftChunk:output_type -> openshell.v1.ApproveDraftChunkResponse - 224, // 495: openshell.v1.OpenShell.RejectDraftChunk:output_type -> openshell.v1.RejectDraftChunkResponse - 227, // 496: openshell.v1.OpenShell.ApproveAllDraftChunks:output_type -> openshell.v1.ApproveAllDraftChunksResponse - 229, // 497: openshell.v1.OpenShell.EditDraftChunk:output_type -> openshell.v1.EditDraftChunkResponse - 231, // 498: openshell.v1.OpenShell.UndoDraftChunk:output_type -> openshell.v1.UndoDraftChunkResponse - 233, // 499: openshell.v1.OpenShell.ClearDraftChunks:output_type -> openshell.v1.ClearDraftChunksResponse - 236, // 500: openshell.v1.OpenShell.GetDraftHistory:output_type -> openshell.v1.GetDraftHistoryResponse - 22, // 501: openshell.v1.OpenShell.IssueSandboxToken:output_type -> openshell.v1.IssueSandboxTokenResponse - 24, // 502: openshell.v1.OpenShell.RefreshSandboxToken:output_type -> openshell.v1.RefreshSandboxTokenResponse - 238, // 503: openshell.v1.OpenShell.CreateWorkspace:output_type -> openshell.v1.CreateWorkspaceResponse - 240, // 504: openshell.v1.OpenShell.GetWorkspace:output_type -> openshell.v1.GetWorkspaceResponse - 242, // 505: openshell.v1.OpenShell.ListWorkspaces:output_type -> openshell.v1.ListWorkspacesResponse - 244, // 506: openshell.v1.OpenShell.DeleteWorkspace:output_type -> openshell.v1.DeleteWorkspaceResponse - 247, // 507: openshell.v1.OpenShell.AddWorkspaceMember:output_type -> openshell.v1.AddWorkspaceMemberResponse - 249, // 508: openshell.v1.OpenShell.RemoveWorkspaceMember:output_type -> openshell.v1.RemoveWorkspaceMemberResponse - 251, // 509: openshell.v1.OpenShell.ListWorkspaceMembers:output_type -> openshell.v1.ListWorkspaceMembersResponse - 426, // [426:510] is the sub-list for method output_type - 342, // [342:426] is the sub-list for method input_type - 342, // [342:342] is the sub-list for extension type_name - 342, // [342:342] is the sub-list for extension extendee - 0, // [0:342] is the sub-list for field type_name + 257, // 41: openshell.v1.SandboxStatus.endpoint_statuses:type_name -> openshell.v1.EndpointStatus + 181, // 42: openshell.v1.SandboxStatus.configuration_admission:type_name -> openshell.v1.SandboxConfigurationAdmission + 258, // 43: openshell.v1.SandboxStatus.provisioning:type_name -> openshell.v1.SandboxProvisioning + 285, // 44: openshell.v1.SandboxStatus.next_restart_time:type_name -> google.protobuf.Timestamp + 285, // 45: openshell.v1.SandboxStatus.main_process_started_time:type_name -> google.protobuf.Timestamp + 255, // 46: openshell.v1.SandboxStatus.last_token_grant_failure:type_name -> openshell.v1.TokenGrantFailureObservation + 285, // 47: openshell.v1.SandboxCondition.transition_time:type_name -> google.protobuf.Timestamp + 285, // 48: openshell.v1.PlatformEvent.event_time:type_name -> google.protobuf.Timestamp + 266, // 49: openshell.v1.PlatformEvent.metadata:type_name -> openshell.v1.PlatformEvent.MetadataEntry + 290, // 50: openshell.v1.CreateSandboxRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 39, // 51: openshell.v1.CreateSandboxRequest.spec:type_name -> openshell.v1.SandboxSpec + 267, // 52: openshell.v1.CreateSandboxRequest.labels:type_name -> openshell.v1.CreateSandboxRequest.LabelsEntry + 268, // 53: openshell.v1.CreateSandboxRequest.annotations:type_name -> openshell.v1.CreateSandboxRequest.AnnotationsEntry + 259, // 54: openshell.v1.CreateSandboxRequest.service_exposures:type_name -> openshell.v1.SandboxServiceExposure + 290, // 55: openshell.v1.UpdateSandboxRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 290, // 56: openshell.v1.CreateSandboxTemplateRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 43, // 57: openshell.v1.CreateSandboxTemplateRequest.template:type_name -> openshell.v1.SandboxWorkloadTemplate + 290, // 58: openshell.v1.GetSandboxTemplateRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 290, // 59: openshell.v1.ListSandboxTemplatesRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 290, // 60: openshell.v1.DeleteSandboxTemplateRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 43, // 61: openshell.v1.SandboxTemplateResponse.template:type_name -> openshell.v1.SandboxWorkloadTemplate + 43, // 62: openshell.v1.ListSandboxTemplatesResponse.templates:type_name -> openshell.v1.SandboxWorkloadTemplate + 17, // 63: openshell.v1.DeleteSandboxTemplateResponse.outcome:type_name -> openshell.v1.DeletionOutcome + 290, // 64: openshell.v1.BeginRootfsTarStagingRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 285, // 65: openshell.v1.BeginRootfsTarStagingResponse.expiration_time:type_name -> google.protobuf.Timestamp + 290, // 66: openshell.v1.GetSandboxRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 290, // 67: openshell.v1.ListSandboxesRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 290, // 68: openshell.v1.ListSandboxProvidersRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 290, // 69: openshell.v1.AttachSandboxProviderRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 290, // 70: openshell.v1.DetachSandboxProviderRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 290, // 71: openshell.v1.DeleteSandboxRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 290, // 72: openshell.v1.StopSandboxRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 290, // 73: openshell.v1.StartSandboxRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 38, // 74: openshell.v1.SandboxResponse.sandbox:type_name -> openshell.v1.Sandbox + 269, // 75: openshell.v1.SandboxResponse.service_urls:type_name -> openshell.v1.SandboxResponse.ServiceUrlsEntry + 38, // 76: openshell.v1.ListSandboxesResponse.sandboxes:type_name -> openshell.v1.Sandbox + 291, // 77: openshell.v1.ListSandboxProvidersResponse.providers:type_name -> openshell.datamodel.v1.Provider + 38, // 78: openshell.v1.AttachSandboxProviderResponse.sandbox:type_name -> openshell.v1.Sandbox + 81, // 79: openshell.v1.AttachSandboxProviderResponse.receipt:type_name -> openshell.v1.ProviderMutationReceipt + 38, // 80: openshell.v1.DetachSandboxProviderResponse.sandbox:type_name -> openshell.v1.Sandbox + 81, // 81: openshell.v1.DetachSandboxProviderResponse.receipt:type_name -> openshell.v1.ProviderMutationReceipt + 79, // 82: openshell.v1.ConfigSnapshotRevision.sandbox_config:type_name -> openshell.v1.SandboxConfigRevision + 77, // 83: openshell.v1.ConfigSnapshotRevision.provider_target:type_name -> openshell.v1.ProviderDesiredIdentity + 292, // 84: openshell.v1.SandboxConfigRevision.policy_source:type_name -> openshell.sandbox.v1.PolicySource + 5, // 85: openshell.v1.ConfigUpdateOperation.component:type_name -> openshell.v1.ConfigComponent + 78, // 86: openshell.v1.ConfigUpdateOperation.target_revision:type_name -> openshell.v1.ConfigSnapshotRevision + 7, // 87: openshell.v1.ConfigUpdateOperation.state:type_name -> openshell.v1.ConfigUpdateOperationState + 6, // 88: openshell.v1.ConfigUpdateOperation.outcome:type_name -> openshell.v1.ConfigApplyOutcome + 285, // 89: openshell.v1.ConfigUpdateOperation.created_time:type_name -> google.protobuf.Timestamp + 285, // 90: openshell.v1.ConfigUpdateOperation.updated_time:type_name -> google.protobuf.Timestamp + 285, // 91: openshell.v1.ConfigUpdateOperation.completed_time:type_name -> google.protobuf.Timestamp + 2, // 92: openshell.v1.ProviderMutationReceipt.kind:type_name -> openshell.v1.ProviderMutationKind + 77, // 93: openshell.v1.ProviderMutationReceipt.desired:type_name -> openshell.v1.ProviderDesiredIdentity + 285, // 94: openshell.v1.ProviderMutationReceipt.persisted_time:type_name -> google.protobuf.Timestamp + 4, // 95: openshell.v1.ProviderReadinessObservation.reason:type_name -> openshell.v1.ProviderReadinessReason + 81, // 96: openshell.v1.ProviderReadinessStatus.receipt:type_name -> openshell.v1.ProviderMutationReceipt + 3, // 97: openshell.v1.ProviderReadinessStatus.state:type_name -> openshell.v1.ProviderReadinessState + 4, // 98: openshell.v1.ProviderReadinessStatus.reason:type_name -> openshell.v1.ProviderReadinessReason + 82, // 99: openshell.v1.ProviderReadinessStatus.observed:type_name -> openshell.v1.ProviderReadinessObservation + 285, // 100: openshell.v1.ProviderReadinessStatus.observed_time:type_name -> google.protobuf.Timestamp + 285, // 101: openshell.v1.ProviderReadinessStatus.evaluated_time:type_name -> google.protobuf.Timestamp + 80, // 102: openshell.v1.ProviderReadinessStatus.operation:type_name -> openshell.v1.ConfigUpdateOperation + 290, // 103: openshell.v1.GetSandboxProviderStatusRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 83, // 104: openshell.v1.GetSandboxProviderStatusResponse.status:type_name -> openshell.v1.ProviderReadinessStatus + 82, // 105: openshell.v1.ReportProviderReadinessRequest.observation:type_name -> openshell.v1.ProviderReadinessObservation + 289, // 106: openshell.v1.ReportProviderReadinessResponse.report_interval:type_name -> google.protobuf.Duration + 289, // 107: openshell.v1.ReportProviderReadinessResponse.observation_ttl:type_name -> google.protobuf.Duration + 17, // 108: openshell.v1.DeleteSandboxResponse.outcome:type_name -> openshell.v1.DeletionOutcome + 290, // 109: openshell.v1.CreateSshSessionRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 285, // 110: openshell.v1.CreateSshSessionResponse.expiration_time:type_name -> google.protobuf.Timestamp + 290, // 111: openshell.v1.ExposeServiceRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 19, // 112: openshell.v1.ExposeServiceRequest.authorization_mode:type_name -> openshell.v1.ServiceAuthorizationMode + 290, // 113: openshell.v1.GetServiceRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 290, // 114: openshell.v1.ListServicesRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 98, // 115: openshell.v1.ListServicesResponse.services:type_name -> openshell.v1.ServiceEndpointResponse + 290, // 116: openshell.v1.DeleteServiceRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 17, // 117: openshell.v1.DeleteServiceResponse.outcome:type_name -> openshell.v1.DeletionOutcome + 286, // 118: openshell.v1.ServiceEndpoint.metadata:type_name -> openshell.datamodel.v1.ObjectMeta + 19, // 119: openshell.v1.ServiceEndpoint.authorization_mode:type_name -> openshell.v1.ServiceAuthorizationMode + 97, // 120: openshell.v1.ServiceEndpointResponse.endpoint:type_name -> openshell.v1.ServiceEndpoint + 17, // 121: openshell.v1.RevokeSshSessionResponse.outcome:type_name -> openshell.v1.DeletionOutcome + 290, // 122: openshell.v1.ExecSandboxRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 270, // 123: openshell.v1.ExecSandboxRequest.environment:type_name -> openshell.v1.ExecSandboxRequest.EnvironmentEntry + 289, // 124: openshell.v1.ExecSandboxRequest.execution_timeout:type_name -> google.protobuf.Duration + 102, // 125: openshell.v1.ExecSandboxEvent.stdout:type_name -> openshell.v1.ExecSandboxStdout + 103, // 126: openshell.v1.ExecSandboxEvent.stderr:type_name -> openshell.v1.ExecSandboxStderr + 104, // 127: openshell.v1.ExecSandboxEvent.exit:type_name -> openshell.v1.ExecSandboxExit + 202, // 128: openshell.v1.TcpForwardInit.ssh:type_name -> openshell.v1.SshRelayTarget + 203, // 129: openshell.v1.TcpForwardInit.tcp:type_name -> openshell.v1.TcpRelayTarget + 106, // 130: openshell.v1.TcpForwardFrame.init:type_name -> openshell.v1.TcpForwardInit + 101, // 131: openshell.v1.ExecSandboxInput.start:type_name -> openshell.v1.ExecSandboxRequest + 109, // 132: openshell.v1.ExecSandboxInput.resize:type_name -> openshell.v1.ExecSandboxWindowResize + 286, // 133: openshell.v1.SshSession.metadata:type_name -> openshell.datamodel.v1.ObjectMeta + 285, // 134: openshell.v1.SshSession.expiration_time:type_name -> google.protobuf.Timestamp + 290, // 135: openshell.v1.WatchSandboxRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 285, // 136: openshell.v1.WatchSandboxRequest.since_time:type_name -> google.protobuf.Timestamp + 38, // 137: openshell.v1.SandboxStreamEvent.sandbox:type_name -> openshell.v1.Sandbox + 113, // 138: openshell.v1.SandboxStreamEvent.log:type_name -> openshell.v1.SandboxLogLine + 52, // 139: openshell.v1.SandboxStreamEvent.event:type_name -> openshell.v1.PlatformEvent + 114, // 140: openshell.v1.SandboxStreamEvent.warning:type_name -> openshell.v1.SandboxStreamWarning + 215, // 141: openshell.v1.SandboxStreamEvent.draft_policy_update:type_name -> openshell.v1.DraftPolicyUpdate + 285, // 142: openshell.v1.SandboxLogLine.event_time:type_name -> google.protobuf.Timestamp + 271, // 143: openshell.v1.SandboxLogLine.fields:type_name -> openshell.v1.SandboxLogLine.FieldsEntry + 290, // 144: openshell.v1.CreateProviderRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 291, // 145: openshell.v1.CreateProviderRequest.provider:type_name -> openshell.datamodel.v1.Provider + 290, // 146: openshell.v1.GetProviderRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 290, // 147: openshell.v1.GetProviderCredentialsRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 289, // 148: openshell.v1.GetProviderCredentialsRequest.minimum_remaining_lifetime:type_name -> google.protobuf.Duration + 285, // 149: openshell.v1.ProviderCredentialValue.expiration_time:type_name -> google.protobuf.Timestamp + 272, // 150: openshell.v1.GetProviderCredentialsResponse.credentials:type_name -> openshell.v1.GetProviderCredentialsResponse.CredentialsEntry + 290, // 151: openshell.v1.ListProvidersRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 290, // 152: openshell.v1.UpdateProviderRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 291, // 153: openshell.v1.UpdateProviderRequest.provider:type_name -> openshell.datamodel.v1.Provider + 273, // 154: openshell.v1.UpdateProviderRequest.credential_expiration_times:type_name -> openshell.v1.UpdateProviderRequest.CredentialExpirationTimesEntry + 290, // 155: openshell.v1.DeleteProviderRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 291, // 156: openshell.v1.ProviderResponse.provider:type_name -> openshell.datamodel.v1.Provider + 81, // 157: openshell.v1.ProviderResponse.target_receipts:type_name -> openshell.v1.ProviderMutationReceipt + 291, // 158: openshell.v1.ListProvidersResponse.providers:type_name -> openshell.datamodel.v1.Provider + 290, // 159: openshell.v1.ListProviderProfilesRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 290, // 160: openshell.v1.GetProviderProfileRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 146, // 161: openshell.v1.ProviderProfileImportItem.profile:type_name -> openshell.v1.ProviderProfile + 289, // 162: openshell.v1.ProviderCredentialTokenGrant.cache_ttl:type_name -> google.protobuf.Duration + 129, // 163: openshell.v1.ProviderCredentialTokenGrant.audience_overrides:type_name -> openshell.v1.ProviderCredentialTokenGrantAudienceOverride + 8, // 164: openshell.v1.ProviderCredentialTokenGrant.grant_type:type_name -> openshell.v1.ProviderCredentialTokenGrantType + 130, // 165: openshell.v1.ProviderCredentialTokenGrant.subject_token:type_name -> openshell.v1.ProviderCredentialTokenGrantSubjectToken + 135, // 166: openshell.v1.ProviderProfileCredential.refresh:type_name -> openshell.v1.ProviderCredentialRefresh + 131, // 167: openshell.v1.ProviderProfileCredential.token_grant:type_name -> openshell.v1.ProviderCredentialTokenGrant + 9, // 168: openshell.v1.ProviderCredentialRefresh.strategy:type_name -> openshell.v1.ProviderCredentialRefreshStrategy + 289, // 169: openshell.v1.ProviderCredentialRefresh.refresh_before:type_name -> google.protobuf.Duration + 289, // 170: openshell.v1.ProviderCredentialRefresh.max_lifetime:type_name -> google.protobuf.Duration + 133, // 171: openshell.v1.ProviderCredentialRefresh.material:type_name -> openshell.v1.ProviderCredentialRefreshMaterial + 134, // 172: openshell.v1.ProviderCredentialRefresh.additional_outputs:type_name -> openshell.v1.ProviderCredentialRefreshOutput + 9, // 173: openshell.v1.ProviderCredentialRefreshStatus.strategy:type_name -> openshell.v1.ProviderCredentialRefreshStrategy + 285, // 174: openshell.v1.ProviderCredentialRefreshStatus.expiration_time:type_name -> google.protobuf.Timestamp + 285, // 175: openshell.v1.ProviderCredentialRefreshStatus.next_refresh_time:type_name -> google.protobuf.Timestamp + 285, // 176: openshell.v1.ProviderCredentialRefreshStatus.last_refresh_time:type_name -> google.protobuf.Timestamp + 15, // 177: openshell.v1.ProviderCredentialRefreshStatus.recovery_action:type_name -> openshell.v1.ProviderCredentialRefreshRecoveryAction + 285, // 178: openshell.v1.ProviderCredentialRefreshStatus.last_error_time:type_name -> google.protobuf.Timestamp + 290, // 179: openshell.v1.GetProviderRefreshStatusRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 136, // 180: openshell.v1.GetProviderRefreshStatusResponse.credentials:type_name -> openshell.v1.ProviderCredentialRefreshStatus + 290, // 181: openshell.v1.ConfigureProviderRefreshRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 9, // 182: openshell.v1.ConfigureProviderRefreshRequest.strategy:type_name -> openshell.v1.ProviderCredentialRefreshStrategy + 274, // 183: openshell.v1.ConfigureProviderRefreshRequest.material:type_name -> openshell.v1.ConfigureProviderRefreshRequest.MaterialEntry + 285, // 184: openshell.v1.ConfigureProviderRefreshRequest.expiration_time:type_name -> google.protobuf.Timestamp + 136, // 185: openshell.v1.ConfigureProviderRefreshResponse.status:type_name -> openshell.v1.ProviderCredentialRefreshStatus + 290, // 186: openshell.v1.RotateProviderCredentialRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 136, // 187: openshell.v1.RotateProviderCredentialResponse.status:type_name -> openshell.v1.ProviderCredentialRefreshStatus + 290, // 188: openshell.v1.DeleteProviderRefreshRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 17, // 189: openshell.v1.DeleteProviderRefreshResponse.outcome:type_name -> openshell.v1.DeletionOutcome + 10, // 190: openshell.v1.ProviderProfile.category:type_name -> openshell.v1.ProviderProfileCategory + 132, // 191: openshell.v1.ProviderProfile.credentials:type_name -> openshell.v1.ProviderProfileCredential + 293, // 192: openshell.v1.ProviderProfile.endpoints:type_name -> openshell.sandbox.v1.NetworkEndpoint + 294, // 193: openshell.v1.ProviderProfile.binaries:type_name -> openshell.sandbox.v1.NetworkBinary + 137, // 194: openshell.v1.ProviderProfile.discovery:type_name -> openshell.v1.ProviderProfileDiscovery + 275, // 195: openshell.v1.ProviderProfile.annotations:type_name -> openshell.v1.ProviderProfile.AnnotationsEntry + 147, // 196: openshell.v1.ProviderProfile.files:type_name -> openshell.v1.ProviderProfileFile + 146, // 197: openshell.v1.ProviderProfileResponse.profile:type_name -> openshell.v1.ProviderProfile + 146, // 198: openshell.v1.ListProviderProfilesResponse.profiles:type_name -> openshell.v1.ProviderProfile + 290, // 199: openshell.v1.ImportProviderProfilesRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 127, // 200: openshell.v1.ImportProviderProfilesRequest.profiles:type_name -> openshell.v1.ProviderProfileImportItem + 128, // 201: openshell.v1.ImportProviderProfilesResponse.diagnostics:type_name -> openshell.v1.ProviderProfileDiagnostic + 146, // 202: openshell.v1.ImportProviderProfilesResponse.profiles:type_name -> openshell.v1.ProviderProfile + 290, // 203: openshell.v1.UpdateProviderProfilesRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 127, // 204: openshell.v1.UpdateProviderProfilesRequest.profile:type_name -> openshell.v1.ProviderProfileImportItem + 128, // 205: openshell.v1.UpdateProviderProfilesResponse.diagnostics:type_name -> openshell.v1.ProviderProfileDiagnostic + 146, // 206: openshell.v1.UpdateProviderProfilesResponse.profile:type_name -> openshell.v1.ProviderProfile + 290, // 207: openshell.v1.LintProviderProfilesRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 127, // 208: openshell.v1.LintProviderProfilesRequest.profiles:type_name -> openshell.v1.ProviderProfileImportItem + 128, // 209: openshell.v1.LintProviderProfilesResponse.diagnostics:type_name -> openshell.v1.ProviderProfileDiagnostic + 17, // 210: openshell.v1.DeleteProviderResponse.outcome:type_name -> openshell.v1.DeletionOutcome + 290, // 211: openshell.v1.DeleteProviderProfileRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 17, // 212: openshell.v1.DeleteProviderProfileResponse.outcome:type_name -> openshell.v1.DeletionOutcome + 160, // 213: openshell.v1.StaticCredentialBinding.endpoints:type_name -> openshell.v1.StaticCredentialEndpointBinding + 276, // 214: openshell.v1.GetSandboxProviderEnvironmentResponse.environment:type_name -> openshell.v1.GetSandboxProviderEnvironmentResponse.EnvironmentEntry + 277, // 215: openshell.v1.GetSandboxProviderEnvironmentResponse.credential_expiration_times:type_name -> openshell.v1.GetSandboxProviderEnvironmentResponse.CredentialExpirationTimesEntry + 278, // 216: openshell.v1.GetSandboxProviderEnvironmentResponse.dynamic_credentials:type_name -> openshell.v1.GetSandboxProviderEnvironmentResponse.DynamicCredentialsEntry + 279, // 217: openshell.v1.GetSandboxProviderEnvironmentResponse.static_credential_bindings:type_name -> openshell.v1.GetSandboxProviderEnvironmentResponse.StaticCredentialBindingsEntry + 4, // 218: openshell.v1.GetSandboxProviderEnvironmentResponse.readiness_reason:type_name -> openshell.v1.ProviderReadinessReason + 280, // 219: openshell.v1.GetSandboxProviderEnvironmentResponse.files:type_name -> openshell.v1.GetSandboxProviderEnvironmentResponse.FilesEntry + 289, // 220: openshell.v1.ExchangeProviderSubjectTokenResponse.expires_after:type_name -> google.protobuf.Duration + 290, // 221: openshell.v1.UpdateConfigRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 287, // 222: openshell.v1.UpdateConfigRequest.policy:type_name -> openshell.sandbox.v1.SandboxPolicy + 295, // 223: openshell.v1.UpdateConfigRequest.setting_value:type_name -> openshell.sandbox.v1.SettingValue + 166, // 224: openshell.v1.UpdateConfigRequest.merge_operations:type_name -> openshell.v1.PolicyMergeOperation + 281, // 225: openshell.v1.UpdateConfigRequest.annotations:type_name -> openshell.v1.UpdateConfigRequest.AnnotationsEntry + 167, // 226: openshell.v1.PolicyMergeOperation.add_rule:type_name -> openshell.v1.AddNetworkRule + 168, // 227: openshell.v1.PolicyMergeOperation.remove_endpoint:type_name -> openshell.v1.RemoveNetworkEndpoint + 169, // 228: openshell.v1.PolicyMergeOperation.remove_rule:type_name -> openshell.v1.RemoveNetworkRule + 171, // 229: openshell.v1.PolicyMergeOperation.add_deny_rules:type_name -> openshell.v1.AddDenyRules + 172, // 230: openshell.v1.PolicyMergeOperation.add_allow_rules:type_name -> openshell.v1.AddAllowRules + 173, // 231: openshell.v1.PolicyMergeOperation.remove_binary:type_name -> openshell.v1.RemoveNetworkBinary + 296, // 232: openshell.v1.AddNetworkRule.rule:type_name -> openshell.sandbox.v1.NetworkPolicyRule + 294, // 233: openshell.v1.L7RuleTarget.binaries:type_name -> openshell.sandbox.v1.NetworkBinary + 297, // 234: openshell.v1.AddDenyRules.deny_rules:type_name -> openshell.sandbox.v1.L7DenyRule + 170, // 235: openshell.v1.AddDenyRules.target:type_name -> openshell.v1.L7RuleTarget + 298, // 236: openshell.v1.AddAllowRules.rules:type_name -> openshell.sandbox.v1.L7Rule + 170, // 237: openshell.v1.AddAllowRules.target:type_name -> openshell.v1.L7RuleTarget + 282, // 238: openshell.v1.UpdateConfigResponse.annotations:type_name -> openshell.v1.UpdateConfigResponse.AnnotationsEntry + 290, // 239: openshell.v1.GetSandboxPolicyStatusRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 184, // 240: openshell.v1.GetSandboxPolicyStatusResponse.revision:type_name -> openshell.v1.SandboxPolicyRevision + 290, // 241: openshell.v1.ListSandboxPoliciesRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 184, // 242: openshell.v1.ListSandboxPoliciesResponse.revisions:type_name -> openshell.v1.SandboxPolicyRevision + 12, // 243: openshell.v1.ReportPolicyStatusRequest.status:type_name -> openshell.v1.PolicyStatus + 11, // 244: openshell.v1.SandboxConfigurationAdmission.state:type_name -> openshell.v1.ConfigurationAdmissionState + 181, // 245: openshell.v1.ReportSandboxConfigurationRequest.admission:type_name -> openshell.v1.SandboxConfigurationAdmission + 12, // 246: openshell.v1.SandboxPolicyRevision.status:type_name -> openshell.v1.PolicyStatus + 285, // 247: openshell.v1.SandboxPolicyRevision.created_time:type_name -> google.protobuf.Timestamp + 285, // 248: openshell.v1.SandboxPolicyRevision.loaded_time:type_name -> google.protobuf.Timestamp + 287, // 249: openshell.v1.SandboxPolicyRevision.policy:type_name -> openshell.sandbox.v1.SandboxPolicy + 283, // 250: openshell.v1.SandboxPolicyRevision.provenance:type_name -> openshell.v1.SandboxPolicyRevision.ProvenanceEntry + 290, // 251: openshell.v1.GetSandboxLogsRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 285, // 252: openshell.v1.GetSandboxLogsRequest.since_time:type_name -> google.protobuf.Timestamp + 113, // 253: openshell.v1.PushSandboxLogsRequest.logs:type_name -> openshell.v1.SandboxLogLine + 113, // 254: openshell.v1.GetSandboxLogsResponse.logs:type_name -> openshell.v1.SandboxLogLine + 191, // 255: openshell.v1.SupervisorMessage.hello:type_name -> openshell.v1.SupervisorHello + 195, // 256: openshell.v1.SupervisorMessage.heartbeat:type_name -> openshell.v1.SupervisorHeartbeat + 208, // 257: openshell.v1.SupervisorMessage.relay_open_result:type_name -> openshell.v1.RelayOpenResult + 209, // 258: openshell.v1.SupervisorMessage.relay_close:type_name -> openshell.v1.RelayClose + 192, // 259: openshell.v1.GatewayMessage.session_accepted:type_name -> openshell.v1.SessionAccepted + 193, // 260: openshell.v1.GatewayMessage.session_rejected:type_name -> openshell.v1.SessionRejected + 196, // 261: openshell.v1.GatewayMessage.heartbeat:type_name -> openshell.v1.GatewayHeartbeat + 201, // 262: openshell.v1.GatewayMessage.relay_open:type_name -> openshell.v1.RelayOpen + 209, // 263: openshell.v1.GatewayMessage.relay_close:type_name -> openshell.v1.RelayClose + 194, // 264: openshell.v1.GatewayMessage.session_redirect:type_name -> openshell.v1.SessionRedirect + 289, // 265: openshell.v1.SessionAccepted.heartbeat_interval:type_name -> google.protobuf.Duration + 202, // 266: openshell.v1.RelayOpen.ssh:type_name -> openshell.v1.SshRelayTarget + 203, // 267: openshell.v1.RelayOpen.tcp:type_name -> openshell.v1.TcpRelayTarget + 204, // 268: openshell.v1.RelayFrame.init:type_name -> openshell.v1.RelayInit + 201, // 269: openshell.v1.PeerRelayInit.relay_open:type_name -> openshell.v1.RelayOpen + 206, // 270: openshell.v1.PeerRelayFrame.init:type_name -> openshell.v1.PeerRelayInit + 285, // 271: openshell.v1.DenialSummary.first_seen_time:type_name -> google.protobuf.Timestamp + 285, // 272: openshell.v1.DenialSummary.last_seen_time:type_name -> google.protobuf.Timestamp + 210, // 273: openshell.v1.DenialSummary.l7_request_samples:type_name -> openshell.v1.L7RequestSample + 212, // 274: openshell.v1.NetworkActivitySummary.denials_by_group:type_name -> openshell.v1.DenialGroupCount + 296, // 275: openshell.v1.PolicyChunk.proposed_rule:type_name -> openshell.sandbox.v1.NetworkPolicyRule + 285, // 276: openshell.v1.PolicyChunk.created_time:type_name -> google.protobuf.Timestamp + 285, // 277: openshell.v1.PolicyChunk.decided_time:type_name -> google.protobuf.Timestamp + 285, // 278: openshell.v1.PolicyChunk.first_seen_time:type_name -> google.protobuf.Timestamp + 285, // 279: openshell.v1.PolicyChunk.last_seen_time:type_name -> google.protobuf.Timestamp + 287, // 280: openshell.v1.PolicyChunk.current_effective_policy:type_name -> openshell.sandbox.v1.SandboxPolicy + 287, // 281: openshell.v1.PolicyChunk.candidate_effective_policy:type_name -> openshell.sandbox.v1.SandboxPolicy + 290, // 282: openshell.v1.SubmitPolicyAnalysisRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 211, // 283: openshell.v1.SubmitPolicyAnalysisRequest.summaries:type_name -> openshell.v1.DenialSummary + 214, // 284: openshell.v1.SubmitPolicyAnalysisRequest.proposed_chunks:type_name -> openshell.v1.PolicyChunk + 213, // 285: openshell.v1.SubmitPolicyAnalysisRequest.network_activity_summaries:type_name -> openshell.v1.NetworkActivitySummary + 290, // 286: openshell.v1.GetDraftPolicyRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 214, // 287: openshell.v1.GetDraftPolicyResponse.chunks:type_name -> openshell.v1.PolicyChunk + 285, // 288: openshell.v1.GetDraftPolicyResponse.last_analyzed_time:type_name -> google.protobuf.Timestamp + 290, // 289: openshell.v1.ApproveDraftChunkRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 290, // 290: openshell.v1.RejectDraftChunkRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 290, // 291: openshell.v1.ApproveAllDraftChunksRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 224, // 292: openshell.v1.ApproveAllDraftChunksRequest.approvals:type_name -> openshell.v1.DraftChunkApproval + 290, // 293: openshell.v1.EditDraftChunkRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 296, // 294: openshell.v1.EditDraftChunkRequest.proposed_rule:type_name -> openshell.sandbox.v1.NetworkPolicyRule + 290, // 295: openshell.v1.UndoDraftChunkRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 290, // 296: openshell.v1.ClearDraftChunksRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 290, // 297: openshell.v1.GetDraftHistoryRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 285, // 298: openshell.v1.DraftHistoryEntry.event_time:type_name -> google.protobuf.Timestamp + 234, // 299: openshell.v1.GetDraftHistoryResponse.entries:type_name -> openshell.v1.DraftHistoryEntry + 284, // 300: openshell.v1.CreateWorkspaceRequest.labels:type_name -> openshell.v1.CreateWorkspaceRequest.LabelsEntry + 299, // 301: openshell.v1.CreateWorkspaceResponse.workspace:type_name -> openshell.datamodel.v1.Workspace + 299, // 302: openshell.v1.GetWorkspaceResponse.workspace:type_name -> openshell.datamodel.v1.Workspace + 299, // 303: openshell.v1.ListWorkspacesResponse.workspaces:type_name -> openshell.datamodel.v1.Workspace + 17, // 304: openshell.v1.DeleteWorkspaceResponse.outcome:type_name -> openshell.v1.DeletionOutcome + 286, // 305: openshell.v1.WorkspaceMember.metadata:type_name -> openshell.datamodel.v1.ObjectMeta + 14, // 306: openshell.v1.WorkspaceMember.role:type_name -> openshell.v1.WorkspaceRole + 290, // 307: openshell.v1.AddWorkspaceMemberRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 14, // 308: openshell.v1.AddWorkspaceMemberRequest.role:type_name -> openshell.v1.WorkspaceRole + 244, // 309: openshell.v1.AddWorkspaceMemberResponse.member:type_name -> openshell.v1.WorkspaceMember + 290, // 310: openshell.v1.RemoveWorkspaceMemberRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 17, // 311: openshell.v1.RemoveWorkspaceMemberResponse.outcome:type_name -> openshell.v1.DeletionOutcome + 290, // 312: openshell.v1.ListWorkspaceMembersRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 244, // 313: openshell.v1.ListWorkspaceMembersResponse.members:type_name -> openshell.v1.WorkspaceMember + 285, // 314: openshell.v1.ExtensionServiceCredential.expiration_time:type_name -> google.protobuf.Timestamp + 18, // 315: openshell.v1.EndpointObservation.result:type_name -> openshell.v1.EndpointResult + 260, // 316: openshell.v1.EndpointObservation.failure:type_name -> openshell.v1.EndpointFailure + 252, // 317: openshell.v1.ReportEndpointStatusRequest.observations:type_name -> openshell.v1.EndpointObservation + 254, // 318: openshell.v1.ReportEndpointStatusRequest.token_grant_status:type_name -> openshell.v1.TokenGrantStatus + 255, // 319: openshell.v1.TokenGrantStatus.last_failure:type_name -> openshell.v1.TokenGrantFailureObservation + 260, // 320: openshell.v1.TokenGrantFailureObservation.failure:type_name -> openshell.v1.EndpointFailure + 18, // 321: openshell.v1.EndpointStatus.last_result:type_name -> openshell.v1.EndpointResult + 285, // 322: openshell.v1.EndpointStatus.last_reported_time:type_name -> google.protobuf.Timestamp + 260, // 323: openshell.v1.EndpointStatus.last_failure:type_name -> openshell.v1.EndpointFailure + 285, // 324: openshell.v1.SandboxProvisioning.configuration_change_time:type_name -> google.protobuf.Timestamp + 285, // 325: openshell.v1.SandboxProvisioning.first_rejection_time:type_name -> google.protobuf.Timestamp + 285, // 326: openshell.v1.SandboxProvisioning.deadline:type_name -> google.protobuf.Timestamp + 285, // 327: openshell.v1.SandboxProvisioning.timeout_time:type_name -> google.protobuf.Timestamp + 285, // 328: openshell.v1.SandboxProvisioning.cleanup_completed_time:type_name -> google.protobuf.Timestamp + 285, // 329: openshell.v1.SandboxProvisioning.cleanup_retry_time:type_name -> google.protobuf.Timestamp + 285, // 330: openshell.v1.SandboxProvisioning.attachment_change_time:type_name -> google.protobuf.Timestamp + 285, // 331: openshell.v1.SandboxProvisioning.preparation_deadline:type_name -> google.protobuf.Timestamp + 285, // 332: openshell.v1.SandboxProvisioning.admission_start_time:type_name -> google.protobuf.Timestamp + 19, // 333: openshell.v1.SandboxServiceExposure.authorization_mode:type_name -> openshell.v1.ServiceAuthorizationMode + 20, // 334: openshell.v1.EndpointFailure.domain:type_name -> openshell.v1.EndpointFailureDomain + 15, // 335: openshell.v1.EndpointFailure.recovery_action:type_name -> openshell.v1.ProviderCredentialRefreshRecoveryAction + 118, // 336: openshell.v1.GetProviderCredentialsResponse.CredentialsEntry.value:type_name -> openshell.v1.ProviderCredentialValue + 285, // 337: openshell.v1.UpdateProviderRequest.CredentialExpirationTimesEntry.value:type_name -> google.protobuf.Timestamp + 285, // 338: openshell.v1.GetSandboxProviderEnvironmentResponse.CredentialExpirationTimesEntry.value:type_name -> google.protobuf.Timestamp + 132, // 339: openshell.v1.GetSandboxProviderEnvironmentResponse.DynamicCredentialsEntry.value:type_name -> openshell.v1.ProviderProfileCredential + 161, // 340: openshell.v1.GetSandboxProviderEnvironmentResponse.StaticCredentialBindingsEntry.value:type_name -> openshell.v1.StaticCredentialBinding + 25, // 341: openshell.v1.OpenShell.Health:input_type -> openshell.v1.HealthRequest + 27, // 342: openshell.v1.OpenShell.GetCurrentUser:input_type -> openshell.v1.GetCurrentUserRequest + 29, // 343: openshell.v1.OpenShell.GetGatewayInfo:input_type -> openshell.v1.GetGatewayInfoRequest + 53, // 344: openshell.v1.OpenShell.CreateSandbox:input_type -> openshell.v1.CreateSandboxRequest + 62, // 345: openshell.v1.OpenShell.BeginRootfsTarStaging:input_type -> openshell.v1.BeginRootfsTarStagingRequest + 64, // 346: openshell.v1.OpenShell.GetSandbox:input_type -> openshell.v1.GetSandboxRequest + 65, // 347: openshell.v1.OpenShell.ListSandboxes:input_type -> openshell.v1.ListSandboxesRequest + 55, // 348: openshell.v1.OpenShell.CreateSandboxTemplate:input_type -> openshell.v1.CreateSandboxTemplateRequest + 56, // 349: openshell.v1.OpenShell.GetSandboxTemplate:input_type -> openshell.v1.GetSandboxTemplateRequest + 57, // 350: openshell.v1.OpenShell.ListSandboxTemplates:input_type -> openshell.v1.ListSandboxTemplatesRequest + 58, // 351: openshell.v1.OpenShell.DeleteSandboxTemplate:input_type -> openshell.v1.DeleteSandboxTemplateRequest + 66, // 352: openshell.v1.OpenShell.ListSandboxProviders:input_type -> openshell.v1.ListSandboxProvidersRequest + 67, // 353: openshell.v1.OpenShell.AttachSandboxProvider:input_type -> openshell.v1.AttachSandboxProviderRequest + 68, // 354: openshell.v1.OpenShell.DetachSandboxProvider:input_type -> openshell.v1.DetachSandboxProviderRequest + 84, // 355: openshell.v1.OpenShell.GetSandboxProviderStatus:input_type -> openshell.v1.GetSandboxProviderStatusRequest + 69, // 356: openshell.v1.OpenShell.DeleteSandbox:input_type -> openshell.v1.DeleteSandboxRequest + 70, // 357: openshell.v1.OpenShell.StopSandbox:input_type -> openshell.v1.StopSandboxRequest + 71, // 358: openshell.v1.OpenShell.StartSandbox:input_type -> openshell.v1.StartSandboxRequest + 89, // 359: openshell.v1.OpenShell.CreateSshSession:input_type -> openshell.v1.CreateSshSessionRequest + 91, // 360: openshell.v1.OpenShell.ExposeService:input_type -> openshell.v1.ExposeServiceRequest + 92, // 361: openshell.v1.OpenShell.GetService:input_type -> openshell.v1.GetServiceRequest + 93, // 362: openshell.v1.OpenShell.ListServices:input_type -> openshell.v1.ListServicesRequest + 95, // 363: openshell.v1.OpenShell.DeleteService:input_type -> openshell.v1.DeleteServiceRequest + 99, // 364: openshell.v1.OpenShell.RevokeSshSession:input_type -> openshell.v1.RevokeSshSessionRequest + 101, // 365: openshell.v1.OpenShell.ExecSandbox:input_type -> openshell.v1.ExecSandboxRequest + 107, // 366: openshell.v1.OpenShell.ForwardTcp:input_type -> openshell.v1.TcpForwardFrame + 108, // 367: openshell.v1.OpenShell.ExecSandboxInteractive:input_type -> openshell.v1.ExecSandboxInput + 115, // 368: openshell.v1.OpenShell.CreateProvider:input_type -> openshell.v1.CreateProviderRequest + 116, // 369: openshell.v1.OpenShell.GetProvider:input_type -> openshell.v1.GetProviderRequest + 117, // 370: openshell.v1.OpenShell.GetProviderCredentials:input_type -> openshell.v1.GetProviderCredentialsRequest + 120, // 371: openshell.v1.OpenShell.ListProviders:input_type -> openshell.v1.ListProvidersRequest + 125, // 372: openshell.v1.OpenShell.ListProviderProfiles:input_type -> openshell.v1.ListProviderProfilesRequest + 126, // 373: openshell.v1.OpenShell.GetProviderProfile:input_type -> openshell.v1.GetProviderProfileRequest + 150, // 374: openshell.v1.OpenShell.ImportProviderProfiles:input_type -> openshell.v1.ImportProviderProfilesRequest + 152, // 375: openshell.v1.OpenShell.UpdateProviderProfiles:input_type -> openshell.v1.UpdateProviderProfilesRequest + 154, // 376: openshell.v1.OpenShell.LintProviderProfiles:input_type -> openshell.v1.LintProviderProfilesRequest + 121, // 377: openshell.v1.OpenShell.UpdateProvider:input_type -> openshell.v1.UpdateProviderRequest + 138, // 378: openshell.v1.OpenShell.GetProviderRefreshStatus:input_type -> openshell.v1.GetProviderRefreshStatusRequest + 140, // 379: openshell.v1.OpenShell.ConfigureProviderRefresh:input_type -> openshell.v1.ConfigureProviderRefreshRequest + 142, // 380: openshell.v1.OpenShell.RotateProviderCredential:input_type -> openshell.v1.RotateProviderCredentialRequest + 144, // 381: openshell.v1.OpenShell.DeleteProviderRefresh:input_type -> openshell.v1.DeleteProviderRefreshRequest + 122, // 382: openshell.v1.OpenShell.DeleteProvider:input_type -> openshell.v1.DeleteProviderRequest + 157, // 383: openshell.v1.OpenShell.DeleteProviderProfile:input_type -> openshell.v1.DeleteProviderProfileRequest + 300, // 384: openshell.v1.OpenShell.GetSandboxConfig:input_type -> openshell.sandbox.v1.GetSandboxConfigRequest + 301, // 385: openshell.v1.OpenShell.GetGatewayConfig:input_type -> openshell.sandbox.v1.GetGatewayConfigRequest + 165, // 386: openshell.v1.OpenShell.UpdateConfig:input_type -> openshell.v1.UpdateConfigRequest + 175, // 387: openshell.v1.OpenShell.GetSandboxPolicyStatus:input_type -> openshell.v1.GetSandboxPolicyStatusRequest + 177, // 388: openshell.v1.OpenShell.ListSandboxPolicies:input_type -> openshell.v1.ListSandboxPoliciesRequest + 179, // 389: openshell.v1.OpenShell.ReportPolicyStatus:input_type -> openshell.v1.ReportPolicyStatusRequest + 253, // 390: openshell.v1.OpenShell.ReportEndpointStatus:input_type -> openshell.v1.ReportEndpointStatusRequest + 86, // 391: openshell.v1.OpenShell.ReportProviderReadiness:input_type -> openshell.v1.ReportProviderReadinessRequest + 182, // 392: openshell.v1.OpenShell.ReportSandboxConfiguration:input_type -> openshell.v1.ReportSandboxConfigurationRequest + 159, // 393: openshell.v1.OpenShell.GetSandboxProviderEnvironment:input_type -> openshell.v1.GetSandboxProviderEnvironmentRequest + 163, // 394: openshell.v1.OpenShell.ExchangeProviderSubjectToken:input_type -> openshell.v1.ExchangeProviderSubjectTokenRequest + 185, // 395: openshell.v1.OpenShell.GetSandboxLogs:input_type -> openshell.v1.GetSandboxLogsRequest + 186, // 396: openshell.v1.OpenShell.PushSandboxLogs:input_type -> openshell.v1.PushSandboxLogsRequest + 189, // 397: openshell.v1.OpenShell.ConnectSupervisor:input_type -> openshell.v1.SupervisorMessage + 197, // 398: openshell.v1.OpenShell.ReportMainProcessExit:input_type -> openshell.v1.ReportMainProcessExitRequest + 199, // 399: openshell.v1.OpenShell.FinalizeMainProcessExit:input_type -> openshell.v1.FinalizeMainProcessExitRequest + 205, // 400: openshell.v1.OpenShell.RelayStream:input_type -> openshell.v1.RelayFrame + 207, // 401: openshell.v1.OpenShell.PeerRelay:input_type -> openshell.v1.PeerRelayFrame + 86, // 402: openshell.v1.OpenShell.PeerReportProviderReadiness:input_type -> openshell.v1.ReportProviderReadinessRequest + 253, // 403: openshell.v1.OpenShell.PeerReportEndpointStatus:input_type -> openshell.v1.ReportEndpointStatusRequest + 84, // 404: openshell.v1.OpenShell.PeerGetSandboxProviderStatus:input_type -> openshell.v1.GetSandboxProviderStatusRequest + 111, // 405: openshell.v1.OpenShell.WatchSandbox:input_type -> openshell.v1.WatchSandboxRequest + 216, // 406: openshell.v1.OpenShell.SubmitPolicyAnalysis:input_type -> openshell.v1.SubmitPolicyAnalysisRequest + 218, // 407: openshell.v1.OpenShell.GetDraftPolicy:input_type -> openshell.v1.GetDraftPolicyRequest + 220, // 408: openshell.v1.OpenShell.ApproveDraftChunk:input_type -> openshell.v1.ApproveDraftChunkRequest + 222, // 409: openshell.v1.OpenShell.RejectDraftChunk:input_type -> openshell.v1.RejectDraftChunkRequest + 225, // 410: openshell.v1.OpenShell.ApproveAllDraftChunks:input_type -> openshell.v1.ApproveAllDraftChunksRequest + 227, // 411: openshell.v1.OpenShell.EditDraftChunk:input_type -> openshell.v1.EditDraftChunkRequest + 229, // 412: openshell.v1.OpenShell.UndoDraftChunk:input_type -> openshell.v1.UndoDraftChunkRequest + 231, // 413: openshell.v1.OpenShell.ClearDraftChunks:input_type -> openshell.v1.ClearDraftChunksRequest + 233, // 414: openshell.v1.OpenShell.GetDraftHistory:input_type -> openshell.v1.GetDraftHistoryRequest + 21, // 415: openshell.v1.OpenShell.IssueSandboxToken:input_type -> openshell.v1.IssueSandboxTokenRequest + 23, // 416: openshell.v1.OpenShell.RefreshSandboxToken:input_type -> openshell.v1.RefreshSandboxTokenRequest + 236, // 417: openshell.v1.OpenShell.CreateWorkspace:input_type -> openshell.v1.CreateWorkspaceRequest + 238, // 418: openshell.v1.OpenShell.GetWorkspace:input_type -> openshell.v1.GetWorkspaceRequest + 240, // 419: openshell.v1.OpenShell.ListWorkspaces:input_type -> openshell.v1.ListWorkspacesRequest + 242, // 420: openshell.v1.OpenShell.DeleteWorkspace:input_type -> openshell.v1.DeleteWorkspaceRequest + 245, // 421: openshell.v1.OpenShell.AddWorkspaceMember:input_type -> openshell.v1.AddWorkspaceMemberRequest + 247, // 422: openshell.v1.OpenShell.RemoveWorkspaceMember:input_type -> openshell.v1.RemoveWorkspaceMemberRequest + 249, // 423: openshell.v1.OpenShell.ListWorkspaceMembers:input_type -> openshell.v1.ListWorkspaceMembersRequest + 54, // 424: openshell.v1.SandboxUpdates.UpdateSandbox:input_type -> openshell.v1.UpdateSandboxRequest + 26, // 425: openshell.v1.OpenShell.Health:output_type -> openshell.v1.HealthResponse + 28, // 426: openshell.v1.OpenShell.GetCurrentUser:output_type -> openshell.v1.GetCurrentUserResponse + 30, // 427: openshell.v1.OpenShell.GetGatewayInfo:output_type -> openshell.v1.GetGatewayInfoResponse + 72, // 428: openshell.v1.OpenShell.CreateSandbox:output_type -> openshell.v1.SandboxResponse + 63, // 429: openshell.v1.OpenShell.BeginRootfsTarStaging:output_type -> openshell.v1.BeginRootfsTarStagingResponse + 72, // 430: openshell.v1.OpenShell.GetSandbox:output_type -> openshell.v1.SandboxResponse + 73, // 431: openshell.v1.OpenShell.ListSandboxes:output_type -> openshell.v1.ListSandboxesResponse + 59, // 432: openshell.v1.OpenShell.CreateSandboxTemplate:output_type -> openshell.v1.SandboxTemplateResponse + 59, // 433: openshell.v1.OpenShell.GetSandboxTemplate:output_type -> openshell.v1.SandboxTemplateResponse + 60, // 434: openshell.v1.OpenShell.ListSandboxTemplates:output_type -> openshell.v1.ListSandboxTemplatesResponse + 61, // 435: openshell.v1.OpenShell.DeleteSandboxTemplate:output_type -> openshell.v1.DeleteSandboxTemplateResponse + 74, // 436: openshell.v1.OpenShell.ListSandboxProviders:output_type -> openshell.v1.ListSandboxProvidersResponse + 75, // 437: openshell.v1.OpenShell.AttachSandboxProvider:output_type -> openshell.v1.AttachSandboxProviderResponse + 76, // 438: openshell.v1.OpenShell.DetachSandboxProvider:output_type -> openshell.v1.DetachSandboxProviderResponse + 85, // 439: openshell.v1.OpenShell.GetSandboxProviderStatus:output_type -> openshell.v1.GetSandboxProviderStatusResponse + 88, // 440: openshell.v1.OpenShell.DeleteSandbox:output_type -> openshell.v1.DeleteSandboxResponse + 72, // 441: openshell.v1.OpenShell.StopSandbox:output_type -> openshell.v1.SandboxResponse + 72, // 442: openshell.v1.OpenShell.StartSandbox:output_type -> openshell.v1.SandboxResponse + 90, // 443: openshell.v1.OpenShell.CreateSshSession:output_type -> openshell.v1.CreateSshSessionResponse + 98, // 444: openshell.v1.OpenShell.ExposeService:output_type -> openshell.v1.ServiceEndpointResponse + 98, // 445: openshell.v1.OpenShell.GetService:output_type -> openshell.v1.ServiceEndpointResponse + 94, // 446: openshell.v1.OpenShell.ListServices:output_type -> openshell.v1.ListServicesResponse + 96, // 447: openshell.v1.OpenShell.DeleteService:output_type -> openshell.v1.DeleteServiceResponse + 100, // 448: openshell.v1.OpenShell.RevokeSshSession:output_type -> openshell.v1.RevokeSshSessionResponse + 105, // 449: openshell.v1.OpenShell.ExecSandbox:output_type -> openshell.v1.ExecSandboxEvent + 107, // 450: openshell.v1.OpenShell.ForwardTcp:output_type -> openshell.v1.TcpForwardFrame + 105, // 451: openshell.v1.OpenShell.ExecSandboxInteractive:output_type -> openshell.v1.ExecSandboxEvent + 123, // 452: openshell.v1.OpenShell.CreateProvider:output_type -> openshell.v1.ProviderResponse + 123, // 453: openshell.v1.OpenShell.GetProvider:output_type -> openshell.v1.ProviderResponse + 119, // 454: openshell.v1.OpenShell.GetProviderCredentials:output_type -> openshell.v1.GetProviderCredentialsResponse + 124, // 455: openshell.v1.OpenShell.ListProviders:output_type -> openshell.v1.ListProvidersResponse + 149, // 456: openshell.v1.OpenShell.ListProviderProfiles:output_type -> openshell.v1.ListProviderProfilesResponse + 148, // 457: openshell.v1.OpenShell.GetProviderProfile:output_type -> openshell.v1.ProviderProfileResponse + 151, // 458: openshell.v1.OpenShell.ImportProviderProfiles:output_type -> openshell.v1.ImportProviderProfilesResponse + 153, // 459: openshell.v1.OpenShell.UpdateProviderProfiles:output_type -> openshell.v1.UpdateProviderProfilesResponse + 155, // 460: openshell.v1.OpenShell.LintProviderProfiles:output_type -> openshell.v1.LintProviderProfilesResponse + 123, // 461: openshell.v1.OpenShell.UpdateProvider:output_type -> openshell.v1.ProviderResponse + 139, // 462: openshell.v1.OpenShell.GetProviderRefreshStatus:output_type -> openshell.v1.GetProviderRefreshStatusResponse + 141, // 463: openshell.v1.OpenShell.ConfigureProviderRefresh:output_type -> openshell.v1.ConfigureProviderRefreshResponse + 143, // 464: openshell.v1.OpenShell.RotateProviderCredential:output_type -> openshell.v1.RotateProviderCredentialResponse + 145, // 465: openshell.v1.OpenShell.DeleteProviderRefresh:output_type -> openshell.v1.DeleteProviderRefreshResponse + 156, // 466: openshell.v1.OpenShell.DeleteProvider:output_type -> openshell.v1.DeleteProviderResponse + 158, // 467: openshell.v1.OpenShell.DeleteProviderProfile:output_type -> openshell.v1.DeleteProviderProfileResponse + 302, // 468: openshell.v1.OpenShell.GetSandboxConfig:output_type -> openshell.sandbox.v1.GetSandboxConfigResponse + 303, // 469: openshell.v1.OpenShell.GetGatewayConfig:output_type -> openshell.sandbox.v1.GetGatewayConfigResponse + 174, // 470: openshell.v1.OpenShell.UpdateConfig:output_type -> openshell.v1.UpdateConfigResponse + 176, // 471: openshell.v1.OpenShell.GetSandboxPolicyStatus:output_type -> openshell.v1.GetSandboxPolicyStatusResponse + 178, // 472: openshell.v1.OpenShell.ListSandboxPolicies:output_type -> openshell.v1.ListSandboxPoliciesResponse + 180, // 473: openshell.v1.OpenShell.ReportPolicyStatus:output_type -> openshell.v1.ReportPolicyStatusResponse + 256, // 474: openshell.v1.OpenShell.ReportEndpointStatus:output_type -> openshell.v1.ReportEndpointStatusResponse + 87, // 475: openshell.v1.OpenShell.ReportProviderReadiness:output_type -> openshell.v1.ReportProviderReadinessResponse + 183, // 476: openshell.v1.OpenShell.ReportSandboxConfiguration:output_type -> openshell.v1.ReportSandboxConfigurationResponse + 162, // 477: openshell.v1.OpenShell.GetSandboxProviderEnvironment:output_type -> openshell.v1.GetSandboxProviderEnvironmentResponse + 164, // 478: openshell.v1.OpenShell.ExchangeProviderSubjectToken:output_type -> openshell.v1.ExchangeProviderSubjectTokenResponse + 188, // 479: openshell.v1.OpenShell.GetSandboxLogs:output_type -> openshell.v1.GetSandboxLogsResponse + 187, // 480: openshell.v1.OpenShell.PushSandboxLogs:output_type -> openshell.v1.PushSandboxLogsResponse + 190, // 481: openshell.v1.OpenShell.ConnectSupervisor:output_type -> openshell.v1.GatewayMessage + 198, // 482: openshell.v1.OpenShell.ReportMainProcessExit:output_type -> openshell.v1.ReportMainProcessExitResponse + 200, // 483: openshell.v1.OpenShell.FinalizeMainProcessExit:output_type -> openshell.v1.FinalizeMainProcessExitResponse + 205, // 484: openshell.v1.OpenShell.RelayStream:output_type -> openshell.v1.RelayFrame + 207, // 485: openshell.v1.OpenShell.PeerRelay:output_type -> openshell.v1.PeerRelayFrame + 87, // 486: openshell.v1.OpenShell.PeerReportProviderReadiness:output_type -> openshell.v1.ReportProviderReadinessResponse + 256, // 487: openshell.v1.OpenShell.PeerReportEndpointStatus:output_type -> openshell.v1.ReportEndpointStatusResponse + 85, // 488: openshell.v1.OpenShell.PeerGetSandboxProviderStatus:output_type -> openshell.v1.GetSandboxProviderStatusResponse + 112, // 489: openshell.v1.OpenShell.WatchSandbox:output_type -> openshell.v1.SandboxStreamEvent + 217, // 490: openshell.v1.OpenShell.SubmitPolicyAnalysis:output_type -> openshell.v1.SubmitPolicyAnalysisResponse + 219, // 491: openshell.v1.OpenShell.GetDraftPolicy:output_type -> openshell.v1.GetDraftPolicyResponse + 221, // 492: openshell.v1.OpenShell.ApproveDraftChunk:output_type -> openshell.v1.ApproveDraftChunkResponse + 223, // 493: openshell.v1.OpenShell.RejectDraftChunk:output_type -> openshell.v1.RejectDraftChunkResponse + 226, // 494: openshell.v1.OpenShell.ApproveAllDraftChunks:output_type -> openshell.v1.ApproveAllDraftChunksResponse + 228, // 495: openshell.v1.OpenShell.EditDraftChunk:output_type -> openshell.v1.EditDraftChunkResponse + 230, // 496: openshell.v1.OpenShell.UndoDraftChunk:output_type -> openshell.v1.UndoDraftChunkResponse + 232, // 497: openshell.v1.OpenShell.ClearDraftChunks:output_type -> openshell.v1.ClearDraftChunksResponse + 235, // 498: openshell.v1.OpenShell.GetDraftHistory:output_type -> openshell.v1.GetDraftHistoryResponse + 22, // 499: openshell.v1.OpenShell.IssueSandboxToken:output_type -> openshell.v1.IssueSandboxTokenResponse + 24, // 500: openshell.v1.OpenShell.RefreshSandboxToken:output_type -> openshell.v1.RefreshSandboxTokenResponse + 237, // 501: openshell.v1.OpenShell.CreateWorkspace:output_type -> openshell.v1.CreateWorkspaceResponse + 239, // 502: openshell.v1.OpenShell.GetWorkspace:output_type -> openshell.v1.GetWorkspaceResponse + 241, // 503: openshell.v1.OpenShell.ListWorkspaces:output_type -> openshell.v1.ListWorkspacesResponse + 243, // 504: openshell.v1.OpenShell.DeleteWorkspace:output_type -> openshell.v1.DeleteWorkspaceResponse + 246, // 505: openshell.v1.OpenShell.AddWorkspaceMember:output_type -> openshell.v1.AddWorkspaceMemberResponse + 248, // 506: openshell.v1.OpenShell.RemoveWorkspaceMember:output_type -> openshell.v1.RemoveWorkspaceMemberResponse + 250, // 507: openshell.v1.OpenShell.ListWorkspaceMembers:output_type -> openshell.v1.ListWorkspaceMembersResponse + 72, // 508: openshell.v1.SandboxUpdates.UpdateSandbox:output_type -> openshell.v1.SandboxResponse + 425, // [425:509] is the sub-list for method output_type + 341, // [341:425] is the sub-list for method input_type + 341, // [341:341] is the sub-list for extension type_name + 341, // [341:341] is the sub-list for extension extendee + 0, // [0:341] is the sub-list for field type_name } func init() { file_openshell_proto_init() } @@ -21304,37 +21207,37 @@ func file_openshell_proto_init() { file_openshell_proto_msgTypes[20].OneofWrappers = []any{} file_openshell_proto_msgTypes[21].OneofWrappers = []any{} file_openshell_proto_msgTypes[29].OneofWrappers = []any{} - file_openshell_proto_msgTypes[58].OneofWrappers = []any{ + file_openshell_proto_msgTypes[57].OneofWrappers = []any{ (*ConfigSnapshotRevision_SandboxConfig)(nil), (*ConfigSnapshotRevision_ProviderEnvironment)(nil), (*ConfigSnapshotRevision_ProviderTarget)(nil), } - file_openshell_proto_msgTypes[85].OneofWrappers = []any{ + file_openshell_proto_msgTypes[84].OneofWrappers = []any{ (*ExecSandboxEvent_Stdout)(nil), (*ExecSandboxEvent_Stderr)(nil), (*ExecSandboxEvent_Exit)(nil), } - file_openshell_proto_msgTypes[86].OneofWrappers = []any{ + file_openshell_proto_msgTypes[85].OneofWrappers = []any{ (*TcpForwardInit_Ssh)(nil), (*TcpForwardInit_Tcp)(nil), } - file_openshell_proto_msgTypes[87].OneofWrappers = []any{ + file_openshell_proto_msgTypes[86].OneofWrappers = []any{ (*TcpForwardFrame_Init)(nil), (*TcpForwardFrame_Data)(nil), } - file_openshell_proto_msgTypes[88].OneofWrappers = []any{ + file_openshell_proto_msgTypes[87].OneofWrappers = []any{ (*ExecSandboxInput_Start)(nil), (*ExecSandboxInput_Stdin)(nil), (*ExecSandboxInput_Resize)(nil), } - file_openshell_proto_msgTypes[92].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[146].OneofWrappers = []any{ + file_openshell_proto_msgTypes[145].OneofWrappers = []any{ (*PolicyMergeOperation_AddRule)(nil), (*PolicyMergeOperation_RemoveEndpoint)(nil), (*PolicyMergeOperation_RemoveRule)(nil), @@ -21342,14 +21245,14 @@ func file_openshell_proto_init() { (*PolicyMergeOperation_AddAllowRules)(nil), (*PolicyMergeOperation_RemoveBinary)(nil), } - file_openshell_proto_msgTypes[150].OneofWrappers = []any{} - file_openshell_proto_msgTypes[169].OneofWrappers = []any{ + file_openshell_proto_msgTypes[149].OneofWrappers = []any{} + file_openshell_proto_msgTypes[168].OneofWrappers = []any{ (*SupervisorMessage_Hello)(nil), (*SupervisorMessage_Heartbeat)(nil), (*SupervisorMessage_RelayOpenResult)(nil), (*SupervisorMessage_RelayClose)(nil), } - file_openshell_proto_msgTypes[170].OneofWrappers = []any{ + file_openshell_proto_msgTypes[169].OneofWrappers = []any{ (*GatewayMessage_SessionAccepted)(nil), (*GatewayMessage_SessionRejected)(nil), (*GatewayMessage_Heartbeat)(nil), @@ -21357,28 +21260,28 @@ func file_openshell_proto_init() { (*GatewayMessage_RelayClose)(nil), (*GatewayMessage_SessionRedirect)(nil), } - file_openshell_proto_msgTypes[181].OneofWrappers = []any{ + file_openshell_proto_msgTypes[180].OneofWrappers = []any{ (*RelayOpen_Ssh)(nil), (*RelayOpen_Tcp)(nil), } - file_openshell_proto_msgTypes[185].OneofWrappers = []any{ + file_openshell_proto_msgTypes[184].OneofWrappers = []any{ (*RelayFrame_Init)(nil), (*RelayFrame_Data)(nil), } - file_openshell_proto_msgTypes[187].OneofWrappers = []any{ + file_openshell_proto_msgTypes[186].OneofWrappers = []any{ (*PeerRelayFrame_Init)(nil), (*PeerRelayFrame_Data)(nil), } - file_openshell_proto_msgTypes[240].OneofWrappers = []any{} + file_openshell_proto_msgTypes[239].OneofWrappers = []any{} type x struct{} out := protoimpl.TypeBuilder{ File: protoimpl.DescBuilder{ GoPackagePath: reflect.TypeOf(x{}).PkgPath(), RawDescriptor: unsafe.Slice(unsafe.StringData(file_openshell_proto_rawDesc), len(file_openshell_proto_rawDesc)), NumEnums: 21, - NumMessages: 265, + NumMessages: 264, NumExtensions: 0, - NumServices: 1, + NumServices: 2, }, GoTypes: file_openshell_proto_goTypes, DependencyIndexes: file_openshell_proto_depIdxs, diff --git a/sdk/go/proto/openshellv1/openshell_grpc.pb.go b/sdk/go/proto/openshellv1/openshell_grpc.pb.go index e12cba7d3f..6dd120fa5a 100644 --- a/sdk/go/proto/openshellv1/openshell_grpc.pb.go +++ b/sdk/go/proto/openshellv1/openshell_grpc.pb.go @@ -27,7 +27,6 @@ const ( OpenShell_GetCurrentUser_FullMethodName = "/openshell.v1.OpenShell/GetCurrentUser" OpenShell_GetGatewayInfo_FullMethodName = "/openshell.v1.OpenShell/GetGatewayInfo" OpenShell_CreateSandbox_FullMethodName = "/openshell.v1.OpenShell/CreateSandbox" - OpenShell_UpdateSandbox_FullMethodName = "/openshell.v1.OpenShell/UpdateSandbox" OpenShell_BeginRootfsTarStaging_FullMethodName = "/openshell.v1.OpenShell/BeginRootfsTarStaging" OpenShell_GetSandbox_FullMethodName = "/openshell.v1.OpenShell/GetSandbox" OpenShell_ListSandboxes_FullMethodName = "/openshell.v1.OpenShell/ListSandboxes" @@ -130,9 +129,6 @@ type OpenShellClient interface { GetGatewayInfo(ctx context.Context, in *GetGatewayInfoRequest, opts ...grpc.CallOption) (*GetGatewayInfoResponse, error) // Create a new sandbox. CreateSandbox(ctx context.Context, in *CreateSandboxRequest, opts ...grpc.CallOption) (*SandboxResponse, error) - // Update only the workload image of a stopped sandbox without deleting its - // identity or retained storage. Requires compute-driver image-update support. - UpdateSandbox(ctx context.Context, in *UpdateSandboxRequest, opts ...grpc.CallOption) (*SandboxResponse, error) // Allocate a gateway-owned staging slot for a local rootfs tar archive. // // The gateway creates a request-scoped directory inside the compute driver's @@ -393,16 +389,6 @@ func (c *openShellClient) CreateSandbox(ctx context.Context, in *CreateSandboxRe return out, nil } -func (c *openShellClient) UpdateSandbox(ctx context.Context, in *UpdateSandboxRequest, opts ...grpc.CallOption) (*SandboxResponse, error) { - cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) - out := new(SandboxResponse) - err := c.cc.Invoke(ctx, OpenShell_UpdateSandbox_FullMethodName, in, out, cOpts...) - if err != nil { - return nil, err - } - return out, nil -} - func (c *openShellClient) BeginRootfsTarStaging(ctx context.Context, in *BeginRootfsTarStagingRequest, opts ...grpc.CallOption) (*BeginRootfsTarStagingResponse, error) { cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(BeginRootfsTarStagingResponse) @@ -1250,9 +1236,6 @@ type OpenShellServer interface { GetGatewayInfo(context.Context, *GetGatewayInfoRequest) (*GetGatewayInfoResponse, error) // Create a new sandbox. CreateSandbox(context.Context, *CreateSandboxRequest) (*SandboxResponse, error) - // Update only the workload image of a stopped sandbox without deleting its - // identity or retained storage. Requires compute-driver image-update support. - UpdateSandbox(context.Context, *UpdateSandboxRequest) (*SandboxResponse, error) // Allocate a gateway-owned staging slot for a local rootfs tar archive. // // The gateway creates a request-scoped directory inside the compute driver's @@ -1485,9 +1468,6 @@ func (UnimplementedOpenShellServer) GetGatewayInfo(context.Context, *GetGatewayI func (UnimplementedOpenShellServer) CreateSandbox(context.Context, *CreateSandboxRequest) (*SandboxResponse, error) { return nil, status.Error(codes.Unimplemented, "method CreateSandbox not implemented") } -func (UnimplementedOpenShellServer) UpdateSandbox(context.Context, *UpdateSandboxRequest) (*SandboxResponse, error) { - return nil, status.Error(codes.Unimplemented, "method UpdateSandbox not implemented") -} func (UnimplementedOpenShellServer) BeginRootfsTarStaging(context.Context, *BeginRootfsTarStagingRequest) (*BeginRootfsTarStagingResponse, error) { return nil, status.Error(codes.Unimplemented, "method BeginRootfsTarStaging not implemented") } @@ -1818,24 +1798,6 @@ func _OpenShell_CreateSandbox_Handler(srv interface{}, ctx context.Context, dec return interceptor(ctx, in, info, handler) } -func _OpenShell_UpdateSandbox_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(UpdateSandboxRequest) - if err := dec(in); err != nil { - return nil, err - } - if interceptor == nil { - return srv.(OpenShellServer).UpdateSandbox(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: OpenShell_UpdateSandbox_FullMethodName, - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(OpenShellServer).UpdateSandbox(ctx, req.(*UpdateSandboxRequest)) - } - return interceptor(ctx, in, info, handler) -} - func _OpenShell_BeginRootfsTarStaging_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(BeginRootfsTarStagingRequest) if err := dec(in); err != nil { @@ -3201,10 +3163,6 @@ var OpenShell_ServiceDesc = grpc.ServiceDesc{ MethodName: "CreateSandbox", Handler: _OpenShell_CreateSandbox_Handler, }, - { - MethodName: "UpdateSandbox", - Handler: _OpenShell_UpdateSandbox_Handler, - }, { MethodName: "BeginRootfsTarStaging", Handler: _OpenShell_BeginRootfsTarStaging_Handler, @@ -3539,3 +3497,117 @@ var OpenShell_ServiceDesc = grpc.ServiceDesc{ }, Metadata: "openshell.proto", } + +const ( + SandboxUpdates_UpdateSandbox_FullMethodName = "/openshell.v1.SandboxUpdates/UpdateSandbox" +) + +// SandboxUpdatesClient is the client API for SandboxUpdates service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream. +// +// Optional sandbox mutations are separate from OpenShell so existing generated +// OpenShell server implementations remain source-compatible. +type SandboxUpdatesClient interface { + // Update only the workload image of a stopped sandbox without deleting its + // identity or retained storage. Requires compute-driver image-update support + // and explicit gateway activation of sandbox image updates. + UpdateSandbox(ctx context.Context, in *UpdateSandboxRequest, opts ...grpc.CallOption) (*SandboxResponse, error) +} + +type sandboxUpdatesClient struct { + cc grpc.ClientConnInterface +} + +func NewSandboxUpdatesClient(cc grpc.ClientConnInterface) SandboxUpdatesClient { + return &sandboxUpdatesClient{cc} +} + +func (c *sandboxUpdatesClient) UpdateSandbox(ctx context.Context, in *UpdateSandboxRequest, opts ...grpc.CallOption) (*SandboxResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(SandboxResponse) + err := c.cc.Invoke(ctx, SandboxUpdates_UpdateSandbox_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +// SandboxUpdatesServer is the server API for SandboxUpdates service. +// All implementations must embed UnimplementedSandboxUpdatesServer +// for forward compatibility. +// +// Optional sandbox mutations are separate from OpenShell so existing generated +// OpenShell server implementations remain source-compatible. +type SandboxUpdatesServer interface { + // Update only the workload image of a stopped sandbox without deleting its + // identity or retained storage. Requires compute-driver image-update support + // and explicit gateway activation of sandbox image updates. + UpdateSandbox(context.Context, *UpdateSandboxRequest) (*SandboxResponse, error) + mustEmbedUnimplementedSandboxUpdatesServer() +} + +// UnimplementedSandboxUpdatesServer must be embedded to have +// forward compatible implementations. +// +// NOTE: this should be embedded by value instead of pointer to avoid a nil +// pointer dereference when methods are called. +type UnimplementedSandboxUpdatesServer struct{} + +func (UnimplementedSandboxUpdatesServer) UpdateSandbox(context.Context, *UpdateSandboxRequest) (*SandboxResponse, error) { + return nil, status.Error(codes.Unimplemented, "method UpdateSandbox not implemented") +} +func (UnimplementedSandboxUpdatesServer) mustEmbedUnimplementedSandboxUpdatesServer() {} +func (UnimplementedSandboxUpdatesServer) testEmbeddedByValue() {} + +// UnsafeSandboxUpdatesServer may be embedded to opt out of forward compatibility for this service. +// Use of this interface is not recommended, as added methods to SandboxUpdatesServer will +// result in compilation errors. +type UnsafeSandboxUpdatesServer interface { + mustEmbedUnimplementedSandboxUpdatesServer() +} + +func RegisterSandboxUpdatesServer(s grpc.ServiceRegistrar, srv SandboxUpdatesServer) { + // If the following call panics, it indicates UnimplementedSandboxUpdatesServer was + // embedded by pointer and is nil. This will cause panics if an + // unimplemented method is ever invoked, so we test this at initialization + // time to prevent it from happening at runtime later due to I/O. + if t, ok := srv.(interface{ testEmbeddedByValue() }); ok { + t.testEmbeddedByValue() + } + s.RegisterService(&SandboxUpdates_ServiceDesc, srv) +} + +func _SandboxUpdates_UpdateSandbox_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(UpdateSandboxRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(SandboxUpdatesServer).UpdateSandbox(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: SandboxUpdates_UpdateSandbox_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(SandboxUpdatesServer).UpdateSandbox(ctx, req.(*UpdateSandboxRequest)) + } + return interceptor(ctx, in, info, handler) +} + +// SandboxUpdates_ServiceDesc is the grpc.ServiceDesc for SandboxUpdates service. +// It's only intended for direct use with grpc.RegisterService, +// and not to be introspected or modified (even as a copy) +var SandboxUpdates_ServiceDesc = grpc.ServiceDesc{ + ServiceName: "openshell.v1.SandboxUpdates", + HandlerType: (*SandboxUpdatesServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "UpdateSandbox", + Handler: _SandboxUpdates_UpdateSandbox_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "openshell.proto", +} diff --git a/sdk/go/proto/openshellv1/sandbox_updates_test.go b/sdk/go/proto/openshellv1/sandbox_updates_test.go new file mode 100644 index 0000000000..1bd00072c9 --- /dev/null +++ b/sdk/go/proto/openshellv1/sandbox_updates_test.go @@ -0,0 +1,121 @@ +// SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +// SPDX-License-Identifier: Apache-2.0 + +package openshellv1_test + +import ( + "context" + "net" + "testing" + + dm "github.com/NVIDIA/OpenShell/sdk/go/proto/datamodelv1" + pb "github.com/NVIDIA/OpenShell/sdk/go/proto/openshellv1" + "github.com/stretchr/testify/require" + "google.golang.org/grpc" + "google.golang.org/grpc/codes" + "google.golang.org/grpc/credentials/insecure" + "google.golang.org/grpc/metadata" + "google.golang.org/grpc/status" + "google.golang.org/grpc/test/bufconn" + "google.golang.org/protobuf/proto" + "google.golang.org/protobuf/reflect/protoreflect" +) + +func TestSandboxStatusRetainsBaselinePublicShape(t *testing.T) { + // Freeze the pre-image-update fields and tags: private operation state must + // not enlarge the public Rust struct or leak into generated SDK messages. + fields := []string{ + "agent_pod", "agent_fd", "sandbox_fd", "conditions", "phase", + "current_policy_version", "main_process_instance_id", "exit_code", + "endpoint_statuses", "configuration_admission", "configuration_activated", + "provisioning", "restart_count", "next_restart_time", + "main_process_started_time", "last_token_grant_failure", + } + descriptor := (&pb.SandboxStatus{}).ProtoReflect().Descriptor() + require.Equal(t, len(fields), descriptor.Fields().Len()) + for i, name := range fields { + field := descriptor.Fields().ByName(protoreflect.Name(name)) + require.NotNil(t, field, name) + require.Equal(t, protoreflect.FieldNumber(i+2), field.Number(), name) + } + require.Nil(t, pb.File_openshell_proto.Messages().ByName("SandboxImageUpdate")) + legacy := pb.File_openshell_proto.Services().ByName("OpenShell") + require.Nil(t, legacy.Methods().ByName("UpdateSandbox")) + updates := pb.File_openshell_proto.Services().ByName("SandboxUpdates") + require.NotNil(t, updates) + require.Equal(t, 1, updates.Methods().Len()) + method := updates.Methods().Get(0) + require.Equal(t, protoreflect.FullName("openshell.v1.UpdateSandboxRequest"), method.Input().FullName()) + require.Equal(t, protoreflect.FullName("openshell.v1.SandboxResponse"), method.Output().FullName()) + require.Equal(t, "/openshell.v1.SandboxUpdates/UpdateSandbox", pb.SandboxUpdates_UpdateSandbox_FullMethodName) +} + +type legacyHealthServer struct { + pb.UnimplementedOpenShellServer +} + +func (legacyHealthServer) Health(context.Context, *pb.HealthRequest) (*pb.HealthResponse, error) { + return &pb.HealthResponse{Version: "legacy-compatible"}, nil +} + +type imageUpdateServer struct { + pb.UnimplementedSandboxUpdatesServer + request *pb.UpdateSandboxRequest +} + +func (s *imageUpdateServer) UpdateSandbox(_ context.Context, request *pb.UpdateSandboxRequest) (*pb.SandboxResponse, error) { + s.request = proto.Clone(request).(*pb.UpdateSandboxRequest) + return &pb.SandboxResponse{Sandbox: &pb.Sandbox{ + Metadata: &dm.ObjectMeta{Id: "stable-id", Name: request.Name, Workspace: request.WorkspaceScope.GetWorkspace()}, + Spec: &pb.SandboxSpec{Template: &pb.SandboxTemplate{Image: request.Image}}, + }}, nil +} + +func TestSeparateSandboxUpdatesTransportCoexistsWithLegacyOpenShell(t *testing.T) { + listener := bufconn.Listen(1024 * 1024) + server := grpc.NewServer(grpc.UnaryInterceptor(func(ctx context.Context, request any, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (any, error) { + if info.FullMethod == pb.SandboxUpdates_UpdateSandbox_FullMethodName { + md, _ := metadata.FromIncomingContext(ctx) + if len(md.Get("authorization")) == 0 { + return nil, status.Error(codes.Unauthenticated, "bearer required") + } + } + return handler(ctx, request) + })) + updatesServer := &imageUpdateServer{} + pb.RegisterOpenShellServer(server, legacyHealthServer{}) + pb.RegisterSandboxUpdatesServer(server, updatesServer) + go func() { _ = server.Serve(listener) }() + t.Cleanup(server.Stop) + t.Cleanup(func() { _ = listener.Close() }) + conn, err := grpc.NewClient("passthrough:///sandbox-updates", grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithContextDialer(func(context.Context, string) (net.Conn, error) { + return listener.Dial() + })) + require.NoError(t, err) + t.Cleanup(func() { _ = conn.Close() }) + legacy := pb.NewOpenShellClient(conn) + health, err := legacy.Health(context.Background(), &pb.HealthRequest{}) + require.NoError(t, err) + require.Equal(t, "legacy-compatible", health.Version) + updates := pb.NewSandboxUpdatesClient(conn) + request := &pb.UpdateSandboxRequest{ + WorkspaceScope: &dm.WorkspaceSelector{Selection: &dm.WorkspaceSelector_Workspace{Workspace: "team"}}, + Name: "sandbox", + Image: "example/workload:new", + ExpectedResourceVersion: 42, + RequestId: "550e8400-e29b-41d4-a716-446655440000", + } + _, err = updates.UpdateSandbox(context.Background(), request) + require.Equal(t, codes.Unauthenticated, status.Code(err)) + require.Nil(t, updatesServer.request) + ctx := metadata.NewOutgoingContext(context.Background(), metadata.Pairs("authorization", "Bearer test-token")) + response, err := updates.UpdateSandbox(ctx, request) + require.NoError(t, err) + require.True(t, proto.Equal(request, updatesServer.request)) + require.Equal(t, "stable-id", response.Sandbox.Metadata.Id) + require.Equal(t, "team", response.Sandbox.Metadata.Workspace) + require.Equal(t, request.Image, response.Sandbox.Spec.Template.Image) + // The old service has no accidental update endpoint. + err = conn.Invoke(ctx, "/openshell.v1.OpenShell/UpdateSandbox", request, &pb.SandboxResponse{}) + require.Equal(t, codes.Unimplemented, status.Code(err)) +} diff --git a/sdk/typescript/src/raw.test.ts b/sdk/typescript/src/raw.test.ts index 9d2e02ac6e..798d23b536 100644 --- a/sdk/typescript/src/raw.test.ts +++ b/sdk/typescript/src/raw.test.ts @@ -3,10 +3,55 @@ import type { MessageInitShape } from '@bufbuild/protobuf'; import { timestampFromDate } from '@bufbuild/protobuf/wkt'; -import { createRouterTransport } from '@connectrpc/connect'; +import { createClient, createRouterTransport } from '@connectrpc/connect'; import { describe, expect, it } from 'vitest'; import { SandboxClient } from './index.js'; -import { EndpointResult, type EndpointStatusSchema, OpenShell, SandboxPhase } from './raw.js'; +import { EndpointResult, type EndpointStatusSchema, OpenShell, SandboxPhase, SandboxUpdates } from './raw.js'; + +describe('raw sandbox image updates', () => { + it.each([true, false])('uses a separate service on the existing transport (binary: %s)', async (useBinaryFormat) => { + const transport = createRouterTransport( + (router) => { + router.service(OpenShell, { + getSandbox: () => ({ sandbox: { metadata: { id: 'stable-id' } } }), + }); + router.service(SandboxUpdates, { + updateSandbox: (request) => { + expect(request.workspaceScope?.selection).toEqual({ case: 'workspace', value: 'team' }); + expect(request.name).toBe('sandbox'); + expect(request.expectedResourceVersion).toBe(42n); + expect(request.requestId).toBe('550e8400-e29b-41d4-a716-446655440000'); + return { + sandbox: { + metadata: { id: 'stable-id', name: request.name, workspace: 'team' }, + spec: { template: { image: request.image } }, + status: { phase: SandboxPhase.STOPPED }, + }, + }; + }, + }); + }, + { transport: { useBinaryFormat } }, + ); + const legacy = new SandboxClient(transport); + const updates = createClient(SandboxUpdates, legacy.transport); + expect(Object.hasOwn(OpenShell.method, 'updateSandbox')).toBe(false); + expect(SandboxUpdates.typeName).toBe('openshell.v1.SandboxUpdates'); + const before = await legacy.raw.getSandbox({ name: 'sandbox' }); + const response = await updates.updateSandbox({ + workspaceScope: { selection: { case: 'workspace', value: 'team' } }, + name: 'sandbox', + image: 'example/workload:new', + expectedResourceVersion: 42n, + requestId: '550e8400-e29b-41d4-a716-446655440000', + }); + expect(response.sandbox?.metadata?.id).toBe(before.sandbox?.metadata?.id); + expect(response.sandbox?.spec?.template?.image).toBe('example/workload:new'); + expect(response.sandbox?.status?.phase).toBe(SandboxPhase.STOPPED); + expect(response.sandbox?.status).not.toHaveProperty('imageUpdate'); + expect(response.sandbox?.status).not.toHaveProperty('imageRevision'); + }); +}); describe('raw sandbox endpoint status', () => { it.each([true, false])( diff --git a/sdk/typescript/src/raw.ts b/sdk/typescript/src/raw.ts index 1571e8e23e..067a6558b9 100644 --- a/sdk/typescript/src/raw.ts +++ b/sdk/typescript/src/raw.ts @@ -4,7 +4,7 @@ export * from './gen/datamodel_pb.js'; export * from './gen/google/rpc/error_details_pb.js'; // Advanced surface: the full generated protobuf types (messages, enums, and the -// OpenShell service descriptor) for callers using the raw escape hatch on +// OpenShell and SandboxUpdates service descriptors) for callers using the raw escape hatch on // OpenShellClient / SandboxClient (`.raw` and `.transport`). These are the // uncurated wire types; import them from '@nvidia/openshell-sdk/raw'. The // curated entry point stays free of generated types so its surface does not diff --git a/skills/debug-openshell-cluster/SKILL.md b/skills/debug-openshell-cluster/SKILL.md index ddf042c67c..f6f651ea2b 100644 --- a/skills/debug-openshell-cluster/SKILL.md +++ b/skills/debug-openshell-cluster/SKILL.md @@ -1139,6 +1139,46 @@ network supervisor logs for CONNECT and upstream-proxy decisions: kubectl -n logs pod/ --tail=200 | grep -Ei 'upstream|connect|proxy' ``` +#### Sandbox image-update activation and recovery + +`openshell.v1.SandboxUpdates/UpdateSandbox` uses the existing authenticated +gateway listener and defaults to disabled. Check the effective +`[openshell.gateway] enable_sandbox_image_updates` value and its overrides, +`--enable-sandbox-image-updates true` or +`OPENSHELL_ENABLE_SANDBOX_IMAGE_UPDATES=true`. Canonical Helm values use: + +```yaml +gatewayConfig: + "openshell.gateway": + enable_sandbox_image_updates: true +``` + +Do not enable the flag to work around an error. It attests that all incompatible +gateways, including unregistered processes and Jobs, have been drained and +retired, their outstanding driver operations have settled, and old binaries +cannot return through rollout or rollback configurations. Keep it false during +a rolling upgrade. SQLite supports one gateway process, not shared-file HA. + +On PostgreSQL, an unmarked client backend in the same database blocks updates, +including an administrative session. The new binary sets every pool +connection's `application_name` to `openshell-image-update-v1`; close unmarked +sessions or use a dedicated database, rather than relabeling old clients. Live +gateway membership must advertise image-update protocol 1; malformed or +truncated membership reads fail closed. Neither these observations nor an +expired membership TTL proves old gateways and their work have stopped. Follow +the published +[activation checklist](https://docs.nvidia.com/openshell/latest/kubernetes/high-availability#activate-sandbox-image-updates), +and do not downgrade while updates are pending or retained sandboxes require +the private revision protocol. + +For an operation-pending error, use the original requested image and a fresh +sandbox resource version to reconcile through `SandboxUpdates`. Intent and +revision are private, not new public status fields. Start, stop, provisioning +retry, and delete do not bypass the barrier. Preserve request-admission semantics: +never change the payload under an existing ID or blindly switch IDs after a +timeout. See the published +[recovery contract](https://docs.nvidia.com/openshell/latest/sdk/api-errors#sandbox-image-update-recovery). + ### Step 7: Check VM-Backed Gateways Use the VM driver logs and host diagnostics available in the user's environment. Verify: diff --git a/skills/openshell-cli/SKILL.md b/skills/openshell-cli/SKILL.md index 7648537c16..960eb5be53 100644 --- a/skills/openshell-cli/SKILL.md +++ b/skills/openshell-cli/SKILL.md @@ -540,12 +540,21 @@ For an infrastructure `Error` on a backend that supports restarting stopped sand ### Change a stopped sandbox's workload image Do not invent a `sandbox update` command or use delete/create to change an -existing sandbox's image. The raw `UpdateSandbox` RPC initially supports only -stopped Kubernetes sandboxes; other drivers return `UNIMPLEMENTED`. Stop and +existing sandbox's image. The separate +`openshell.v1.SandboxUpdates/UpdateSandbox` RPC uses the same gateway listener +and authentication as `OpenShell`. It defaults to disabled; the operator must +complete the published +[activation checklist](https://docs.nvidia.com/openshell/latest/kubernetes/high-availability#activate-sandbox-image-updates) +before enabling `enable_sandbox_image_updates`. Keep it false during a rolling +upgrade and never enable it merely to bypass a failed compatibility check. +After activation, the RPC initially supports only stopped Kubernetes sandboxes; +other drivers return `UNIMPLEMENTED`. Stop and wait for `Stopped`, read the sandbox's current resource version through `GetSandbox`, call raw `UpdateSandbox` with the named workspace, sandbox name, OCI image, and required nonzero `expected_resource_version`, then start after -success. There is no curated SDK update method. The sandbox identity, Kubernetes +success. Rust SDK callers use `client.raw_sandbox_updates_fresh()`; generated +clients use `SandboxUpdates`, not the unchanged `OpenShell` service. There is no +curated SDK update method. The sandbox identity, Kubernetes custom resource, and persistent volume claim remain; the existing workspace is not reseeded and trusted runtime images do not change. @@ -554,8 +563,10 @@ cleanup completion and settlement of the original driver operation, then run `sandbox stop` to obtain `Stopped` before correcting the image. This retains the timeout diagnostic and storage and does not bypass pending cleanup. -If raw `sandbox.status.image_update` is present after a failure, start is -blocked. Read a fresh version and retry that same pending image. An optional +An operation-pending error after a failure blocks start, stop, provisioning +retry, and delete. Image intent and revision are private; the public `SandboxStatus` +shape is unchanged. Read a fresh version and retry the same image originally +requested, even if the spec already names it. An optional `request_id` with an unresolved admission does not execute again; inspect and reconcile state before submitting a new conditional request with a fresh version and new ID, or no ID. Never change the payload under the original ID or From a7e585db06a6f55a47d9aa6aa8629af75d69005e Mon Sep 17 00:00:00 2001 From: sjenning <493891+sjenning@users.noreply.github.com> Date: Thu, 15 Oct 2026 21:33:07 -0500 Subject: [PATCH 4/7] fix(gateway): preserve optional driver compatibility and repair CI Move image updates to a separate optional compute-driver service, preserving the baseline generated trait and streaming associated type. Add source and TCP/UDS transport regressions, capability negotiation coverage, and a default-unsupported in-process extension. Keep Go compatibility tests outside generated output and update production reflection expectations for the separate sandbox update service. Signed-off-by: sjenning <493891+sjenning@users.noreply.github.com> --- crates/openshell-core/README.md | 13 + crates/openshell-core/src/compute.rs | 26 ++ crates/openshell-core/src/lib.rs | 1 + .../tests/compute_driver_compat.rs | 292 ++++++++++++++++++ crates/openshell-driver-docker/src/lib.rs | 26 +- crates/openshell-driver-kubernetes/README.md | 4 +- .../openshell-driver-kubernetes/src/grpc.rs | 55 ++-- .../src/image_update_tests.rs | 2 +- .../openshell-driver-kubernetes/src/main.rs | 7 +- crates/openshell-driver-mxc/src/grpc.rs | 13 +- crates/openshell-driver-podman/src/grpc.rs | 13 +- crates/openshell-driver-vm/src/driver.rs | 13 +- crates/openshell-otel/src/grpc.rs | 11 +- crates/openshell-server/src/compute/mod.rs | 227 ++++++++++---- crates/openshell-server/src/lib.rs | 2 +- crates/openshell-server/src/test_support.rs | 36 ++- proto/compute_driver.proto | 20 +- .../compatibility}/sandbox_updates_test.go | 2 +- 18 files changed, 620 insertions(+), 143 deletions(-) create mode 100644 crates/openshell-core/src/compute.rs create mode 100644 crates/openshell-core/tests/compute_driver_compat.rs rename sdk/go/{proto/openshellv1 => tests/compatibility}/sandbox_updates_test.go (99%) diff --git a/crates/openshell-core/README.md b/crates/openshell-core/README.md index 1cf1b7e70e..707e3ec77b 100644 --- a/crates/openshell-core/README.md +++ b/crates/openshell-core/README.md @@ -65,6 +65,19 @@ configuration validation live in `openshell_core::middleware`. Policy admission and the supervisor runtime consume the same contract without introducing a dependency from the policy crate to the supervisor implementation. +## Optional Compute Image Updates + +The generated `proto::compute::v1::compute_driver_server::ComputeDriver` trait +retains its baseline methods and streaming associated type. External drivers +that support image updates additionally serve `ComputeDriverImageUpdates` on +the same endpoint and advertise `openshell.compute.update-sandbox-image`. +Drivers without that capability need no new generated-trait method. + +Linked in-process drivers implement `openshell_core::compute::ComputeDriver` +in addition to the generated baseline trait. An empty implementation inherits +`UNIMPLEMENTED` for image updates; supporting drivers override the optional +method. The gateway negotiates the capability before invoking either path. + ## Protobuf Struct Conversion Use `openshell_core::proto_struct` when crossing between `serde_json` values and diff --git a/crates/openshell-core/src/compute.rs b/crates/openshell-core/src/compute.rs new file mode 100644 index 0000000000..57722752e3 --- /dev/null +++ b/crates/openshell-core/src/compute.rs @@ -0,0 +1,26 @@ +// SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +// SPDX-License-Identifier: Apache-2.0 + +//! In-process compute contract, separate from the baseline generated gRPC trait. + +use crate::proto::compute::v1::{ + UpdateSandboxImageRequest, UpdateSandboxImageResponse, compute_driver_server, +}; + +/// Gateway-facing in-process compute driver with optional image updates. +/// +/// External servers implement the unchanged generated +/// [`compute_driver_server::ComputeDriver`] trait and, when supported, the +/// separate generated `ComputeDriverImageUpdates` service on the same endpoint. +/// In-process drivers use this default unless they advertise image updates. +#[tonic::async_trait] +pub trait ComputeDriver: compute_driver_server::ComputeDriver { + async fn update_sandbox_image( + &self, + _request: tonic::Request, + ) -> Result, tonic::Status> { + Err(tonic::Status::unimplemented( + "storage-preserving image updates are not supported by this driver", + )) + } +} diff --git a/crates/openshell-core/src/lib.rs b/crates/openshell-core/src/lib.rs index 9e70b309c2..c688734488 100644 --- a/crates/openshell-core/src/lib.rs +++ b/crates/openshell-core/src/lib.rs @@ -11,6 +11,7 @@ pub mod activity; pub mod auth; +pub mod compute; pub mod config; pub mod container_paths; pub mod denial; diff --git a/crates/openshell-core/tests/compute_driver_compat.rs b/crates/openshell-core/tests/compute_driver_compat.rs new file mode 100644 index 0000000000..40f0124af5 --- /dev/null +++ b/crates/openshell-core/tests/compute_driver_compat.rs @@ -0,0 +1,292 @@ +// SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +// SPDX-License-Identifier: Apache-2.0 + +//! Fixed baseline server source fixture from 6546691d5e493343c7877573252e835d28bf9e23. +//! It deliberately implements only the original generated `ComputeDriver` methods, +//! including its concrete streaming associated type, with no image-update method +//! or in-process extension trait. New optional RPCs must not break this source. + +use openshell_core::proto::compute::v1::{ + AuthenticateSandboxRequest, AuthenticateSandboxResponse, CreateSandboxRequest, + CreateSandboxResponse, DeleteSandboxRequest, DeleteSandboxResponse, DeleteWorkspaceRequest, + DeleteWorkspaceResponse, EnsureWorkspaceRequest, EnsureWorkspaceResponse, + GetCapabilitiesRequest, GetCapabilitiesResponse, GetSandboxRequest, GetSandboxResponse, + ListSandboxesRequest, ListSandboxesResponse, StartSandboxRequest, StartSandboxResponse, + StopSandboxRequest, StopSandboxResponse, UpdateSandboxImageRequest, UpdateSandboxImageResponse, + ValidateSandboxCreateRequest, ValidateSandboxCreateResponse, WatchSandboxesEvent, + WatchSandboxesRequest, + compute_driver_client::ComputeDriverClient, + compute_driver_image_updates_client::ComputeDriverImageUpdatesClient, + compute_driver_image_updates_server::{ + ComputeDriverImageUpdates, ComputeDriverImageUpdatesServer, + }, + compute_driver_server::{ComputeDriver, ComputeDriverServer}, +}; +use prost::Message; +use std::pin::Pin; +use std::sync::{Arc, Mutex}; +use std::task::{Context, Poll}; +use tokio::net::{TcpListener, TcpStream}; +use tokio_stream::Stream; +use tonic::{Request, Response, Status}; + +#[derive(Debug)] +struct BaselineDriver; + +#[tonic::async_trait] +impl ComputeDriver for BaselineDriver { + async fn get_capabilities( + &self, + _request: Request, + ) -> Result, Status> { + Ok(Response::new(GetCapabilitiesResponse { + driver_name: "baseline-source-fixture".into(), + ..Default::default() + })) + } + + async fn authenticate_sandbox( + &self, + _request: Request, + ) -> Result, Status> { + Err(Status::unimplemented("fixture")) + } + + async fn validate_sandbox_create( + &self, + _request: Request, + ) -> Result, Status> { + Err(Status::unimplemented("fixture")) + } + + async fn get_sandbox( + &self, + _request: Request, + ) -> Result, Status> { + Err(Status::unimplemented("fixture")) + } + + async fn list_sandboxes( + &self, + _request: Request, + ) -> Result, Status> { + Ok(Response::new(ListSandboxesResponse { sandboxes: vec![] })) + } + + async fn create_sandbox( + &self, + _request: Request, + ) -> Result, Status> { + Err(Status::unimplemented("fixture")) + } + + async fn stop_sandbox( + &self, + _request: Request, + ) -> Result, Status> { + Err(Status::unimplemented("fixture")) + } + + async fn start_sandbox( + &self, + _request: Request, + ) -> Result, Status> { + Err(Status::unimplemented("fixture")) + } + + async fn delete_sandbox( + &self, + _request: Request, + ) -> Result, Status> { + Err(Status::unimplemented("fixture")) + } + + type WatchSandboxesStream = tokio_stream::Empty>; + + async fn watch_sandboxes( + &self, + _request: Request, + ) -> Result, Status> { + Ok(Response::new(tokio_stream::empty())) + } + + async fn ensure_workspace( + &self, + _request: Request, + ) -> Result, Status> { + Err(Status::unimplemented("fixture")) + } + + async fn delete_workspace( + &self, + _request: Request, + ) -> Result, Status> { + Err(Status::unimplemented("fixture")) + } +} + +#[derive(Debug, Clone, Default)] +struct ImageUpdates { + calls: Arc>>, +} + +#[tonic::async_trait] +impl ComputeDriverImageUpdates for ImageUpdates { + async fn update_sandbox_image( + &self, + request: Request, + ) -> Result, Status> { + self.calls.lock().unwrap().push(request.into_inner()); + Ok(Response::new(UpdateSandboxImageResponse {})) + } +} + +struct TcpIncoming(TcpListener); + +impl Stream for TcpIncoming { + type Item = std::io::Result; + + fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll> { + self.0.poll_accept(cx).map(|result| { + Some(result.map(|(stream, _)| { + openshell_core::net::set_tcp_nodelay_best_effort(&stream); + stream + })) + }) + } +} + +async fn roundtrip(serve_image_updates: bool) { + let listener = TcpListener::bind("127.0.0.1:0").await.unwrap(); + let address = listener.local_addr().unwrap(); + let extension = ImageUpdates::default(); + let optional_service = + serve_image_updates.then(|| ComputeDriverImageUpdatesServer::new(extension.clone())); + let (shutdown_tx, shutdown_rx) = tokio::sync::oneshot::channel(); + let server = tokio::spawn(async move { + tonic::transport::Server::builder() + .add_service(ComputeDriverServer::new(BaselineDriver)) + .add_optional_service(optional_service) + .serve_with_incoming_shutdown(TcpIncoming(listener), async { + let _ = shutdown_rx.await; + }) + .await + .unwrap(); + }); + let channel = tonic::transport::Endpoint::from_shared(format!("http://{address}")) + .unwrap() + .connect() + .await + .unwrap(); + let mut baseline = ComputeDriverClient::new(channel.clone()); + assert_eq!( + baseline + .get_capabilities(GetCapabilitiesRequest::default()) + .await + .unwrap() + .into_inner() + .driver_name, + "baseline-source-fixture" + ); + assert!( + baseline + .list_sandboxes(ListSandboxesRequest {}) + .await + .unwrap() + .into_inner() + .sandboxes + .is_empty() + ); + assert!( + baseline + .watch_sandboxes(WatchSandboxesRequest {}) + .await + .unwrap() + .into_inner() + .message() + .await + .unwrap() + .is_none() + ); + + let request = UpdateSandboxImageRequest { + sandbox_id: "sandbox-id".into(), + image: "example/workload:v2".into(), + ..Default::default() + }; + let result = ComputeDriverImageUpdatesClient::new(channel) + .update_sandbox_image(request.clone()) + .await; + if serve_image_updates { + result.unwrap(); + assert_eq!(*extension.calls.lock().unwrap(), vec![request]); + } else { + assert_eq!(result.unwrap_err().code(), tonic::Code::Unimplemented); + assert!(extension.calls.lock().unwrap().is_empty()); + } + // Absence of the optional service must not impair the original service. + baseline + .list_sandboxes(ListSandboxesRequest {}) + .await + .unwrap(); + drop(baseline); + shutdown_tx.send(()).unwrap(); + server.await.unwrap(); +} + +#[tokio::test] +async fn baseline_generated_server_source_and_transport_remain_compatible() { + roundtrip(false).await; +} + +#[tokio::test] +async fn optional_image_service_shares_the_baseline_channel() { + roundtrip(true).await; +} + +#[test] +fn baseline_compute_service_methods_are_frozen() { + let descriptor = + prost_types::FileDescriptorSet::decode(openshell_core::FILE_DESCRIPTOR_SET).unwrap(); + let compute = descriptor + .file + .iter() + .find(|file| file.package.as_deref() == Some("openshell.compute.v1")) + .unwrap(); + let baseline = compute + .service + .iter() + .find(|service| service.name.as_deref() == Some("ComputeDriver")) + .unwrap(); + assert_eq!( + baseline + .method + .iter() + .map(|method| method.name.as_deref().unwrap()) + .collect::>(), + vec![ + "GetCapabilities", + "AuthenticateSandbox", + "ValidateSandboxCreate", + "GetSandbox", + "ListSandboxes", + "CreateSandbox", + "StopSandbox", + "StartSandbox", + "DeleteSandbox", + "WatchSandboxes", + "EnsureWorkspace", + "DeleteWorkspace", + ] + ); + let image_updates = compute + .service + .iter() + .find(|service| service.name.as_deref() == Some("ComputeDriverImageUpdates")) + .unwrap(); + assert_eq!(image_updates.method.len(), 1); + assert_eq!( + image_updates.method[0].name.as_deref(), + Some("UpdateSandboxImage") + ); +} diff --git a/crates/openshell-driver-docker/src/lib.rs b/crates/openshell-driver-docker/src/lib.rs index 88e74918d5..f9351911f0 100644 --- a/crates/openshell-driver-docker/src/lib.rs +++ b/crates/openshell-driver-docker/src/lib.rs @@ -3110,17 +3110,10 @@ fn validate_docker_outer_fence( Ok(()) } #[tonic::async_trait] -impl ComputeDriver for ComputeDriverService { - async fn update_sandbox_image( - &self, - _request: Request, - ) -> Result, Status> - { - Err(Status::unimplemented( - "storage-preserving image updates are not supported by this driver", - )) - } +impl openshell_core::compute::ComputeDriver for ComputeDriverService {} +#[tonic::async_trait] +impl ComputeDriver for ComputeDriverService { type WatchSandboxesStream = WatchStream; async fn authenticate_sandbox( @@ -3273,17 +3266,10 @@ impl ComputeDriver for ComputeDriverService { } #[tonic::async_trait] -impl ComputeDriver for DockerComputeDriver { - async fn update_sandbox_image( - &self, - _request: Request, - ) -> Result, Status> - { - Err(Status::unimplemented( - "storage-preserving image updates are not supported by this driver", - )) - } +impl openshell_core::compute::ComputeDriver for DockerComputeDriver {} +#[tonic::async_trait] +impl ComputeDriver for DockerComputeDriver { async fn authenticate_sandbox( &self, _request: Request, diff --git a/crates/openshell-driver-kubernetes/README.md b/crates/openshell-driver-kubernetes/README.md index cfba32db4e..9b94ef9381 100644 --- a/crates/openshell-driver-kubernetes/README.md +++ b/crates/openshell-driver-kubernetes/README.md @@ -160,7 +160,9 @@ condition and deletion of the backing pod. Legacy `v1alpha1` controllers omit a usable stopped condition, so pod deletion alone confirms their stop. The optional `openshell.compute.update-sandbox-image` capability supports -image-only updates while the sandbox is stopped. `UpdateSandboxImage` requires +image-only updates while the sandbox is stopped. External drivers serve it as +the separate `ComputeDriverImageUpdates` service on the baseline `ComputeDriver` +endpoint, preserving the baseline generated server trait. `UpdateSandboxImage` requires the persisted Kubernetes runtime identity, current image, sandbox name, and a stable operation ID with a monotonic image revision. The driver verifies that the same Sandbox resource is suspended, runtime bootstrap has completed, and diff --git a/crates/openshell-driver-kubernetes/src/grpc.rs b/crates/openshell-driver-kubernetes/src/grpc.rs index 2ef25533d3..4ff485a675 100644 --- a/crates/openshell-driver-kubernetes/src/grpc.rs +++ b/crates/openshell-driver-kubernetes/src/grpc.rs @@ -215,26 +215,6 @@ impl ComputeDriver for ComputeDriverService { .await } - async fn update_sandbox_image( - &self, - request: Request, - ) -> Result, Status> - { - self.rpc_tracer - .trace(openshell_otel::rpc::UPDATE_SANDBOX_IMAGE, async { - self.driver - .update_sandbox_image(&request.into_inner()) - .await - .map_err(|error| { - Status::from(openshell_core::ComputeDriverError::from(error)) - })?; - Ok(Response::new( - openshell_core::proto::compute::v1::UpdateSandboxImageResponse {}, - )) - }) - .await - } - async fn delete_sandbox( &self, request: Request, @@ -348,6 +328,41 @@ impl ComputeDriver for ComputeDriverService { } } +#[tonic::async_trait] +impl openshell_core::compute::ComputeDriver for ComputeDriverService { + async fn update_sandbox_image( + &self, + request: Request, + ) -> Result, Status> + { + self.rpc_tracer + .trace(openshell_otel::rpc::UPDATE_SANDBOX_IMAGE, async { + self.driver + .update_sandbox_image(&request.into_inner()) + .await + .map_err(|error| { + Status::from(openshell_core::ComputeDriverError::from(error)) + })?; + Ok(Response::new( + openshell_core::proto::compute::v1::UpdateSandboxImageResponse {}, + )) + }) + .await + } +} + +#[tonic::async_trait] +impl openshell_core::proto::compute::v1::compute_driver_image_updates_server::ComputeDriverImageUpdates + for ComputeDriverService +{ + async fn update_sandbox_image( + &self, + request: Request, + ) -> Result, Status> { + openshell_core::compute::ComputeDriver::update_sandbox_image(self, request).await + } +} + fn workspace_delete_requires_namespace_access(mode: WorkspaceMode) -> bool { matches!(mode, WorkspaceMode::Managed) } diff --git a/crates/openshell-driver-kubernetes/src/image_update_tests.rs b/crates/openshell-driver-kubernetes/src/image_update_tests.rs index 780e435e7d..3ef561a6c1 100644 --- a/crates/openshell-driver-kubernetes/src/image_update_tests.rs +++ b/crates/openshell-driver-kubernetes/src/image_update_tests.rs @@ -560,7 +560,7 @@ async fn image_update_conflict_does_not_blindly_retry_or_recreate() { #[tokio::test] async fn image_update_grpc_maps_validation_and_precondition_errors() { - use openshell_core::proto::compute::v1::compute_driver_server::ComputeDriver; + use openshell_core::proto::compute::v1::compute_driver_image_updates_server::ComputeDriverImageUpdates; let (driver, state) = fixture(SANDBOX_VERSION_V1BETA1, false); let service = crate::ComputeDriverService::new(driver); let mut invalid = request(); diff --git a/crates/openshell-driver-kubernetes/src/main.rs b/crates/openshell-driver-kubernetes/src/main.rs index ab6e0bf1b8..389ca5b785 100644 --- a/crates/openshell-driver-kubernetes/src/main.rs +++ b/crates/openshell-driver-kubernetes/src/main.rs @@ -9,6 +9,7 @@ use std::path::PathBuf; use tracing::info; use openshell_core::VERSION; +use openshell_core::proto::compute::v1::compute_driver_image_updates_server::ComputeDriverImageUpdatesServer; use openshell_core::proto::compute::v1::compute_driver_server::ComputeDriverServer; use openshell_driver_kubernetes::{ ComputeDriverService, DEFAULT_GATEWAY_ID, DEFAULT_SANDBOX_SERVICE_ACCOUNT_NAME, @@ -331,7 +332,9 @@ async fn main() -> Result<()> { .await .into_diagnostic()?; - let service = ComputeDriverServer::new(ComputeDriverService::new(driver)); + let driver_service = ComputeDriverService::new(driver); + let image_updates_service = ComputeDriverImageUpdatesServer::new(driver_service.clone()); + let service = ComputeDriverServer::new(driver_service); let shutdown = async move { shutdown_signal().await; let _ = shutdown_tx.send(true); @@ -345,6 +348,7 @@ async fn main() -> Result<()> { tonic::transport::Server::builder() .layer(openshell_otel::compute_driver_rpc_layer()) .add_service(service) + .add_service(image_updates_service) .serve_with_incoming_shutdown( openshell_core::external_driver_socket::SameUidUnixIncoming::new(listener), shutdown, @@ -356,6 +360,7 @@ async fn main() -> Result<()> { tonic::transport::Server::builder() .layer(openshell_otel::compute_driver_rpc_layer()) .add_service(service) + .add_service(image_updates_service) .serve_with_shutdown(args.bind_address, shutdown) .await .into_diagnostic() diff --git a/crates/openshell-driver-mxc/src/grpc.rs b/crates/openshell-driver-mxc/src/grpc.rs index 27810b435b..e2b4f57461 100644 --- a/crates/openshell-driver-mxc/src/grpc.rs +++ b/crates/openshell-driver-mxc/src/grpc.rs @@ -33,17 +33,10 @@ impl ComputeDriverService { } #[tonic::async_trait] -impl ComputeDriver for ComputeDriverService { - async fn update_sandbox_image( - &self, - _request: Request, - ) -> Result, Status> - { - Err(Status::unimplemented( - "storage-preserving image updates are not supported by this driver", - )) - } +impl openshell_core::compute::ComputeDriver for ComputeDriverService {} +#[tonic::async_trait] +impl ComputeDriver for ComputeDriverService { async fn get_capabilities( &self, request: Request, diff --git a/crates/openshell-driver-podman/src/grpc.rs b/crates/openshell-driver-podman/src/grpc.rs index c7eda30a90..6db17d37ab 100644 --- a/crates/openshell-driver-podman/src/grpc.rs +++ b/crates/openshell-driver-podman/src/grpc.rs @@ -49,17 +49,10 @@ impl ComputeDriverService { } #[tonic::async_trait] -impl ComputeDriver for ComputeDriverService { - async fn update_sandbox_image( - &self, - _request: Request, - ) -> Result, Status> - { - Err(Status::unimplemented( - "storage-preserving image updates are not supported by this driver", - )) - } +impl openshell_core::compute::ComputeDriver for ComputeDriverService {} +#[tonic::async_trait] +impl ComputeDriver for ComputeDriverService { async fn authenticate_sandbox( &self, _request: Request, diff --git a/crates/openshell-driver-vm/src/driver.rs b/crates/openshell-driver-vm/src/driver.rs index 564f2439c9..ac2327da0d 100644 --- a/crates/openshell-driver-vm/src/driver.rs +++ b/crates/openshell-driver-vm/src/driver.rs @@ -4814,17 +4814,10 @@ fn configure_main_exit_marker(command: &mut Command, state_dir: &Path) { } #[tonic::async_trait] -impl ComputeDriver for VmDriver { - async fn update_sandbox_image( - &self, - _request: Request, - ) -> Result, Status> - { - Err(Status::unimplemented( - "storage-preserving image updates are not supported by this driver", - )) - } +impl openshell_core::compute::ComputeDriver for VmDriver {} +#[tonic::async_trait] +impl ComputeDriver for VmDriver { async fn authenticate_sandbox( &self, _request: Request, diff --git a/crates/openshell-otel/src/grpc.rs b/crates/openshell-otel/src/grpc.rs index 59f901568d..6cd6a55fef 100644 --- a/crates/openshell-otel/src/grpc.rs +++ b/crates/openshell-otel/src/grpc.rs @@ -63,6 +63,8 @@ where } pub const COMPUTE_DRIVER_RPC_SERVICE: &str = "openshell.compute.v1.ComputeDriver"; +pub const COMPUTE_DRIVER_IMAGE_UPDATES_RPC_SERVICE: &str = + "openshell.compute.v1.ComputeDriverImageUpdates"; /// Low-cardinality semantic-convention identity for a compute-driver RPC. #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -102,10 +104,11 @@ pub mod rpc { "CreateSandbox", "openshell.compute.v1.ComputeDriver/CreateSandbox", ); - pub const UPDATE_SANDBOX_IMAGE: ComputeDriverRpc = ComputeDriverRpc::new( - "UpdateSandboxImage", - "openshell.compute.v1.ComputeDriver/UpdateSandboxImage", - ); + pub const UPDATE_SANDBOX_IMAGE: ComputeDriverRpc = ComputeDriverRpc { + service: super::COMPUTE_DRIVER_IMAGE_UPDATES_RPC_SERVICE, + method: "UpdateSandboxImage", + operation: "openshell.compute.v1.ComputeDriverImageUpdates/UpdateSandboxImage", + }; pub const GET_SANDBOX: ComputeDriverRpc = ComputeDriverRpc::new( "GetSandbox", "openshell.compute.v1.ComputeDriver/GetSandbox", diff --git a/crates/openshell-server/src/compute/mod.rs b/crates/openshell-server/src/compute/mod.rs index 3264b11c91..b61134d638 100644 --- a/crates/openshell-server/src/compute/mod.rs +++ b/crates/openshell-server/src/compute/mod.rs @@ -43,6 +43,7 @@ use openshell_core::proto::compute::v1::{ ResourceRequirements as DriverSandboxResourceRequirements, StartSandboxRequest, StopSandboxRequest, ValidateSandboxCreateRequest, WatchSandboxesEvent, WatchSandboxesRequest, WorkloadIdentityRequest, compute_driver_client::ComputeDriverClient, + compute_driver_image_updates_client::ComputeDriverImageUpdatesClient, compute_driver_server::ComputeDriver, watch_sandboxes_event, }; use openshell_core::proto::{ @@ -78,8 +79,11 @@ use tracing::{Instrument as _, debug, info, warn}; pub type DriverWatchStream = Pin> + Send>>; -pub type SharedComputeDriver = - Arc + Send + Sync>; +pub type SharedComputeDriver = Arc< + dyn openshell_core::compute::ComputeDriver + + Send + + Sync, +>; fn supports_isolation_registration(capabilities: &[String]) -> bool { capabilities.iter().any(|capability| { @@ -544,6 +548,9 @@ impl AcquiredRemoteDriverEndpoint { #[derive(Debug, Clone)] struct RemoteComputeDriver { client: RemoteComputeDriverClient, + image_updates_client: ComputeDriverImageUpdatesClient< + tonic::service::interceptor::InterceptedService, + >, admission_acknowledgement: Arc>>, } @@ -554,7 +561,11 @@ type RemoteComputeDriverClient = ComputeDriverClient< impl RemoteComputeDriver { fn new(channel: Channel) -> Self { Self { - client: ComputeDriverClient::with_interceptor(channel, TraceContextInterceptor), + client: ComputeDriverClient::with_interceptor(channel.clone(), TraceContextInterceptor), + image_updates_client: ComputeDriverImageUpdatesClient::with_interceptor( + channel, + TraceContextInterceptor, + ), admission_acknowledgement: Arc::new(StdMutex::new(None)), } } @@ -596,7 +607,7 @@ impl RemoteComputeDriver { } #[tonic::async_trait] -impl ComputeDriver for RemoteComputeDriver { +impl openshell_core::compute::ComputeDriver for RemoteComputeDriver { async fn update_sandbox_image( &self, request: Request, @@ -605,9 +616,15 @@ impl ComputeDriver for RemoteComputeDriver { Status, > { self.verify_admission_policy().await?; - self.client().update_sandbox_image(request).await + self.image_updates_client + .clone() + .update_sandbox_image(request) + .await } +} +#[tonic::async_trait] +impl ComputeDriver for RemoteComputeDriver { type WatchSandboxesStream = DriverWatchStream; async fn get_capabilities( @@ -7506,19 +7523,11 @@ impl Default for NoopTestDriver { #[cfg(any(test, feature = "test-support"))] #[tonic::async_trait] -impl ComputeDriver for NoopTestDriver { - async fn update_sandbox_image( - &self, - _request: Request, - ) -> Result< - tonic::Response, - Status, - > { - Err(Status::unimplemented( - "storage-preserving image updates are not supported by this driver", - )) - } +impl openshell_core::compute::ComputeDriver for NoopTestDriver {} +#[cfg(any(test, feature = "test-support"))] +#[tonic::async_trait] +impl ComputeDriver for NoopTestDriver { async fn authenticate_sandbox( &self, _request: Request, @@ -8143,19 +8152,10 @@ mod tests { } #[tonic::async_trait] - impl ComputeDriver for TestDriver { - async fn update_sandbox_image( - &self, - _request: Request, - ) -> Result< - tonic::Response, - Status, - > { - Err(Status::unimplemented( - "storage-preserving image updates are not supported by this driver", - )) - } + impl openshell_core::compute::ComputeDriver for TestDriver {} + #[tonic::async_trait] + impl ComputeDriver for TestDriver { async fn authenticate_sandbox( &self, _request: Request, @@ -8573,19 +8573,10 @@ mod tests { } #[tonic::async_trait] - impl ComputeDriver for ControlledDriver { - async fn update_sandbox_image( - &self, - _request: Request, - ) -> Result< - tonic::Response, - Status, - > { - Err(Status::unimplemented( - "storage-preserving image updates are not supported by this driver", - )) - } + impl openshell_core::compute::ComputeDriver for ControlledDriver {} + #[tonic::async_trait] + impl ComputeDriver for ControlledDriver { async fn authenticate_sandbox( &self, _request: Request, @@ -11850,19 +11841,10 @@ mod tests { struct FailingDriver(TestDriver); #[tonic::async_trait] - impl ComputeDriver for FailingDriver { - async fn update_sandbox_image( - &self, - _request: Request, - ) -> Result< - tonic::Response, - Status, - > { - Err(Status::unimplemented( - "storage-preserving image updates are not supported by this driver", - )) - } + impl openshell_core::compute::ComputeDriver for FailingDriver {} + #[tonic::async_trait] + impl ComputeDriver for FailingDriver { async fn authenticate_sandbox( &self, _request: Request, @@ -16721,10 +16703,11 @@ mod tests { async fn remote_compute_driver_interceptor_propagates_every_rpc() { use crate::otel_tracing::test_exporter; use crate::test_support::FakeComputeDriver; + use openshell_core::compute::ComputeDriver as _; let dir = tempfile::tempdir().unwrap(); let socket_path = dir.path().join("compute-driver.sock"); - let driver = FakeComputeDriver::new(); + let driver = FakeComputeDriver::new().with_sandbox_image_updates(); let _server = driver.serve_uds(&socket_path).unwrap(); let endpoint = connect_remote_compute_driver("external-test", &socket_path) .await @@ -16778,6 +16761,16 @@ mod tests { .watch_sandboxes(Request::new(WatchSandboxesRequest {})) .await .unwrap(); + remote + .update_sandbox_image(Request::new( + openshell_core::proto::compute::v1::UpdateSandboxImageRequest { + sandbox_id: sandbox.id.clone(), + image: "example/workload:v2".into(), + ..Default::default() + }, + )) + .await + .unwrap(); remote .delete_sandbox(Request::new(DeleteSandboxRequest { sandbox_id: sandbox.id, @@ -16795,7 +16788,7 @@ mod tests { let traceparents = driver.traceparents(); assert_eq!( traceparents.len(), - 10, + 12, "the client interceptor should cover every RPC" ); assert!( @@ -17354,6 +17347,130 @@ endpoint = { kind = "unix", socket_path = "/run/agent-substrate/isolation.sock" ); } + #[tokio::test] + #[cfg(unix)] + async fn remote_compute_driver_negotiates_optional_image_service() { + use crate::test_support::{FakeComputeDriver, FakeComputeDriverCall}; + use openshell_core::GetResourceVersion as _; + use openshell_core::extension_protocol::COMPUTE_UPDATE_SANDBOX_IMAGE; + + for supported in [false, true] { + let dir = tempfile::tempdir().unwrap(); + let socket_path = dir.path().join("image-updates.sock"); + let driver = FakeComputeDriver::new(); + let driver = if supported { + driver.with_sandbox_image_updates() + } else { + driver + }; + let _server = driver.serve_uds(&socket_path).unwrap(); + let endpoint = connect_remote_compute_driver("external-test", &socket_path) + .await + .unwrap(); + let store = Arc::new(crate::persistence::test_store().await); + crate::ensure_default_workspace(&store).await.unwrap(); + let mut runtime = ComputeRuntime::new_remote_driver( + endpoint, + store.clone(), + SandboxIndex::new(), + SandboxWatchBus::new(), + TracingLogBus::new(), + Arc::new(SupervisorSessionRegistry::new()), + ) + .await + .unwrap(); + runtime.image_updates_enabled = true; + assert_eq!( + runtime + .driver_info + .negotiated_extension + .supported_capabilities + .iter() + .any(|capability| capability == COMPUTE_UPDATE_SANDBOX_IMAGE), + supported, + ); + let mut sandbox = sandbox_record("sb-image", "image-sandbox", SandboxPhase::Stopped); + sandbox.metadata.as_mut().unwrap().annotations.insert( + COMPUTE_RUNTIME_IDENTITY_ANNOTATION.into(), + "stable-runtime".into(), + ); + sandbox.spec = Some(SandboxSpec { + template: Some(SandboxTemplate { + image: "example/workload:v1".into(), + ..Default::default() + }), + ..Default::default() + }); + store.put_message(&sandbox).await.unwrap(); + let sandbox = store + .get_message::("sb-image") + .await + .unwrap() + .unwrap(); + driver.clear_calls(); + let result = runtime + .update_sandbox_image( + "sb-image", + "example/workload:v2".into(), + sandbox.get_resource_version(), + ) + .await; + let requests = driver + .calls() + .into_iter() + .filter_map(|call| match call { + FakeComputeDriverCall::UpdateSandboxImage { request } => Some(request), + _ => None, + }) + .collect::>(); + if supported { + let updated = result.unwrap(); + assert_eq!( + updated.spec.unwrap().template.unwrap().image, + "example/workload:v2" + ); + assert_eq!( + requests.len(), + 2, + "preflight and mutation use the optional service" + ); + assert!(requests[0].validate_only); + assert!(!requests[1].validate_only); + for request in &requests { + assert_eq!(request.sandbox_id, "sb-image"); + assert_eq!(request.expected_runtime_identity, "stable-runtime"); + assert_eq!(request.expected_image, "example/workload:v1"); + assert_eq!(request.image, "example/workload:v2"); + } + assert_eq!(requests[0].operation_id, requests[1].operation_id); + } else { + assert_eq!(result.unwrap_err().code(), Code::Unimplemented); + assert!( + requests.is_empty(), + "capability admission must precede extension calls" + ); + let unchanged = store + .get_message::("sb-image") + .await + .unwrap() + .unwrap(); + assert_eq!(unchanged, sandbox); + } + } + } + + #[tokio::test] + async fn in_process_driver_defaults_image_updates_to_unimplemented() { + let driver = NoopTestDriver::default(); + let error = openshell_core::compute::ComputeDriver::update_sandbox_image( + &driver, + Request::new(openshell_core::proto::compute::v1::UpdateSandboxImageRequest::default()), + ) + .await + .unwrap_err(); + assert_eq!(error.code(), Code::Unimplemented); + } + #[tokio::test] async fn negotiated_launch_requirement_rejects_create_before_driver_or_store() { let driver = Arc::new(TestDriver { diff --git a/crates/openshell-server/src/lib.rs b/crates/openshell-server/src/lib.rs index 1e30be417f..67ae358538 100644 --- a/crates/openshell-server/src/lib.rs +++ b/crates/openshell-server/src/lib.rs @@ -2360,7 +2360,7 @@ mod tests { .iter() .map(|service| service.name.as_str()) .collect::>(), - ["openshell.v1.OpenShell"] + ["openshell.v1.OpenShell", "openshell.v1.SandboxUpdates"] ); stop_listener(shutdown, handle).await; diff --git a/crates/openshell-server/src/test_support.rs b/crates/openshell-server/src/test_support.rs index 94905e3956..11e7ab08ff 100644 --- a/crates/openshell-server/src/test_support.rs +++ b/crates/openshell-server/src/test_support.rs @@ -15,6 +15,8 @@ use crate::tracing_bus::TracingLogBus; use futures::{Stream, stream}; use openshell_core::Config; #[cfg(unix)] +use openshell_core::proto::compute::v1::compute_driver_image_updates_server::ComputeDriverImageUpdatesServer; +#[cfg(unix)] use openshell_core::proto::compute::v1::compute_driver_server::ComputeDriverServer; use openshell_core::proto::compute::v1::{ CreateSandboxRequest, CreateSandboxResponse, DeleteSandboxRequest, DeleteSandboxResponse, @@ -225,6 +227,20 @@ impl FakeComputeDriver { self } + #[must_use] + pub fn with_sandbox_image_updates(self) -> Self { + self.with_state(|state| { + state + .capabilities + .extension + .as_mut() + .unwrap() + .supported_capabilities + .push(openshell_core::extension_protocol::COMPUTE_UPDATE_SANDBOX_IMAGE.into()); + }); + self + } + #[must_use] pub fn calls(&self) -> Vec { self.with_state(|state| state.calls.clone()) @@ -253,7 +269,8 @@ impl FakeComputeDriver { let driver = self.clone(); let task = tokio::spawn(async move { tonic::transport::Server::builder() - .add_service(ComputeDriverServer::new(driver)) + .add_service(ComputeDriverServer::new(driver.clone())) + .add_service(ComputeDriverImageUpdatesServer::new(driver)) .serve_with_incoming(UnixIncoming { listener }) .await }); @@ -319,7 +336,7 @@ impl Stream for UnixIncoming { } #[tonic::async_trait] -impl ComputeDriver for FakeComputeDriver { +impl openshell_core::compute::ComputeDriver for FakeComputeDriver { async fn update_sandbox_image( &self, request: Request, @@ -343,7 +360,22 @@ impl ComputeDriver for FakeComputeDriver { )) }) } +} + +#[tonic::async_trait] +impl openshell_core::proto::compute::v1::compute_driver_image_updates_server::ComputeDriverImageUpdates + for FakeComputeDriver +{ + async fn update_sandbox_image( + &self, + request: Request, + ) -> Result, Status> { + openshell_core::compute::ComputeDriver::update_sandbox_image(self, request).await + } +} +#[tonic::async_trait] +impl ComputeDriver for FakeComputeDriver { async fn authenticate_sandbox( &self, _request: Request, diff --git a/proto/compute_driver.proto b/proto/compute_driver.proto index 2a9aec0e06..719532f3fd 100644 --- a/proto/compute_driver.proto +++ b/proto/compute_driver.proto @@ -45,13 +45,6 @@ service ComputeDriver { // Provision platform resources for a sandbox. rpc CreateSandbox(CreateSandboxRequest) returns (CreateSandboxResponse); - // Idempotently replace only the workload image of a stopped sandbox, retaining - // its stable resource and storage. Requires the optional capability - // openshell.compute.update-sandbox-image. Unsupported drivers return - // UNIMPLEMENTED without changing any resource. - rpc UpdateSandboxImage(UpdateSandboxImageRequest) - returns (UpdateSandboxImageResponse); - // Idempotently stop platform resources without deleting persistent state. rpc StopSandbox(StopSandboxRequest) returns (StopSandboxResponse); @@ -72,6 +65,19 @@ service ComputeDriver { rpc DeleteWorkspace(DeleteWorkspaceRequest) returns (DeleteWorkspaceResponse); } +// Optional image-update extension, served on the same endpoint as ComputeDriver. +// Keeping this separate preserves the baseline generated server trait for +// independently versioned external drivers. Drivers advertise +// openshell.compute.update-sandbox-image only when they serve this service; +// gateways must negotiate that capability before calling it. +service ComputeDriverImageUpdates { + // Idempotently replace only the workload image of a stopped sandbox, retaining + // its stable resource and storage. Unsupported drivers omit this service and + // return UNIMPLEMENTED without changing any resource. + rpc UpdateSandboxImage(UpdateSandboxImageRequest) + returns (UpdateSandboxImageResponse); +} + message GetCapabilitiesRequest { // Gateway protocol metadata. Drivers must reject unmet requirements. openshell.extension.v1.PeerMetadata gateway = 1; diff --git a/sdk/go/proto/openshellv1/sandbox_updates_test.go b/sdk/go/tests/compatibility/sandbox_updates_test.go similarity index 99% rename from sdk/go/proto/openshellv1/sandbox_updates_test.go rename to sdk/go/tests/compatibility/sandbox_updates_test.go index 1bd00072c9..2181a87b88 100644 --- a/sdk/go/proto/openshellv1/sandbox_updates_test.go +++ b/sdk/go/tests/compatibility/sandbox_updates_test.go @@ -1,7 +1,7 @@ // SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. // SPDX-License-Identifier: Apache-2.0 -package openshellv1_test +package compatibility_test import ( "context" From 73b8b67cfb26ee139b09f309e9e4b1bd1b2fcbf2 Mon Sep 17 00:00:00 2001 From: sjenning <493891+sjenning@users.noreply.github.com> Date: Fri, 16 Oct 2026 13:37:48 -0500 Subject: [PATCH 5/7] fix(gateway): preserve baseline factory and descriptor APIs Restore the original in-process driver trait object and existing instance enum. Register optional image updates through a default factory hook without requiring changes to existing drivers or factories, and require registration plus capability before mutation. Accept OpenShell-only descriptors while retaining strict validation of present update services. Cover baseline registration, missing-updater no-write behavior, descriptor validation, and both live Kubernetes retention lanes. Signed-off-by: sjenning <493891+sjenning@users.noreply.github.com> --- crates/openshell-core/README.md | 10 +- crates/openshell-core/src/compute.rs | 12 +- crates/openshell-driver-kubernetes/README.md | 4 +- .../src/routes.rs | 202 ++++++++++++++++-- crates/openshell-gateway/src/lib.rs | 21 +- crates/openshell-server/README.md | 13 ++ .../src/compute/image_update.rs | 74 ++++++- crates/openshell-server/src/compute/mod.rs | 51 +++-- .../src/compute_factory_compatibility.rs | 172 +++++++++++++++ .../src/grpc/sandbox/image_update_tests.rs | 1 + crates/openshell-server/src/lib.rs | 29 ++- 11 files changed, 523 insertions(+), 66 deletions(-) create mode 100644 crates/openshell-server/src/compute_factory_compatibility.rs diff --git a/crates/openshell-core/README.md b/crates/openshell-core/README.md index 707e3ec77b..0b694f1b1e 100644 --- a/crates/openshell-core/README.md +++ b/crates/openshell-core/README.md @@ -73,10 +73,12 @@ that support image updates additionally serve `ComputeDriverImageUpdates` on the same endpoint and advertise `openshell.compute.update-sandbox-image`. Drivers without that capability need no new generated-trait method. -Linked in-process drivers implement `openshell_core::compute::ComputeDriver` -in addition to the generated baseline trait. An empty implementation inherits -`UNIMPLEMENTED` for image updates; supporting drivers override the optional -method. The gateway negotiates the capability before invoking either path. +Existing linked in-process drivers and factories need no new trait or hook. +Only drivers opting into image updates implement +`openshell_core::compute::ComputeDriver` and register that implementation through +`ComputeDriverFactory::build_with_image_updates`. The default factory hook calls +the existing `build` method without an updater. The gateway requires both this +separate registration and the negotiated capability before invoking updates. ## Protobuf Struct Conversion diff --git a/crates/openshell-core/src/compute.rs b/crates/openshell-core/src/compute.rs index 57722752e3..ba9e6f546a 100644 --- a/crates/openshell-core/src/compute.rs +++ b/crates/openshell-core/src/compute.rs @@ -1,18 +1,18 @@ // SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. // SPDX-License-Identifier: Apache-2.0 -//! In-process compute contract, separate from the baseline generated gRPC trait. +//! Opt-in in-process image updates, separate from the baseline driver contract. use crate::proto::compute::v1::{ UpdateSandboxImageRequest, UpdateSandboxImageResponse, compute_driver_server, }; -/// Gateway-facing in-process compute driver with optional image updates. +/// Optional in-process image updater, registered separately by a driver factory. /// -/// External servers implement the unchanged generated -/// [`compute_driver_server::ComputeDriver`] trait and, when supported, the -/// separate generated `ComputeDriverImageUpdates` service on the same endpoint. -/// In-process drivers use this default unless they advertise image updates. +/// Existing drivers need only the generated baseline trait, not this extension. +/// Supporting factories opt in through `ComputeDriverFactory::build_with_image_updates` +/// and advertise the image-update capability. External servers use the separate +/// generated `ComputeDriverImageUpdates` service on the same endpoint instead. #[tonic::async_trait] pub trait ComputeDriver: compute_driver_server::ComputeDriver { async fn update_sandbox_image( diff --git a/crates/openshell-driver-kubernetes/README.md b/crates/openshell-driver-kubernetes/README.md index 9b94ef9381..644f50590a 100644 --- a/crates/openshell-driver-kubernetes/README.md +++ b/crates/openshell-driver-kubernetes/README.md @@ -162,7 +162,9 @@ a usable stopped condition, so pod deletion alone confirms their stop. The optional `openshell.compute.update-sandbox-image` capability supports image-only updates while the sandbox is stopped. External drivers serve it as the separate `ComputeDriverImageUpdates` service on the baseline `ComputeDriver` -endpoint, preserving the baseline generated server trait. `UpdateSandboxImage` requires +endpoint, preserving the baseline generated server trait. The linked gateway +factory opts in through `ComputeDriverFactory::build_with_image_updates` without +changing the baseline driver object. `UpdateSandboxImage` requires the persisted Kubernetes runtime identity, current image, sandbox name, and a stable operation ID with a monotonic image revision. The driver verifies that the same Sandbox resource is suspended, runtime bootstrap has completed, and diff --git a/crates/openshell-gateway-interceptors/src/routes.rs b/crates/openshell-gateway-interceptors/src/routes.rs index dcb98ec5bc..30e053e323 100644 --- a/crates/openshell-gateway-interceptors/src/routes.rs +++ b/crates/openshell-gateway-interceptors/src/routes.rs @@ -62,17 +62,23 @@ impl OpenShellRouteIndex { } pub(crate) fn from_descriptor_pool(pool: &DescriptorPool) -> Result { + let open_shell = pool + .get_service_by_name(SERVICE_OPEN_SHELL) + .ok_or_else(|| { + InterceptorError::Config(format!( + "descriptor set does not contain service '{SERVICE_OPEN_SHELL}'" + )) + })?; + // SandboxUpdates is an optional extension: baseline descriptor sets + // still need only OpenShell, but a present extension must be valid. + let sandbox_updates = pool.get_service_by_name(SERVICE_SANDBOX_UPDATES); let mut all_methods = BTreeSet::new(); let mut unary_methods = BTreeSet::new(); let mut input_types = BTreeMap::new(); let mut output_types = BTreeMap::new(); - for service_name in [SERVICE_OPEN_SHELL, SERVICE_SANDBOX_UPDATES] { - let service = pool.get_service_by_name(service_name).ok_or_else(|| { - InterceptorError::Config(format!( - "descriptor set does not contain service '{service_name}'" - )) - })?; + for service in std::iter::once(&open_shell).chain(sandbox_updates.as_ref()) { + let service_name = service.full_name(); for method in service.methods() { let route = format!("{service_name}/{}", method.name()); all_methods.insert(route.clone()); @@ -90,7 +96,13 @@ impl OpenShellRouteIndex { input_types, output_types, }; - index.validate_interceptable_list()?; + index.validate_interceptable_list(SERVICE_OPEN_SHELL, INTERCEPTABLE_METHODS)?; + if sandbox_updates.is_some() { + index.validate_interceptable_list( + SERVICE_SANDBOX_UPDATES, + INTERCEPTABLE_SANDBOX_UPDATE_METHODS, + )?; + } Ok(index) } @@ -118,23 +130,15 @@ impl OpenShellRouteIndex { .map(String::as_str) } - fn validate_interceptable_list(&self) -> Result<()> { + fn validate_interceptable_list(&self, service: &str, methods: &[&str]) -> Result<()> { let mut stale = Vec::new(); let mut streaming = Vec::new(); - for (service, methods) in [ - (SERVICE_OPEN_SHELL, INTERCEPTABLE_METHODS), - ( - SERVICE_SANDBOX_UPDATES, - INTERCEPTABLE_SANDBOX_UPDATE_METHODS, - ), - ] { - for method in methods { - let route = format!("{service}/{method}"); - if !self.all_methods.contains(&route) { - stale.push(route); - } else if !self.unary_methods.contains(&route) { - streaming.push(route); - } + for method in methods { + let route = format!("{service}/{method}"); + if !self.all_methods.contains(&route) { + stale.push(route); + } else if !self.unary_methods.contains(&route) { + streaming.push(route); } } if !stale.is_empty() { @@ -153,8 +157,158 @@ impl OpenShellRouteIndex { #[cfg(test)] mod tests { + use prost::Message; + use prost_types::{FileDescriptorSet, ServiceDescriptorProto}; + use super::*; + fn descriptor_set() -> FileDescriptorSet { + FileDescriptorSet::decode(openshell_core::FILE_DESCRIPTOR_SET).unwrap() + } + + fn service_mut<'a>( + descriptors: &'a mut FileDescriptorSet, + name: &str, + ) -> &'a mut ServiceDescriptorProto { + descriptors + .file + .iter_mut() + .filter(|file| file.package.as_deref() == Some("openshell.v1")) + .flat_map(|file| &mut file.service) + .find(|service| service.name.as_deref() == Some(name)) + .unwrap() + } + + #[test] + fn open_shell_only_descriptor_set_is_accepted() { + let mut descriptors = descriptor_set(); + for file in &mut descriptors.file { + file.service.retain(|service| { + file.package.as_deref() == Some("openshell.v1") + && service.name.as_deref() == Some("OpenShell") + }); + } + + let index = OpenShellRouteIndex::from_descriptor_set(&descriptors.encode_to_vec()).unwrap(); + for method in INTERCEPTABLE_METHODS { + assert!(index.is_interceptable(SERVICE_OPEN_SHELL, method)); + assert!(index.input_type(SERVICE_OPEN_SHELL, method).is_some()); + assert!(index.output_type(SERVICE_OPEN_SHELL, method).is_some()); + } + assert!(!index.is_interceptable(SERVICE_SANDBOX_UPDATES, "UpdateSandbox")); + assert!( + index + .input_type(SERVICE_SANDBOX_UPDATES, "UpdateSandbox") + .is_none() + ); + assert!( + index + .output_type(SERVICE_SANDBOX_UPDATES, "UpdateSandbox") + .is_none() + ); + } + + #[test] + fn missing_open_shell_service_is_rejected() { + let mut descriptors = descriptor_set(); + for file in &mut descriptors.file { + file.service + .retain(|service| service.name.as_deref() != Some("OpenShell")); + } + + let error = + OpenShellRouteIndex::from_descriptor_set(&descriptors.encode_to_vec()).unwrap_err(); + assert!(error.to_string().contains(&format!( + "descriptor set does not contain service '{SERVICE_OPEN_SHELL}'" + ))); + } + + #[test] + fn present_sandbox_updates_service_requires_update_sandbox() { + let mut descriptors = descriptor_set(); + service_mut(&mut descriptors, "SandboxUpdates") + .method + .clear(); + + let error = + OpenShellRouteIndex::from_descriptor_set(&descriptors.encode_to_vec()).unwrap_err(); + assert!(error.to_string().contains("stale methods")); + assert!( + error + .to_string() + .contains("openshell.v1.SandboxUpdates/UpdateSandbox") + ); + } + + #[test] + fn streaming_update_sandbox_is_rejected() { + for (client_streaming, server_streaming) in [(true, false), (false, true), (true, true)] { + let mut descriptors = descriptor_set(); + let method = &mut service_mut(&mut descriptors, "SandboxUpdates").method[0]; + assert_eq!(method.name.as_deref(), Some("UpdateSandbox")); + method.client_streaming = Some(client_streaming); + method.server_streaming = Some(server_streaming); + + let error = + OpenShellRouteIndex::from_descriptor_set(&descriptors.encode_to_vec()).unwrap_err(); + assert!(error.to_string().contains("streaming methods")); + assert!( + error + .to_string() + .contains("openshell.v1.SandboxUpdates/UpdateSandbox") + ); + } + } + + #[test] + fn unlisted_sandbox_update_methods_are_not_interceptable() { + let mut descriptors = descriptor_set(); + let service = service_mut(&mut descriptors, "SandboxUpdates"); + let mut future_method = service.method[0].clone(); + future_method.name = Some("FutureUnaryMethod".to_string()); + service.method.push(future_method); + + let index = OpenShellRouteIndex::from_descriptor_set(&descriptors.encode_to_vec()).unwrap(); + assert!(index.is_interceptable(SERVICE_SANDBOX_UPDATES, "UpdateSandbox")); + assert!(!index.is_interceptable(SERVICE_SANDBOX_UPDATES, "FutureUnaryMethod")); + assert_eq!( + index.input_type(SERVICE_SANDBOX_UPDATES, "FutureUnaryMethod"), + Some("openshell.v1.UpdateSandboxRequest") + ); + } + + #[test] + fn open_shell_allowlist_validation_remains_required() { + let mut missing_method = descriptor_set(); + service_mut(&mut missing_method, "OpenShell") + .method + .retain(|method| method.name.as_deref() != Some("CreateSandbox")); + let error = + OpenShellRouteIndex::from_descriptor_set(&missing_method.encode_to_vec()).unwrap_err(); + assert!(error.to_string().contains("stale methods")); + assert!( + error + .to_string() + .contains("openshell.v1.OpenShell/CreateSandbox") + ); + + let mut streaming_method = descriptor_set(); + let method = service_mut(&mut streaming_method, "OpenShell") + .method + .iter_mut() + .find(|method| method.name.as_deref() == Some("CreateSandbox")) + .unwrap(); + method.server_streaming = Some(true); + let error = OpenShellRouteIndex::from_descriptor_set(&streaming_method.encode_to_vec()) + .unwrap_err(); + assert!(error.to_string().contains("streaming methods")); + assert!( + error + .to_string() + .contains("openshell.v1.OpenShell/CreateSandbox") + ); + } + #[test] fn interceptable_entries_match_real_unary_methods() { OpenShellRouteIndex::from_descriptor_set(openshell_core::FILE_DESCRIPTOR_SET).unwrap(); @@ -168,6 +322,10 @@ mod tests { assert!(index.is_interceptable(SERVICE_SANDBOX_UPDATES, "UpdateSandbox")); assert!(!index.is_interceptable(SERVICE_OPEN_SHELL, "UpdateSandbox")); assert!(!index.is_interceptable(SERVICE_SANDBOX_UPDATES, "CreateSandbox")); + assert_eq!( + index.input_type(SERVICE_OPEN_SHELL, "CreateSandbox"), + Some("openshell.v1.CreateSandboxRequest") + ); assert_eq!( index.input_type(SERVICE_SANDBOX_UPDATES, "UpdateSandbox"), Some("openshell.v1.UpdateSandboxRequest") diff --git a/crates/openshell-gateway/src/lib.rs b/crates/openshell-gateway/src/lib.rs index d353cb4f1b..8538206484 100644 --- a/crates/openshell-gateway/src/lib.rs +++ b/crates/openshell-gateway/src/lib.rs @@ -278,6 +278,18 @@ impl openshell_server::ComputeDriverFactory for KubernetesFactory { &self, context: openshell_server::ComputeDriverBuildContext<'_>, ) -> openshell_core::Result { + self.build_with_image_updates(context) + .await + .map(|(instance, _)| instance) + } + + async fn build_with_image_updates( + &self, + context: openshell_server::ComputeDriverBuildContext<'_>, + ) -> openshell_core::Result<( + openshell_server::ComputeDriverInstance, + Option, + )> { let mut config = kubernetes_config(context.config_context())?; config.supervisor_otlp_endpoint = context .otlp_config() @@ -291,9 +303,12 @@ impl openshell_server::ComputeDriverFactory for KubernetesFactory { ) .await .map_err(|error| openshell_core::Error::execution(error.to_string()))?; - let driver = openshell_driver_kubernetes::ComputeDriverService::new_in_process(driver); - Ok(openshell_server::ComputeDriverInstance::InProcess( - std::sync::Arc::new(driver), + let driver = std::sync::Arc::new( + openshell_driver_kubernetes::ComputeDriverService::new_in_process(driver), + ); + Ok(( + openshell_server::ComputeDriverInstance::InProcess(driver.clone()), + Some(driver), )) } } diff --git a/crates/openshell-server/README.md b/crates/openshell-server/README.md index 58f735c35c..b5edb7ebc5 100644 --- a/crates/openshell-server/README.md +++ b/crates/openshell-server/README.md @@ -18,6 +18,19 @@ Retries reuse that generation and session, including after gateway restart. Credential renewal retains both; credentials for an older launch cannot authorize the new one. +## Optional in-process image updates + +`SharedComputeDriver` retains the generated baseline compute-driver trait, and +`ComputeDriverInstance` retains its existing variants. Existing compiled drivers +and factories need no new trait implementation or registration method. + +A supporting factory overrides `ComputeDriverFactory::build_with_image_updates` +to return its ordinary instance plus a separately registered image updater. The +default calls the existing `build` method and returns no updater. The gateway +requires both this opt-in and the negotiated capability before recording image +intent. Remote drivers register the separate `ComputeDriverImageUpdates` service +on their existing endpoint instead. + ## Operator credential export `GetProviderCredentials` exports selected profile-declared runtime environment diff --git a/crates/openshell-server/src/compute/image_update.rs b/crates/openshell-server/src/compute/image_update.rs index 3eb11f65f3..407a795a5a 100644 --- a/crates/openshell-server/src/compute/image_update.rs +++ b/crates/openshell-server/src/compute/image_update.rs @@ -53,6 +53,11 @@ impl ComputeRuntime { "compute driver does not support storage-preserving sandbox image updates", )); } + if self.image_update_driver.is_none() { + return Err(Status::unimplemented( + "compute driver has no registered image updater", + )); + } let lifecycle_guard = self.lifecycle_gates.lock_for(sandbox_id).await; let sandbox_guard = self.lock_sandbox_for_lifecycle(&lifecycle_guard).await; let current = self @@ -112,15 +117,7 @@ impl ComputeRuntime { current } else { let request = image_update_driver_request(¤t, &intent, true); - self.driver - .call_owned( - openshell_otel::rpc::UPDATE_SANDBOX_IMAGE, - Some(sandbox_id), - move |driver| async move { - driver.update_sandbox_image(Request::new(request)).await - }, - ) - .await?; + self.call_image_update_driver(request).await?; // The private intent, desired image, and OLD-understood pending // operation flag commit in one version-fenced transaction. self.store @@ -156,8 +153,7 @@ impl ComputeRuntime { ) -> Result { ensure_image_update_interlock(&pending, &intent)?; let request = image_update_driver_request(&pending, &intent, false); - self.driver.call_owned(openshell_otel::rpc::UPDATE_SANDBOX_IMAGE, Some(pending.object_id()), - move |driver| async move { driver.update_sandbox_image(Request::new(request)).await }).await?; + self.call_image_update_driver(request).await?; let _guard = self.lock_sandbox_local(pending.object_id()).await; // An ambiguous error NEVER clears either the private intent or the // public operation interlock. Only exact successful reconciliation can. @@ -175,6 +171,28 @@ impl ComputeRuntime { Ok(updated) } + async fn call_image_update_driver( + &self, + request: UpdateSandboxImageRequest, + ) -> Result< + tonic::Response, + Status, + > { + let driver = self.image_update_driver.clone().ok_or_else(|| { + Status::unimplemented("compute driver has no registered image updater") + })?; + let sandbox_id = request.sandbox_id.clone(); + self.driver + .call_owned( + openshell_otel::rpc::UPDATE_SANDBOX_IMAGE, + Some(&sandbox_id), + move |_baseline| async move { + driver.update_sandbox_image(Request::new(request)).await + }, + ) + .await + } + pub(super) async fn ensure_no_pending_image_update( &self, sandbox: &Sandbox, @@ -279,6 +297,7 @@ mod tests { .unwrap(); runtime.image_updates_enabled = true; if supported { + runtime.image_update_driver = Some(driver.clone()); runtime .driver_info .negotiated_extension @@ -414,6 +433,39 @@ mod tests { assert_eq!(image_calls(&driver)[1].revision, 2); } + #[tokio::test] + async fn image_update_rejects_unregistered_updater_without_writes() { + let (mut runtime, driver, original) = fixture(true).await; + runtime.image_update_driver = None; + driver.clear_calls(); + let error = runtime + .update_sandbox_image( + original.object_id(), + "example/workload:new".into(), + original.get_resource_version(), + ) + .await + .unwrap_err(); + assert_eq!(error.code(), Code::Unimplemented); + assert!(driver.calls().is_empty()); + assert_eq!( + runtime + .store + .get_message::(original.object_id()) + .await + .unwrap(), + Some(original.clone()) + ); + assert!( + runtime + .store + .get_sandbox_image_state(original.object_id()) + .await + .unwrap() + .is_none() + ); + } + #[tokio::test] async fn image_update_rejects_unsupported_driver_and_stale_version_without_writes() { let (runtime, driver, original) = fixture(false).await; diff --git a/crates/openshell-server/src/compute/mod.rs b/crates/openshell-server/src/compute/mod.rs index b61134d638..051f6aeb7e 100644 --- a/crates/openshell-server/src/compute/mod.rs +++ b/crates/openshell-server/src/compute/mod.rs @@ -79,7 +79,11 @@ use tracing::{Instrument as _, debug, info, warn}; pub type DriverWatchStream = Pin> + Send>>; -pub type SharedComputeDriver = Arc< +pub type SharedComputeDriver = + Arc + Send + Sync>; + +/// Optional image-update registration, independent of the baseline driver object. +pub type SharedComputeDriverImageUpdates = Arc< dyn openshell_core::compute::ComputeDriver + Send + Sync, @@ -770,6 +774,7 @@ pub struct ComputeRuntime { admission: openshell_core::resource_admission::DriverAdmissionConfig, admission_acknowledgement: String, driver: TracedDriver, + image_update_driver: Option, driver_info: ComputeDriverInfoSnapshot, telemetry_compute_driver: TelemetryComputeDriver, driver_process: Option>, @@ -867,6 +872,7 @@ impl ComputeRuntime { Ok(Self { isolation_backend: None, driver: TracedDriver::new(driver, driver_name), + image_update_driver: None, admission: openshell_core::resource_admission::DriverAdmissionConfig::default(), admission_acknowledgement: capabilities.resource_admission_policy, driver_info, @@ -979,10 +985,10 @@ impl ComputeRuntime { tracing_log_bus: TracingLogBus, supervisor_sessions: Arc, ) -> Result { - let driver: SharedComputeDriver = Arc::new(RemoteComputeDriver::new(endpoint.channel)); + let driver = Arc::new(RemoteComputeDriver::new(endpoint.channel)); Self::from_driver( endpoint.name, - driver, + driver.clone(), endpoint.driver_process, store, sandbox_index, @@ -991,6 +997,15 @@ impl ComputeRuntime { supervisor_sessions, ) .await + .map(|runtime| runtime.with_image_update_driver(Some(driver))) + } + + pub(crate) fn with_image_update_driver( + mut self, + driver: Option, + ) -> Self { + self.image_update_driver = driver; + self } #[must_use] @@ -7521,10 +7536,6 @@ impl Default for NoopTestDriver { } } -#[cfg(any(test, feature = "test-support"))] -#[tonic::async_trait] -impl openshell_core::compute::ComputeDriver for NoopTestDriver {} - #[cfg(any(test, feature = "test-support"))] #[tonic::async_trait] impl ComputeDriver for NoopTestDriver { @@ -7738,6 +7749,7 @@ pub fn new_test_runtime_with_driver( ComputeRuntime { isolation_backend: None, driver: TracedDriver::new(driver, "test".to_string()), + image_update_driver: None, admission: openshell_core::resource_admission::DriverAdmissionConfig { allow_driver_config: true, ..Default::default() @@ -8151,9 +8163,6 @@ mod tests { created_sandboxes: TestMutex>, } - #[tonic::async_trait] - impl openshell_core::compute::ComputeDriver for TestDriver {} - #[tonic::async_trait] impl ComputeDriver for TestDriver { async fn authenticate_sandbox( @@ -8864,6 +8873,7 @@ mod tests { ComputeRuntime { isolation_backend: None, driver: TracedDriver::new(driver, "test-driver".to_string()), + image_update_driver: None, admission: openshell_core::resource_admission::DriverAdmissionConfig { allow_driver_config: true, ..Default::default() @@ -17461,14 +17471,21 @@ endpoint = { kind = "unix", socket_path = "/run/agent-substrate/isolation.sock" #[tokio::test] async fn in_process_driver_defaults_image_updates_to_unimplemented() { - let driver = NoopTestDriver::default(); - let error = openshell_core::compute::ComputeDriver::update_sandbox_image( - &driver, - Request::new(openshell_core::proto::compute::v1::UpdateSandboxImageRequest::default()), - ) - .await - .unwrap_err(); + // NoopTestDriver implements only the baseline generated trait. + let mut runtime = test_runtime(Arc::new(NoopTestDriver::default())) + .await + .with_sandbox_image_updates(true); + runtime + .driver_info + .negotiated_extension + .supported_capabilities + .push(openshell_core::extension_protocol::COMPUTE_UPDATE_SANDBOX_IMAGE.into()); + let error = runtime + .update_sandbox_image("not-created", "example/workload:v2".into(), 1) + .await + .unwrap_err(); assert_eq!(error.code(), Code::Unimplemented); + assert!(runtime.image_update_driver.is_none()); } #[tokio::test] diff --git a/crates/openshell-server/src/compute_factory_compatibility.rs b/crates/openshell-server/src/compute_factory_compatibility.rs new file mode 100644 index 0000000000..c009597076 --- /dev/null +++ b/crates/openshell-server/src/compute_factory_compatibility.rs @@ -0,0 +1,172 @@ +// SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +// SPDX-License-Identifier: Apache-2.0 + +//! Baseline factory source fixture: no image-update trait or new hook required. + +use std::collections::BTreeMap; +use std::sync::Arc; +use std::sync::atomic::{AtomicUsize, Ordering}; + +use openshell_core::proto::compute::v1::compute_driver_server::ComputeDriver; + +use crate::test_support::FakeComputeDriver; +use crate::{ + ComputeDriverBuildContext, ComputeDriverFactory, ComputeDriverInstance, + ComputeDriverRegistration, ComputeDriverRegistry, DriverWatchStream, SharedComputeDriver, + SharedComputeDriverImageUpdates, +}; + +// Written using only the baseline generated trait, not the new optional trait. +type BaselineDriver = + Arc + Send + Sync>; + +struct BaselineFactory { + driver: BaselineDriver, + calls: Arc, +} + +#[async_trait::async_trait] +impl ComputeDriverFactory for BaselineFactory { + async fn build( + &self, + _context: ComputeDriverBuildContext<'_>, + ) -> openshell_core::Result { + self.calls.fetch_add(1, Ordering::SeqCst); + // This unchanged baseline expression must compile without a new trait. + Ok(ComputeDriverInstance::InProcess(self.driver.clone())) + } +} + +struct OptInFactory { + driver: Arc, + legacy_build_calls: Arc, + opt_in_calls: Arc, +} + +#[async_trait::async_trait] +impl ComputeDriverFactory for OptInFactory { + async fn build( + &self, + _context: ComputeDriverBuildContext<'_>, + ) -> openshell_core::Result { + self.legacy_build_calls.fetch_add(1, Ordering::SeqCst); + Ok(ComputeDriverInstance::InProcess(self.driver.clone())) + } + + async fn build_with_image_updates( + &self, + _context: ComputeDriverBuildContext<'_>, + ) -> openshell_core::Result<( + ComputeDriverInstance, + Option, + )> { + self.opt_in_calls.fetch_add(1, Ordering::SeqCst); + Ok(( + ComputeDriverInstance::InProcess(self.driver.clone()), + Some(self.driver.clone()), + )) + } +} + +async fn registered_runtime(factory: impl ComputeDriverFactory + 'static) -> crate::ComputeRuntime { + let mut registry = ComputeDriverRegistry::new(); + registry + .install(ComputeDriverRegistration::new("fixture", 0, None, factory).unwrap()) + .unwrap(); + let selection = registry.select(Some("fixture")).unwrap(); + let config = openshell_core::Config::new(None); + let overrides = BTreeMap::new(); + let startup = crate::compute::driver_config::DriverStartupContext { + file: None, + guest_tls: None, + gateway_port: 8080, + gateway_tls_enabled: false, + endpoint_overrides: &overrides, + }; + let store = Arc::new(crate::persistence::test_store().await); + crate::build_compute_runtime( + ®istry, + &selection, + &config, + startup, + store, + crate::sandbox_index::SandboxIndex::new(), + crate::sandbox_watch::SandboxWatchBus::new(), + crate::tracing_bus::TracingLogBus::new(), + Arc::new(crate::supervisor_session::SupervisorSessionRegistry::new()), + tokio::sync::watch::channel(false).1, + ) + .await + .unwrap() + .with_sandbox_image_updates(true) +} + +#[tokio::test] +async fn baseline_factory_and_trait_object_still_build_without_opt_in() { + // This concrete fixture implements only the baseline generated trait. + let driver: BaselineDriver = Arc::new(crate::compute::NoopTestDriver::default()); + let shared: SharedComputeDriver = driver.clone(); + // Exhaustive baseline enum match also prevents adding a required new variant. + match ComputeDriverInstance::InProcess(shared) { + ComputeDriverInstance::InProcess(actual) => assert!(Arc::ptr_eq(&actual, &driver)), + ComputeDriverInstance::ManagedRemote(_) => panic!("expected in-process driver"), + } + let calls = Arc::new(AtomicUsize::new(0)); + let runtime = registered_runtime(BaselineFactory { + driver, + calls: calls.clone(), + }) + .await; + assert_eq!(calls.load(Ordering::SeqCst), 1); + assert_eq!( + runtime + .update_sandbox_image("not-created", "example/workload:v2".into(), 1) + .await + .unwrap_err() + .code(), + tonic::Code::Unimplemented + ); +} + +#[tokio::test] +async fn capability_alone_does_not_register_an_in_process_image_updater() { + let driver = Arc::new(FakeComputeDriver::new().with_sandbox_image_updates()); + let runtime = registered_runtime(BaselineFactory { + driver: driver.clone(), + calls: Arc::new(AtomicUsize::new(0)), + }) + .await; + driver.clear_calls(); + assert_eq!( + runtime + .update_sandbox_image("not-created", "example/workload:v2".into(), 1) + .await + .unwrap_err() + .code(), + tonic::Code::Unimplemented + ); + assert!(driver.calls().is_empty()); +} + +#[tokio::test] +async fn registered_opt_in_hook_supplies_the_optional_updater() { + let legacy_calls = Arc::new(AtomicUsize::new(0)); + let opt_in_calls = Arc::new(AtomicUsize::new(0)); + let runtime = registered_runtime(OptInFactory { + driver: Arc::new(FakeComputeDriver::new().with_sandbox_image_updates()), + legacy_build_calls: legacy_calls.clone(), + opt_in_calls: opt_in_calls.clone(), + }) + .await; + assert_eq!(legacy_calls.load(Ordering::SeqCst), 0); + assert_eq!(opt_in_calls.load(Ordering::SeqCst), 1); + // Passing capability/registration admission reaches the sandbox lookup. + assert_eq!( + runtime + .update_sandbox_image("not-created", "example/workload:v2".into(), 1) + .await + .unwrap_err() + .code(), + tonic::Code::NotFound + ); +} diff --git a/crates/openshell-server/src/grpc/sandbox/image_update_tests.rs b/crates/openshell-server/src/grpc/sandbox/image_update_tests.rs index a4dc0a7dcf..faf42a9139 100644 --- a/crates/openshell-server/src/grpc/sandbox/image_update_tests.rs +++ b/crates/openshell-server/src/grpc/sandbox/image_update_tests.rs @@ -145,6 +145,7 @@ async fn state() -> (Arc, Arc, Sandbox) { ) .await .unwrap() + .with_image_update_driver(Some(driver.clone())) .with_sandbox_image_updates(true); Arc::get_mut(&mut state).unwrap().compute = compute; let mut sandbox = Sandbox { diff --git a/crates/openshell-server/src/lib.rs b/crates/openshell-server/src/lib.rs index 67ae358538..850d1d3ea8 100644 --- a/crates/openshell-server/src/lib.rs +++ b/crates/openshell-server/src/lib.rs @@ -1253,6 +1253,7 @@ async fn terminate_signal() { pub use compute::{ AcquiredRemoteDriverEndpoint, DriverWatchStream, ManagedDriverProcess, SharedComputeDriver, + SharedComputeDriverImageUpdates, }; /// Driver instance returned by a compiled compute-driver factory. @@ -1312,6 +1313,23 @@ pub trait ComputeDriverFactory: Send + Sync { } async fn build(&self, context: ComputeDriverBuildContext<'_>) -> Result; + + /// Build with a separately registered, optional in-process image updater. + /// + /// Existing factories only implement `build`; their baseline driver object + /// remains sufficient and this hook defaults to no image-update support. + /// Supporting factories return the same driver instance in both slots and + /// advertise the negotiated image-update capability. Remote drivers expose + /// their extension over the existing endpoint instead of using this hook. + async fn build_with_image_updates( + &self, + context: ComputeDriverBuildContext<'_>, + ) -> Result<( + ComputeDriverInstance, + Option, + )> { + self.build(context).await.map(|instance| (instance, None)) + } } /// One named compiled-driver registration. @@ -1718,7 +1736,10 @@ async fn build_compute_runtime( }, shutdown_rx, }; - let instance = registration.factory.build(build_context).await?; + let (instance, image_updates) = registration + .factory + .build_with_image_updates(build_context) + .await?; match instance { ComputeDriverInstance::InProcess(driver) => ComputeRuntime::from_driver( registration.name, @@ -1733,7 +1754,8 @@ async fn build_compute_runtime( .await .map_err(|error| { Error::execution(format!("failed to create compute runtime: {error}")) - })?, + })? + .with_image_update_driver(image_updates), ComputeDriverInstance::ManagedRemote(mut endpoint) => { endpoint.name = registration.name; ComputeRuntime::new_remote_driver( @@ -1940,6 +1962,9 @@ pub(crate) async fn ensure_default_workspace(store: &Store) -> Result<()> { } } +#[cfg(test)] +mod compute_factory_compatibility; + #[cfg(test)] mod tests { use super::{ From b284d04e9168dd574d5620b2d96bfa36ad3d401b Mon Sep 17 00:00:00 2001 From: sjenning <493891+sjenning@users.noreply.github.com> Date: Fri, 16 Oct 2026 13:50:30 -0500 Subject: [PATCH 6/7] chore(ci): use upstream Kubernetes E2E defaults Drop the task-level fallback superseded by main's runner defaults and explicit e2e-conformance-only selector. Preserve current upstream task definitions and recovery waiver unchanged. Signed-off-by: sjenning <493891+sjenning@users.noreply.github.com> --- tasks/test.toml | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/tasks/test.toml b/tasks/test.toml index 126fde4f5c..6518bfdbe4 100644 --- a/tasks/test.toml +++ b/tasks/test.toml @@ -220,10 +220,7 @@ run = "e2e/rust/e2e-podman.sh" ["e2e:kubernetes"] description = "Run Rust CLI e2e tests against an OpenShell gateway deployed on Kubernetes via Helm (set OPENSHELL_E2E_KUBE_CONTEXT to reuse a cluster; otherwise creates a local k3d cluster when k3d is installed; set OPENSHELL_E2E_KUBE_TEST= to scope to one test)" -# The reusable CI workflow exports an empty feature input by default. Restore -# the normal Rust suite here, not in the runner: the external-driver task -# intentionally passes an empty feature set for conformance-only coverage. -run = 'OPENSHELL_E2E_KUBERNETES_FEATURES="${OPENSHELL_E2E_KUBERNETES_FEATURES:-e2e,e2e-host-gateway,e2e-kubernetes}" e2e/rust/e2e-kubernetes.sh' +run = "e2e/rust/e2e-kubernetes.sh" ["e2e:kubernetes:v1alpha1"] description = "Run Kubernetes e2e against Agent Sandbox v1alpha1" From 73b69ac6bf691bb4a3132b74bd52521b4e41f0f4 Mon Sep 17 00:00:00 2001 From: sjenning <493891+sjenning@users.noreply.github.com> Date: Fri, 16 Oct 2026 15:10:32 -0500 Subject: [PATCH 7/7] fix(gateway): integrate image updates with backend protocol Adapt non-launch image updates to the upstream remote admission API while retaining resource-policy verification before forwarding. Cover both negotiated extensions and preservation of backend pins and persisted launch identity. Signed-off-by: sjenning <493891+sjenning@users.noreply.github.com> --- .../openshell-core/src/extension_protocol.rs | 17 +++++++++++ .../src/compute/image_update.rs | 28 +++++++++++++++---- crates/openshell-server/src/compute/mod.rs | 22 +++++++++++++-- 3 files changed, 60 insertions(+), 7 deletions(-) diff --git a/crates/openshell-core/src/extension_protocol.rs b/crates/openshell-core/src/extension_protocol.rs index fea8126b45..e6af168efa 100644 --- a/crates/openshell-core/src/extension_protocol.rs +++ b/crates/openshell-core/src/extension_protocol.rs @@ -400,6 +400,23 @@ fn valid_capability(value: &str) -> bool { mod tests { use super::*; + #[test] + fn compute_gateway_advertises_both_optional_extensions() { + let gateway = gateway_metadata(ExtensionFamily::Compute); + assert!( + gateway + .supported_capabilities + .iter() + .any(|c| c == COMPUTE_ISOLATION_BACKEND) + ); + assert!( + gateway + .supported_capabilities + .iter() + .any(|c| c == COMPUTE_UPDATE_SANDBOX_IMAGE) + ); + } + fn compatible() -> (PeerMetadata, PeerMetadata) { let gateway = gateway_metadata(ExtensionFamily::Compute); let extension = extension_metadata( diff --git a/crates/openshell-server/src/compute/image_update.rs b/crates/openshell-server/src/compute/image_update.rs index 407a795a5a..76c14f3375 100644 --- a/crates/openshell-server/src/compute/image_update.rs +++ b/crates/openshell-server/src/compute/image_update.rs @@ -310,10 +310,16 @@ mod tests { name: "image-sandbox".into(), workspace: "default".into(), labels: HashMap::from([("app".into(), "retained".into())]), - annotations: HashMap::from([( - COMPUTE_RUNTIME_IDENTITY_ANNOTATION.into(), - "stable-runtime".into(), - )]), + annotations: HashMap::from([ + ( + COMPUTE_RUNTIME_IDENTITY_ANNOTATION.into(), + "stable-runtime".into(), + ), + ( + crate::compute::ISOLATION_BACKEND_ANNOTATION.into(), + openshell_core::isolation_registration::BUILTIN_BACKEND_NAME.into(), + ), + ]), ..Default::default() }), spec: Some(SandboxSpec { @@ -353,7 +359,19 @@ mod tests { #[tokio::test] async fn image_update_preserves_identity_and_every_other_spec_field() { - let (runtime, driver, original) = fixture(true).await; + let (runtime, driver, mut original) = fixture(true).await; + // Image edits must preserve the upstream backend pin and launch identity, + // including generation/session and authorization epoch annotations. + crate::auth::sandbox_session::PersistedSandboxIdentity::new() + .unwrap() + .write(&mut original.metadata.as_mut().unwrap().annotations); + runtime.store.put_message(&original).await.unwrap(); + let original = runtime + .store + .get_message::(original.object_id()) + .await + .unwrap() + .unwrap(); let updated = runtime .update_sandbox_image( original.object_id(), diff --git a/crates/openshell-server/src/compute/mod.rs b/crates/openshell-server/src/compute/mod.rs index 051f6aeb7e..1157036281 100644 --- a/crates/openshell-server/src/compute/mod.rs +++ b/crates/openshell-server/src/compute/mod.rs @@ -619,7 +619,8 @@ impl openshell_core::compute::ComputeDriver for RemoteComputeDriver { tonic::Response, Status, > { - self.verify_admission_policy().await?; + // An image-only update does not install an external isolation route. + self.verify_admission_policy(false).await?; self.image_updates_client .clone() .update_sandbox_image(request) @@ -17351,9 +17352,16 @@ endpoint = { kind = "unix", socket_path = "/run/agent-substrate/isolation.sock" .await .is_err() ); + let status = openshell_core::compute::ComputeDriver::update_sandbox_image( + &remote, + Request::new(openshell_core::proto::compute::v1::UpdateSandboxImageRequest::default()), + ) + .await + .unwrap_err(); + assert_eq!(status.code(), Code::FailedPrecondition); assert_eq!( driver.calls(), - vec![FakeComputeDriverCall::GetCapabilities; 3] + vec![FakeComputeDriverCall::GetCapabilities; 4] ); } @@ -17390,6 +17398,16 @@ endpoint = { kind = "unix", socket_path = "/run/agent-substrate/isolation.sock" .await .unwrap(); runtime.image_updates_enabled = true; + assert!( + !runtime + .driver_info + .negotiated_extension + .supported_capabilities + .iter() + .any(|capability| capability + == openshell_core::extension_protocol::COMPUTE_ISOLATION_BACKEND), + "image-only updates do not require external isolation registration" + ); assert_eq!( runtime .driver_info