From 3144ecc655183b80f7f50cb93d3b4e1b1f9add68 Mon Sep 17 00:00:00 2001 From: Seth Jennings Date: Tue, 15 Sep 2026 14:14:05 -0500 Subject: [PATCH 1/5] feat(extensions)!: normalize protocol negotiation Closes #3057 Introduce a shared extension handshake, enforce protocol and capability compatibility across extension families, and expose immutable negotiated snapshots through gateway info and the Go SDK. Signed-off-by: Seth Jennings --- architecture/compute-runtimes.md | 8 +- architecture/gateway.md | 8 + crates/openshell-cli/src/commands/gateway.rs | 96 +- .../openshell-core/src/extension_protocol.rs | 452 +++ crates/openshell-core/src/lib.rs | 1 + crates/openshell-core/src/middleware.rs | 17 +- crates/openshell-core/src/proto/mod.rs | 4 + crates/openshell-driver-docker/src/lib.rs | 12 +- crates/openshell-driver-docker/src/tests.rs | 5 +- .../src/lib.rs | 6 + .../openshell-driver-kubernetes/src/driver.rs | 6 + .../openshell-driver-kubernetes/src/grpc.rs | 9 +- crates/openshell-driver-mxc/src/driver.rs | 6 + crates/openshell-driver-podman/src/driver.rs | 6 + crates/openshell-driver-podman/src/grpc.rs | 4 +- crates/openshell-driver-vault/src/lib.rs | 6 + crates/openshell-driver-vm/src/driver.rs | 10 +- .../src/plan.rs | 54 +- .../src/runtime.rs | 6 + crates/openshell-gateway/src/vm.rs | 2 +- crates/openshell-sdk/tests/client_mock.rs | 1 + crates/openshell-server/src/compute/mod.rs | 90 +- crates/openshell-server/src/credentials.rs | 99 +- crates/openshell-server/src/grpc/mod.rs | 110 +- crates/openshell-server/src/multiplex.rs | 6 + .../src/provider_profile_sources.rs | 6 + crates/openshell-server/src/storage_proto.rs | 4 +- crates/openshell-server/src/test_support.rs | 6 + .../src/lib.rs | 6 + .../src/lib.rs | 200 +- .../src/remote.rs | 14 +- .../src/l7/relay.rs | 26 +- .../src/l7/websocket.rs | 8 +- .../openshell-supervisor-network/src/proxy.rs | 14 +- docs/extensibility/extension-negotiation.mdx | 69 + docs/extensibility/gateway-interceptors.mdx | 2 + docs/extensibility/supervisor-middleware.mdx | 2 + docs/reference/gateway-config.mdx | 4 + docs/reference/sandbox-compute-drivers.mdx | 2 + examples/governance-interceptor/src/main.rs | 6 + .../src/main.rs | 21 +- proto/compute_driver.proto | 10 +- proto/credential_driver.proto | 10 +- proto/extension.proto | 34 + proto/gateway_interceptor.proto | 8 +- proto/openshell.proto | 28 + proto/supervisor_middleware.proto | 16 +- sdk/go/openshell/v1/fake/health.go | 8 + sdk/go/openshell/v1/fake/health_test.go | 8 + sdk/go/openshell/v1/health.go | 6 + .../openshell/v1/internal/converter/health.go | 35 + .../v1/internal/converter/health_test.go | 23 + sdk/go/openshell/v1/types/health.go | 25 + sdk/go/proto/openshellv1/openshell.pb.go | 3044 +++++++++-------- skills/debug-openshell-cluster/SKILL.md | 5 +- .../references/supervisor-middleware.md | 3 +- skills/openshell-cli/SKILL.md | 2 + 57 files changed, 3134 insertions(+), 1545 deletions(-) create mode 100644 crates/openshell-core/src/extension_protocol.rs create mode 100644 docs/extensibility/extension-negotiation.mdx create mode 100644 proto/extension.proto diff --git a/architecture/compute-runtimes.md b/architecture/compute-runtimes.md index a2bb25c312..1dab57f92d 100644 --- a/architecture/compute-runtimes.md +++ b/architecture/compute-runtimes.md @@ -118,9 +118,11 @@ The capability RPC reports driver identity, version, and the default sandbox image used by the gateway. GPU availability stays driver-local and is validated when a sandbox create request asks for GPU resources. -The gateway records driver identity and version from the startup capability -response. Elevated gateway info reports that initialized driver snapshot instead -of re-querying drivers on each request. +The gateway sends its common extension peer metadata with the startup capability +request and rejects a driver whose protocol major or capability requirements are +incompatible. It records the negotiated protocol, implementation identity and +version, capability sets, and typed resource support once. Elevated gateway info +reports that immutable snapshot instead of re-querying drivers on each request. ## Compiled Driver Selection diff --git a/architecture/gateway.md b/architecture/gateway.md index f991e591bc..ef6dd1ec04 100644 --- a/architecture/gateway.md +++ b/architecture/gateway.md @@ -734,6 +734,14 @@ resolution and again by the sandbox placeholder resolver. This keeps expired credentials from resolving even when a running sandbox still has retained placeholder generations from an earlier provider credential snapshot. +All gateway-owned extension registries negotiate the same peer metadata envelope +before accepting work. Compute drivers, credential drivers, gateway interceptors, +and supervisor middleware retain their typed family manifests, while the shared +validator enforces protocol-major compatibility and mutual required-capability +sets. The gateway aggregates immutable, non-secret startup snapshots for the +protected gateway-info API; it does not publish transport, authentication, or +backend configuration. + Static credential delivery is capability-negotiated and endpoint-bound. The gateway classifies each returned environment entry as either a credential or non-secret provider configuration and associates every credential key with the diff --git a/crates/openshell-cli/src/commands/gateway.rs b/crates/openshell-cli/src/commands/gateway.rs index 0e1fe92426..07bd31cb47 100644 --- a/crates/openshell-cli/src/commands/gateway.rs +++ b/crates/openshell-cli/src/commands/gateway.rs @@ -20,7 +20,7 @@ use openshell_bootstrap::{ save_active_gateway, store_gateway_metadata, }; use openshell_bootstrap::{GatewayMetadataSource, ListedGateway}; -use openshell_core::proto::{GetGatewayInfoRequest, HealthRequest, ServiceStatus}; +use openshell_core::proto::{ExtensionKind, GetGatewayInfoRequest, HealthRequest, ServiceStatus}; use std::io::IsTerminal; use std::path::PathBuf; use tonic::{Code, Status}; @@ -33,6 +33,7 @@ struct GatewayInfoView { status: String, version: String, compute_drivers: Vec, + extensions: Vec, } #[derive(Debug, Clone)] @@ -47,6 +48,17 @@ struct ComputeDriverCapabilitiesView { driver_version: String, } +#[derive(Debug, Clone)] +struct ExtensionInfoView { + kind: String, + configured_name: String, + implementation_name: String, + implementation_version: String, + protocol_version: String, + supported_capabilities: Vec, + required_capabilities: Vec, +} + /// Show gateway status. #[allow(clippy::branches_sharing_code)] pub async fn gateway_status( @@ -376,6 +388,19 @@ pub async fn gateway_info( })? .into_inner(); + let extensions = info + .extensions + .into_iter() + .map(|extension| ExtensionInfoView { + kind: extension_kind_name(extension.kind).to_string(), + configured_name: extension.configured_name, + implementation_name: extension.implementation_name, + implementation_version: extension.implementation_version, + protocol_version: format!("{}.{}", extension.protocol_major, extension.protocol_minor), + supported_capabilities: extension.supported_capabilities, + required_capabilities: extension.required_capabilities, + }) + .collect(); let view = GatewayInfoView { gateway: gateway_name.to_string(), server: server.to_string(), @@ -396,6 +421,7 @@ pub async fn gateway_info( } }) .collect(), + extensions, }; print_gateway_info(&view, output) @@ -422,10 +448,52 @@ fn print_gateway_info(view: &GatewayInfoView, output: &str) -> Result<()> { println!(" {} {}", "Status:".dimmed(), view.status); println!(" {} {}", "Version:".dimmed(), view.version); print_compute_driver_info(&view.compute_drivers); + print_extension_info(&view.extensions); Ok(()) } +fn extension_kind_name(kind: i32) -> &'static str { + match ExtensionKind::try_from(kind).unwrap_or(ExtensionKind::Unspecified) { + ExtensionKind::ComputeDriver => "compute-driver", + ExtensionKind::CredentialDriver => "credential-driver", + ExtensionKind::GatewayInterceptor => "gateway-interceptor", + ExtensionKind::SupervisorMiddleware => "supervisor-middleware", + ExtensionKind::Unspecified => "unspecified", + } +} + +fn print_extension_info(extensions: &[ExtensionInfoView]) { + if extensions.is_empty() { + return; + } + println!(" {}", "Extensions:".dimmed()); + for extension in extensions { + println!(" {} ({})", extension.configured_name, extension.kind); + println!( + " {} {} {} (protocol {})", + "Implementation:".dimmed(), + extension.implementation_name, + extension.implementation_version, + extension.protocol_version + ); + if !extension.supported_capabilities.is_empty() { + println!( + " {} {}", + "Capabilities:".dimmed(), + extension.supported_capabilities.join(", ") + ); + } + if !extension.required_capabilities.is_empty() { + println!( + " {} {}", + "Requires gateway:".dimmed(), + extension.required_capabilities.join(", ") + ); + } + } +} + fn print_compute_driver_info(drivers: &[ComputeDriverInfoView]) { if drivers.is_empty() { return; @@ -467,6 +535,15 @@ fn gateway_info_to_json(view: &GatewayInfoView) -> serde_json::Value { }, })) .collect::>(), + "extensions": view.extensions.iter().map(|extension| serde_json::json!({ + "kind": &extension.kind, + "configured_name": &extension.configured_name, + "implementation_name": &extension.implementation_name, + "implementation_version": &extension.implementation_version, + "protocol_version": &extension.protocol_version, + "supported_capabilities": &extension.supported_capabilities, + "required_capabilities": &extension.required_capabilities, + })).collect::>(), }) } @@ -1507,9 +1584,9 @@ pub fn gateway_remove(name: &str) -> Result<()> { #[cfg(test)] mod tests { use super::{ - ComputeDriverCapabilitiesView, ComputeDriverInfoView, GatewayAuthenticationState, - GatewayInfoView, TlsOptions, format_gateway_select_header, format_gateway_select_items, - gateway_add, gateway_auth_label, gateway_authentication_state, + ComputeDriverCapabilitiesView, ComputeDriverInfoView, ExtensionInfoView, + GatewayAuthenticationState, GatewayInfoView, TlsOptions, format_gateway_select_header, + format_gateway_select_items, gateway_add, gateway_auth_label, gateway_authentication_state, gateway_env_override_warning, gateway_info_to_json, gateway_remote_label, gateway_select_with, gateway_to_json, gateway_type_label, http_health_check, import_local_package_mtls_bundle, mtls_certs_exist_for_gateway, package_managed_tls_dirs, @@ -1824,6 +1901,15 @@ mod tests { driver_version: "0.0.75".to_string(), }, }], + extensions: vec![ExtensionInfoView { + kind: "compute-driver".to_string(), + configured_name: "podman".to_string(), + implementation_name: "openshell/podman".to_string(), + implementation_version: "0.0.75".to_string(), + protocol_version: "1.0".to_string(), + supported_capabilities: vec!["openshell.compute.contract".to_string()], + required_capabilities: vec!["openshell.compute.contract".to_string()], + }], }; let json = gateway_info_to_json(&view); @@ -1836,6 +1922,7 @@ mod tests { json["compute_drivers"][0]["capabilities"]["driver_name"], "podman" ); + assert_eq!(json["extensions"][0]["protocol_version"], "1.0"); assert_eq!( json["compute_drivers"][0]["capabilities"]["driver_version"], "0.0.75" @@ -1851,6 +1938,7 @@ mod tests { status: "healthy".to_string(), version: "0.0.74".to_string(), compute_drivers: Vec::new(), + extensions: Vec::new(), }; let json = gateway_info_to_json(&view); diff --git a/crates/openshell-core/src/extension_protocol.rs b/crates/openshell-core/src/extension_protocol.rs new file mode 100644 index 0000000000..2886b223dc --- /dev/null +++ b/crates/openshell-core/src/extension_protocol.rs @@ -0,0 +1,452 @@ +// SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +// SPDX-License-Identifier: Apache-2.0 + +//! Shared version and capability negotiation for `OpenShell` extensions. + +use std::collections::BTreeSet; + +use thiserror::Error; + +use crate::proto::extension::v1::{PeerMetadata, ProtocolVersion}; + +pub const PROTOCOL_MAJOR: u32 = 1; +pub const PROTOCOL_MINOR: u32 = 0; + +const MAX_IMPLEMENTATION_NAME_BYTES: usize = 128; +const MAX_IMPLEMENTATION_VERSION_BYTES: usize = 128; +const MAX_CAPABILITY_BYTES: usize = 128; +const MAX_CAPABILITIES: usize = 128; + +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)] +pub enum ExtensionFamily { + Compute, + Credentials, + GatewayInterceptor, + SupervisorMiddleware, +} + +impl ExtensionFamily { + #[must_use] + pub const fn as_str(self) -> &'static str { + match self { + Self::Compute => "compute", + Self::Credentials => "credentials", + Self::GatewayInterceptor => "gateway-interceptor", + Self::SupervisorMiddleware => "supervisor-middleware", + } + } + + #[must_use] + pub fn contract_capability(self) -> String { + format!("openshell.{}.contract", self.as_str()) + } +} + +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct NegotiatedExtension { + pub family: ExtensionFamily, + pub configured_name: String, + pub implementation_name: String, + pub implementation_version: String, + pub protocol_major: u32, + pub protocol_minor: u32, + pub supported_capabilities: Vec, + pub required_capabilities: Vec, +} + +#[derive(Debug, Error, PartialEq, Eq)] +pub enum NegotiationError { + #[error( + "{family} extension '{name}' did not provide protocol metadata; upgrade the extension to a version that supports OpenShell extension negotiation" + )] + MissingMetadata { family: &'static str, name: String }, + #[error("{family} extension '{name}' did not provide a protocol version")] + MissingProtocolVersion { family: &'static str, name: String }, + #[error( + "{family} extension '{name}' uses unsupported protocol {remote_major}.{remote_minor}; gateway supports {local_major}.{local_minor}" + )] + IncompatibleProtocol { + family: &'static str, + name: String, + remote_major: u32, + remote_minor: u32, + local_major: u32, + local_minor: u32, + }, + #[error("{family} extension '{name}' has invalid {field}: {reason}")] + InvalidMetadata { + family: &'static str, + name: String, + field: &'static str, + reason: String, + }, + #[error("{family} extension '{name}' is missing required capabilities: {capabilities}")] + MissingExtensionCapabilities { + family: &'static str, + name: String, + capabilities: String, + }, + #[error( + "gateway is missing capabilities required by {family} extension '{name}': {capabilities}" + )] + MissingGatewayCapabilities { + family: &'static str, + name: String, + capabilities: String, + }, +} + +#[must_use] +pub fn gateway_metadata(family: ExtensionFamily) -> PeerMetadata { + let contract = family.contract_capability(); + PeerMetadata { + protocol_version: Some(ProtocolVersion { + major: PROTOCOL_MAJOR, + minor: PROTOCOL_MINOR, + }), + implementation_name: "openshell/gateway".to_string(), + implementation_version: crate::VERSION.to_string(), + supported_capabilities: vec![contract.clone()], + required_capabilities: vec![contract], + } +} + +#[must_use] +pub fn extension_metadata( + family: ExtensionFamily, + implementation_name: impl Into, + implementation_version: impl Into, + additional_capabilities: impl IntoIterator, +) -> PeerMetadata { + let contract = family.contract_capability(); + let mut supported_capabilities = vec![contract.clone()]; + supported_capabilities.extend(additional_capabilities); + PeerMetadata { + protocol_version: Some(ProtocolVersion { + major: PROTOCOL_MAJOR, + minor: PROTOCOL_MINOR, + }), + implementation_name: implementation_name.into(), + implementation_version: implementation_version.into(), + supported_capabilities, + required_capabilities: vec![contract], + } +} + +pub fn negotiate( + family: ExtensionFamily, + configured_name: impl Into, + gateway: &PeerMetadata, + extension: Option, +) -> Result { + let configured_name = configured_name.into(); + let family_name = family.as_str(); + let extension = extension.ok_or_else(|| NegotiationError::MissingMetadata { + family: family_name, + name: configured_name.clone(), + })?; + let version = extension.protocol_version.as_ref().ok_or_else(|| { + NegotiationError::MissingProtocolVersion { + family: family_name, + name: configured_name.clone(), + } + })?; + let gateway_version = gateway.protocol_version.as_ref().ok_or_else(|| { + NegotiationError::MissingProtocolVersion { + family: family_name, + name: "gateway".to_string(), + } + })?; + if version.major != gateway_version.major { + return Err(NegotiationError::IncompatibleProtocol { + family: family_name, + name: configured_name, + remote_major: version.major, + remote_minor: version.minor, + local_major: gateway_version.major, + local_minor: gateway_version.minor, + }); + } + + validate_text( + family_name, + &configured_name, + "implementation_name", + &extension.implementation_name, + MAX_IMPLEMENTATION_NAME_BYTES, + )?; + validate_text( + family_name, + &configured_name, + "implementation_version", + &extension.implementation_version, + MAX_IMPLEMENTATION_VERSION_BYTES, + )?; + let extension_supported = normalize_capabilities( + family_name, + &configured_name, + "supported_capabilities", + &extension.supported_capabilities, + )?; + let extension_required = normalize_capabilities( + family_name, + &configured_name, + "required_capabilities", + &extension.required_capabilities, + )?; + let gateway_supported = normalize_capabilities( + family_name, + "gateway", + "supported_capabilities", + &gateway.supported_capabilities, + )?; + let gateway_required = normalize_capabilities( + family_name, + "gateway", + "required_capabilities", + &gateway.required_capabilities, + )?; + + let missing_extension = gateway_required + .difference(&extension_supported) + .cloned() + .collect::>(); + if !missing_extension.is_empty() { + return Err(NegotiationError::MissingExtensionCapabilities { + family: family_name, + name: configured_name, + capabilities: missing_extension.join(", "), + }); + } + let missing_gateway = extension_required + .difference(&gateway_supported) + .cloned() + .collect::>(); + if !missing_gateway.is_empty() { + return Err(NegotiationError::MissingGatewayCapabilities { + family: family_name, + name: configured_name, + capabilities: missing_gateway.join(", "), + }); + } + + Ok(NegotiatedExtension { + family, + configured_name, + implementation_name: extension.implementation_name, + implementation_version: extension.implementation_version, + protocol_major: version.major, + protocol_minor: version.minor, + supported_capabilities: extension_supported.into_iter().collect(), + required_capabilities: extension_required.into_iter().collect(), + }) +} + +fn validate_text( + family: &'static str, + name: &str, + field: &'static str, + value: &str, + max_bytes: usize, +) -> Result<(), NegotiationError> { + let reason = if value.trim().is_empty() { + Some("must not be empty".to_string()) + } else if value.len() > max_bytes { + Some(format!("must be at most {max_bytes} bytes")) + } else if value.chars().any(char::is_control) { + Some("must not contain control characters".to_string()) + } else { + None + }; + if let Some(reason) = reason { + return Err(NegotiationError::InvalidMetadata { + family, + name: name.to_string(), + field, + reason, + }); + } + Ok(()) +} + +fn normalize_capabilities( + family: &'static str, + name: &str, + field: &'static str, + capabilities: &[String], +) -> Result, NegotiationError> { + if capabilities.len() > MAX_CAPABILITIES { + return Err(NegotiationError::InvalidMetadata { + family, + name: name.to_string(), + field, + reason: format!("must contain at most {MAX_CAPABILITIES} entries"), + }); + } + let mut normalized = BTreeSet::new(); + for capability in capabilities { + if !valid_capability(capability) { + return Err(NegotiationError::InvalidMetadata { + family, + name: name.to_string(), + field, + reason: format!("'{capability}' must be a lowercase namespaced identifier"), + }); + } + if !normalized.insert(capability.clone()) { + return Err(NegotiationError::InvalidMetadata { + family, + name: name.to_string(), + field, + reason: format!("contains duplicate '{capability}'"), + }); + } + } + Ok(normalized) +} + +fn valid_capability(value: &str) -> bool { + !value.is_empty() + && value.len() <= MAX_CAPABILITY_BYTES + && value.starts_with("openshell.") + && value.split('.').count() >= 3 + && value.split('.').all(|segment| { + !segment.is_empty() + && segment + .bytes() + .all(|byte| byte.is_ascii_lowercase() || byte.is_ascii_digit() || byte == b'-') + }) +} + +#[cfg(test)] +mod tests { + use super::*; + + fn compatible() -> (PeerMetadata, PeerMetadata) { + let gateway = gateway_metadata(ExtensionFamily::Compute); + let extension = extension_metadata( + ExtensionFamily::Compute, + "example/compute", + "2.3.4", + ["openshell.compute.optional-future".to_string()], + ); + (gateway, extension) + } + + #[test] + fn compatible_metadata_negotiates_and_sorts_unknown_optional_capabilities() { + let (gateway, mut extension) = compatible(); + extension.supported_capabilities.reverse(); + let result = negotiate( + ExtensionFamily::Compute, + "example", + &gateway, + Some(extension), + ) + .unwrap(); + assert_eq!(result.protocol_major, 1); + assert_eq!( + result.supported_capabilities, + vec![ + "openshell.compute.contract", + "openshell.compute.optional-future" + ] + ); + } + + #[test] + fn same_major_minor_skew_is_compatible() { + let (gateway, mut extension) = compatible(); + extension.protocol_version.as_mut().unwrap().minor = 99; + assert!( + negotiate( + ExtensionFamily::Compute, + "example", + &gateway, + Some(extension) + ) + .is_ok() + ); + } + + #[test] + fn missing_metadata_and_major_skew_are_actionable() { + let (gateway, mut extension) = compatible(); + assert!(matches!( + negotiate(ExtensionFamily::Compute, "example", &gateway, None), + Err(NegotiationError::MissingMetadata { .. }) + )); + extension.protocol_version.as_mut().unwrap().major = 2; + assert!(matches!( + negotiate( + ExtensionFamily::Compute, + "example", + &gateway, + Some(extension) + ), + Err(NegotiationError::IncompatibleProtocol { .. }) + )); + } + + #[test] + fn both_peers_require_capabilities_from_the_other() { + let (mut gateway, mut extension) = compatible(); + gateway + .required_capabilities + .push("openshell.compute.gateway-required".to_string()); + assert!(matches!( + negotiate( + ExtensionFamily::Compute, + "example", + &gateway, + Some(extension.clone()) + ), + Err(NegotiationError::MissingExtensionCapabilities { .. }) + )); + + gateway.required_capabilities.pop(); + extension + .required_capabilities + .push("openshell.compute.extension-required".to_string()); + assert!(matches!( + negotiate( + ExtensionFamily::Compute, + "example", + &gateway, + Some(extension) + ), + Err(NegotiationError::MissingGatewayCapabilities { .. }) + )); + } + + #[test] + fn malformed_and_duplicate_capabilities_are_rejected() { + let (gateway, mut extension) = compatible(); + extension + .supported_capabilities + .push("NOT-NAMESPACED".to_string()); + assert!(matches!( + negotiate( + ExtensionFamily::Compute, + "example", + &gateway, + Some(extension) + ), + Err(NegotiationError::InvalidMetadata { .. }) + )); + + let (gateway, mut extension) = compatible(); + extension + .supported_capabilities + .push("openshell.compute.contract".to_string()); + assert!(matches!( + negotiate( + ExtensionFamily::Compute, + "example", + &gateway, + Some(extension) + ), + Err(NegotiationError::InvalidMetadata { .. }) + )); + } +} diff --git a/crates/openshell-core/src/lib.rs b/crates/openshell-core/src/lib.rs index a0a317d412..b310aba8ac 100644 --- a/crates/openshell-core/src/lib.rs +++ b/crates/openshell-core/src/lib.rs @@ -20,6 +20,7 @@ pub mod dynamic_string_allowlist; pub mod endpoint_path; pub mod endpoint_status; pub mod error; +pub mod extension_protocol; #[cfg(unix)] pub mod external_driver_socket; pub mod forward; diff --git a/crates/openshell-core/src/middleware.rs b/crates/openshell-core/src/middleware.rs index a4023bfb1c..ff8ceff569 100644 --- a/crates/openshell-core/src/middleware.rs +++ b/crates/openshell-core/src/middleware.rs @@ -12,9 +12,9 @@ use tonic::{Request, Response, Status}; use crate::proto::{ HttpHeader, HttpRequestEvaluation, HttpRequestResult, HttpRequestTarget, HttpResponseEvent, - HttpResponseEventResult, MiddlewareManifest, RequestContext, SupervisorMiddlewarePhase, - ValidateConfigRequest, ValidateConfigResponse, WebSocketSessionEvent, - WebSocketSessionEventResult, + HttpResponseEventResult, MiddlewareDescribeRequest, MiddlewareManifest, RequestContext, + SupervisorMiddlewarePhase, ValidateConfigRequest, ValidateConfigResponse, + WebSocketSessionEvent, WebSocketSessionEventResult, }; /// Transport-neutral result stream for one HTTP response middleware stage. @@ -37,7 +37,10 @@ pub type WebSocketResponseStream = Pin< /// whether invocations are direct calls or serialized gRPC requests. #[tonic::async_trait] pub trait SupervisorMiddlewareEndpoint: Send + Sync { - async fn describe(&self, request: Request<()>) -> Result, Status>; + async fn describe( + &self, + request: Request, + ) -> Result, Status>; async fn validate_config( &self, @@ -193,6 +196,12 @@ impl<'a> HttpRequestView<'a> { /// request_timeout: None, /// }], /// expected_audience: String::new(), +/// extension: Some(openshell_core::extension_protocol::extension_metadata( +/// openshell_core::extension_protocol::ExtensionFamily::SupervisorMiddleware, +/// "example/audit", +/// "1", +/// [], +/// )), /// } /// } /// diff --git a/crates/openshell-core/src/proto/mod.rs b/crates/openshell-core/src/proto/mod.rs index e05222e670..c6076620a9 100644 --- a/crates/openshell-core/src/proto/mod.rs +++ b/crates/openshell-core/src/proto/mod.rs @@ -40,6 +40,10 @@ pub mod compute { pub use super::generated::openshell::compute::v1; } +pub mod extension { + pub use super::generated::openshell::extension::v1; +} + #[allow( clippy::all, clippy::pedantic, diff --git a/crates/openshell-driver-docker/src/lib.rs b/crates/openshell-driver-docker/src/lib.rs index 1bdfac927f..c741f5f519 100644 --- a/crates/openshell-driver-docker/src/lib.rs +++ b/crates/openshell-driver-docker/src/lib.rs @@ -311,7 +311,6 @@ struct DockerDriverRuntimeConfig { gateway_tls_server_name: Option, ssh_socket_path: String, guest_tls: Option, - daemon_version: String, gpu: DockerGpuRuntimeCapabilities, sandbox_pids_limit: Option, enable_bind_mounts: bool, @@ -859,7 +858,7 @@ impl DockerComputeDriver { .map_err(|err| { Error::execution(format!("failed to create Docker client: {err}")) })?; - let version = docker.version().await.map_err(|err| { + docker.version().await.map_err(|err| { Error::execution(format!("failed to query Docker daemon version: {err}")) })?; let info = docker.info().await.map_err(|err| { @@ -973,7 +972,6 @@ impl DockerComputeDriver { gateway_tls_server_name, ssh_socket_path: docker_config.ssh_socket_path.clone(), guest_tls, - daemon_version: version.version.unwrap_or_else(|| "unknown".to_string()), gpu, sandbox_pids_limit: docker_config.sandbox_pids_limit, enable_bind_mounts: docker_config.enable_bind_mounts, @@ -1014,7 +1012,7 @@ impl DockerComputeDriver { fn capabilities(&self) -> GetCapabilitiesResponse { GetCapabilitiesResponse { driver_name: "docker".to_string(), - driver_version: self.config.daemon_version.clone(), + driver_version: openshell_core::VERSION.to_string(), default_image: self.config.default_image.clone(), gateway_manages_lifecycle: true, supports_sandbox_authentication: false, @@ -1033,6 +1031,12 @@ impl DockerComputeDriver { }), rootfs_tar_staging_dir: String::new(), rootfs_tar_max_bytes: 0, + extension: Some(openshell_core::extension_protocol::extension_metadata( + openshell_core::extension_protocol::ExtensionFamily::Compute, + "openshell/docker", + openshell_core::VERSION, + [], + )), } } diff --git a/crates/openshell-driver-docker/src/tests.rs b/crates/openshell-driver-docker/src/tests.rs index a0f45f31b7..239f9bf7b6 100644 --- a/crates/openshell-driver-docker/src/tests.rs +++ b/crates/openshell-driver-docker/src/tests.rs @@ -147,7 +147,6 @@ fn runtime_config() -> DockerDriverRuntimeConfig { cert: PathBuf::from("/tmp/tls.crt"), key: PathBuf::from("/tmp/tls.key"), }), - daemon_version: "28.0.0".to_string(), gpu: DockerGpuRuntimeCapabilities { cdi_supported: false, wsl_all_gpu_fallback_enabled: false, @@ -298,7 +297,7 @@ async fn tracing_standalone_rpc_layer_propagates_context_and_records_errors() { let (mut client, shutdown, server) = standalone_traced_client().await; client - .get_capabilities(request_with_traceparent(GetCapabilitiesRequest {})) + .get_capabilities(request_with_traceparent(GetCapabilitiesRequest::default())) .await .expect("capabilities should succeed"); client @@ -451,7 +450,7 @@ async fn tracing_in_process_service_preserves_the_driver_rpc_server_boundary() { otel.name = "openshell.compute.v1.ComputeDriver/GetCapabilities", otel.kind = "client" ); - ComputeDriver::get_capabilities(&service, Request::new(GetCapabilitiesRequest {})) + ComputeDriver::get_capabilities(&service, Request::new(GetCapabilitiesRequest::default())) .instrument(gateway_span) .await?; diff --git a/crates/openshell-driver-kubernetes-secrets/src/lib.rs b/crates/openshell-driver-kubernetes-secrets/src/lib.rs index ae733d62e7..669b7ac514 100644 --- a/crates/openshell-driver-kubernetes-secrets/src/lib.rs +++ b/crates/openshell-driver-kubernetes-secrets/src/lib.rs @@ -469,6 +469,12 @@ impl CredentialDriver for CredentialDriverService { backend_kind: KubernetesSecretsCredentialDriver::NAME.to_string(), supports_list: false, supports_expires_at: false, + extension: Some(openshell_core::extension_protocol::extension_metadata( + openshell_core::extension_protocol::ExtensionFamily::Credentials, + "openshell/kubernetes-secrets", + VERSION, + [], + )), })) } diff --git a/crates/openshell-driver-kubernetes/src/driver.rs b/crates/openshell-driver-kubernetes/src/driver.rs index c9e2682983..849a3631e5 100644 --- a/crates/openshell-driver-kubernetes/src/driver.rs +++ b/crates/openshell-driver-kubernetes/src/driver.rs @@ -763,6 +763,12 @@ impl KubernetesComputeDriver { }), rootfs_tar_staging_dir: String::new(), rootfs_tar_max_bytes: 0, + extension: Some(openshell_core::extension_protocol::extension_metadata( + openshell_core::extension_protocol::ExtensionFamily::Compute, + "openshell/kubernetes", + openshell_core::VERSION, + [], + )), }) } diff --git a/crates/openshell-driver-kubernetes/src/grpc.rs b/crates/openshell-driver-kubernetes/src/grpc.rs index 82d54ecea0..3f077ca1ab 100644 --- a/crates/openshell-driver-kubernetes/src/grpc.rs +++ b/crates/openshell-driver-kubernetes/src/grpc.rs @@ -376,9 +376,12 @@ mod tests { otel.name = "openshell.compute.v1.ComputeDriver/GetCapabilities", otel.kind = "client" ); - ComputeDriver::get_capabilities(&service, Request::new(GetCapabilitiesRequest {})) - .instrument(gateway_span) - .await?; + ComputeDriver::get_capabilities( + &service, + Request::new(GetCapabilitiesRequest::default()), + ) + .instrument(gateway_span) + .await?; ComputeDriver::validate_sandbox_create( &service, diff --git a/crates/openshell-driver-mxc/src/driver.rs b/crates/openshell-driver-mxc/src/driver.rs index 708aa3ae90..81c26a080c 100644 --- a/crates/openshell-driver-mxc/src/driver.rs +++ b/crates/openshell-driver-mxc/src/driver.rs @@ -462,6 +462,12 @@ impl MxcComputeBackend { resource_capabilities: None, rootfs_tar_staging_dir: String::new(), rootfs_tar_max_bytes: 0, + extension: Some(openshell_core::extension_protocol::extension_metadata( + openshell_core::extension_protocol::ExtensionFamily::Compute, + "openshell/mxc", + openshell_core::VERSION, + [], + )), } } diff --git a/crates/openshell-driver-podman/src/driver.rs b/crates/openshell-driver-podman/src/driver.rs index 62142a3157..a2078a18a3 100644 --- a/crates/openshell-driver-podman/src/driver.rs +++ b/crates/openshell-driver-podman/src/driver.rs @@ -547,6 +547,12 @@ impl PodmanComputeDriver { }), rootfs_tar_staging_dir: String::new(), rootfs_tar_max_bytes: 0, + extension: Some(openshell_core::extension_protocol::extension_metadata( + openshell_core::extension_protocol::ExtensionFamily::Compute, + "openshell/podman", + openshell_core::VERSION, + [], + )), }) } diff --git a/crates/openshell-driver-podman/src/grpc.rs b/crates/openshell-driver-podman/src/grpc.rs index b8605d9f49..7c7e6f8f91 100644 --- a/crates/openshell-driver-podman/src/grpc.rs +++ b/crates/openshell-driver-podman/src/grpc.rs @@ -378,7 +378,7 @@ mod tests { async { let gateway_span = tracing::info_span!(target: "openshell_server::compute", "driver", otel.name = "openshell.compute.v1.ComputeDriver/GetCapabilities", otel.kind = "client"); - ComputeDriver::get_capabilities(&service, Request::new(GetCapabilitiesRequest {})) + ComputeDriver::get_capabilities(&service, Request::new(GetCapabilitiesRequest::default())) .instrument(gateway_span) .await } @@ -441,7 +441,7 @@ mod tests { let (mut client, shutdown, server) = standalone_traced_client().await; client - .get_capabilities(request_with_traceparent(GetCapabilitiesRequest {})) + .get_capabilities(request_with_traceparent(GetCapabilitiesRequest::default())) .await .expect("capabilities should succeed"); client diff --git a/crates/openshell-driver-vault/src/lib.rs b/crates/openshell-driver-vault/src/lib.rs index 4ae5c9c8ad..528cb59d60 100644 --- a/crates/openshell-driver-vault/src/lib.rs +++ b/crates/openshell-driver-vault/src/lib.rs @@ -509,6 +509,12 @@ impl CredentialDriver for CredentialDriverService { backend_kind: VaultCredentialDriver::NAME.to_string(), supports_list: false, supports_expires_at: false, + extension: Some(openshell_core::extension_protocol::extension_metadata( + openshell_core::extension_protocol::ExtensionFamily::Credentials, + "openshell/vault", + VERSION, + [], + )), })) } diff --git a/crates/openshell-driver-vm/src/driver.rs b/crates/openshell-driver-vm/src/driver.rs index 1ad10f654b..b88a47cfc8 100644 --- a/crates/openshell-driver-vm/src/driver.rs +++ b/crates/openshell-driver-vm/src/driver.rs @@ -1002,6 +1002,12 @@ impl VmDriver { .to_string_lossy() .into_owned(), rootfs_tar_max_bytes: self.config.rootfs_tar_max_bytes(), + extension: Some(openshell_core::extension_protocol::extension_metadata( + openshell_core::extension_protocol::ExtensionFamily::Compute, + "openshell/vm", + openshell_core::VERSION, + [], + )), } } @@ -7141,7 +7147,7 @@ mod tests { let mut client = traced_driver_client(driver).await; client - .get_capabilities(request_with_traceparent(GetCapabilitiesRequest {})) + .get_capabilities(request_with_traceparent(GetCapabilitiesRequest::default())) .await .unwrap(); client.shutdown().await; @@ -7173,7 +7179,7 @@ mod tests { let mut client = traced_driver_client(driver).await; client - .get_capabilities(request_with_traceparent(GetCapabilitiesRequest {})) + .get_capabilities(request_with_traceparent(GetCapabilitiesRequest::default())) .await .unwrap(); assert!( diff --git a/crates/openshell-gateway-interceptors/src/plan.rs b/crates/openshell-gateway-interceptors/src/plan.rs index 3328348249..cec0711876 100644 --- a/crates/openshell-gateway-interceptors/src/plan.rs +++ b/crates/openshell-gateway-interceptors/src/plan.rs @@ -10,6 +10,9 @@ use openshell_core::config::{ GatewayInterceptorBindingOverride, GatewayInterceptorBindingPolicy, GatewayInterceptorConfig, GatewayInterceptorFailurePolicy, GatewayInterceptorPhaseConfig, }; +use openshell_core::extension_protocol::{ + ExtensionFamily, NegotiatedExtension, gateway_metadata, negotiate, +}; use openshell_core::proto::gateway_interceptor::v1::{ DescribeRequest, GatewayInterceptorPhase, InterceptorBinding, InterceptorSelector, gateway_interceptor_client::GatewayInterceptorClient, @@ -158,6 +161,7 @@ pub struct ExecutionPlan { bindings: BTreeMap<(RpcSelector, Phase), Vec>, profile_sources: BTreeMap, routes: OpenShellRouteIndex, + negotiated_extensions: Vec, } impl ExecutionPlan { @@ -167,6 +171,7 @@ impl ExecutionPlan { bindings: BTreeMap::new(), profile_sources: BTreeMap::new(), routes, + negotiated_extensions: Vec::new(), } } @@ -181,6 +186,7 @@ impl ExecutionPlan { let mut bindings: BTreeMap<(RpcSelector, Phase), Vec> = BTreeMap::new(); let mut profile_sources = BTreeMap::new(); + let mut negotiated_extensions = Vec::new(); for config in configs { let channel = connect_endpoint(&config).await?; @@ -208,22 +214,33 @@ impl ExecutionPlan { .max_response_bytes .unwrap_or(DEFAULT_MAX_RESPONSE_BYTES), ); - let manifest = - tokio::time::timeout(timeout, client.describe(Request::new(DescribeRequest {}))) - .await - .map_err(|_| { - InterceptorError::Transport(format!( - "Describe timed out for '{}'", - config.name - )) - })? - .map_err(|status| { - InterceptorError::Transport(format!( - "Describe failed for '{}': {status}", - config.name - )) - })? - .into_inner(); + let gateway = gateway_metadata(ExtensionFamily::GatewayInterceptor); + let manifest = tokio::time::timeout( + timeout, + client.describe(Request::new(DescribeRequest { + gateway: Some(gateway.clone()), + })), + ) + .await + .map_err(|_| { + InterceptorError::Transport(format!("Describe timed out for '{}'", config.name)) + })? + .map_err(|status| { + InterceptorError::Transport(format!( + "Describe failed for '{}': {status}", + config.name + )) + })? + .into_inner(); + negotiated_extensions.push( + negotiate( + ExtensionFamily::GatewayInterceptor, + &config.name, + &gateway, + manifest.extension.clone(), + ) + .map_err(|error| InterceptorError::Config(error.to_string()))?, + ); validate_expected_audience( &config, &manifest.expected_audience, @@ -326,6 +343,7 @@ impl ExecutionPlan { bindings, profile_sources, routes, + negotiated_extensions, }) } @@ -336,6 +354,10 @@ impl ExecutionPlan { self.profile_sources.get(interceptor_name).cloned() } + pub(crate) fn negotiated_extensions(&self) -> &[NegotiatedExtension] { + &self.negotiated_extensions + } + pub(crate) fn is_empty(&self) -> bool { self.bindings.is_empty() && self.profile_sources.is_empty() } diff --git a/crates/openshell-gateway-interceptors/src/runtime.rs b/crates/openshell-gateway-interceptors/src/runtime.rs index 91ea949feb..235f28b7b0 100644 --- a/crates/openshell-gateway-interceptors/src/runtime.rs +++ b/crates/openshell-gateway-interceptors/src/runtime.rs @@ -10,6 +10,7 @@ use std::time::Instant; use json_patch::{PatchOperation, patch}; use metrics::{counter, histogram}; use openshell_core::config::GatewayInterceptorConfig; +use openshell_core::extension_protocol::NegotiatedExtension; use openshell_core::proto::gateway_interceptor::v1::{ InterceptorEvaluation, InterceptorResult, JsonPatch, ModifyOperationEvaluation, PostCommitEvaluation, ValidateEvaluation, interceptor_evaluation, @@ -104,6 +105,11 @@ impl GatewayInterceptorRuntime { self.plan.is_empty() } + #[must_use] + pub fn negotiated_extensions(&self) -> &[NegotiatedExtension] { + self.plan.negotiated_extensions() + } + #[must_use] pub fn should_intercept_path(&self, path: &str) -> bool { let Some(selector) = RpcSelector::from_grpc_path(path) else { diff --git a/crates/openshell-gateway/src/vm.rs b/crates/openshell-gateway/src/vm.rs index 07735c7a9c..3956eca30f 100644 --- a/crates/openshell-gateway/src/vm.rs +++ b/crates/openshell-gateway/src/vm.rs @@ -718,7 +718,7 @@ async fn wait_for_compute_driver( let mut client = ComputeDriverClient::with_interceptor(channel.clone(), TraceContextInterceptor); match client - .get_capabilities(tonic::Request::new(GetCapabilitiesRequest {})) + .get_capabilities(tonic::Request::new(GetCapabilitiesRequest::default())) .await { Ok(_) => return Ok(channel), diff --git a/crates/openshell-sdk/tests/client_mock.rs b/crates/openshell-sdk/tests/client_mock.rs index f2fc52b5ff..a70039c662 100644 --- a/crates/openshell-sdk/tests/client_mock.rs +++ b/crates/openshell-sdk/tests/client_mock.rs @@ -224,6 +224,7 @@ impl OpenShell for TestOpenShell { status: proto::ServiceStatus::Healthy.into(), gateway_version: "test-1.2.3".to_string(), compute_drivers: Vec::new(), + extensions: Vec::new(), })) } diff --git a/crates/openshell-server/src/compute/mod.rs b/crates/openshell-server/src/compute/mod.rs index 4cca02d6ac..5dab42a806 100644 --- a/crates/openshell-server/src/compute/mod.rs +++ b/crates/openshell-server/src/compute/mod.rs @@ -20,6 +20,9 @@ use crate::tracing_bus::TracingLogBus; use futures::{Stream, StreamExt}; #[cfg(unix)] use hyper_util::rt::TokioIo; +use openshell_core::extension_protocol::{ + ExtensionFamily, NegotiatedExtension, gateway_metadata, negotiate, +}; use openshell_core::proto::compute::v1::{ AuthenticateSandboxRequest, CreateSandboxRequest, DeleteSandboxRequest, DeleteWorkspaceRequest, DeleteWorkspaceResponse, DriverCondition, DriverPlatformEvent, DriverResourceRequirements, @@ -314,6 +317,8 @@ pub struct ComputeDriverInfoSnapshot { pub driver_name: String, /// Driver-reported implementation version from the startup capability snapshot. pub driver_version: String, + /// Common extension protocol negotiation result. + pub negotiated_extension: NegotiatedExtension, /// Whether the driver asks the gateway to reconcile compute across restarts. pub gateway_manages_lifecycle: bool, /// Whether the driver authenticates driver-native sandbox credentials. @@ -658,14 +663,24 @@ impl ComputeRuntime { tracing_log_bus: TracingLogBus, supervisor_sessions: Arc, ) -> Result { + let gateway = gateway_metadata(ExtensionFamily::Compute); let capabilities = driver - .get_capabilities(Request::new(GetCapabilitiesRequest {})) + .get_capabilities(Request::new(GetCapabilitiesRequest { + gateway: Some(gateway.clone()), + })) .await .map_err(|status| { tracing::Span::current().record("otel.status_code", "ERROR"); compute_error_from_status(status) })? .into_inner(); + let negotiated_extension = negotiate( + ExtensionFamily::Compute, + &driver_name, + &gateway, + capabilities.extension.clone(), + ) + .map_err(|error| ComputeError::Message(error.to_string()))?; info!( configured_driver = %driver_name, advertised_driver = %capabilities.driver_name, @@ -675,6 +690,7 @@ impl ComputeRuntime { name: driver_name.clone(), driver_name: capabilities.driver_name, driver_version: capabilities.driver_version, + negotiated_extension, gateway_manages_lifecycle: capabilities.gateway_manages_lifecycle, supports_sandbox_authentication: capabilities.supports_sandbox_authentication, driver_reports_runtime_readiness: capabilities.driver_reports_runtime_readiness, @@ -5062,6 +5078,12 @@ impl ComputeDriver for NoopTestDriver { resource_capabilities: None, rootfs_tar_staging_dir: String::new(), rootfs_tar_max_bytes: 0, + extension: Some(openshell_core::extension_protocol::extension_metadata( + ExtensionFamily::Compute, + "openshell/noop-test-driver", + "test", + [], + )), }, )) } @@ -5185,6 +5207,23 @@ pub async fn new_test_runtime(store: Arc) -> ComputeRuntime { new_test_runtime_for_driver(store, "test").await } +#[cfg(any(test, feature = "test-support"))] +fn test_compute_negotiation(name: &str) -> NegotiatedExtension { + let gateway = gateway_metadata(ExtensionFamily::Compute); + negotiate( + ExtensionFamily::Compute, + name, + &gateway, + Some(openshell_core::extension_protocol::extension_metadata( + ExtensionFamily::Compute, + format!("openshell/{name}"), + "test", + [], + )), + ) + .unwrap() +} + #[cfg(any(test, feature = "test-support"))] pub async fn new_test_runtime_for_driver(store: Arc, driver_name: &str) -> ComputeRuntime { new_test_runtime_with_driver(store, driver_name, Arc::new(NoopTestDriver::default())) @@ -5203,6 +5242,7 @@ pub fn new_test_runtime_with_driver( name: driver_name.to_string(), driver_name: driver_name.to_string(), driver_version: "test".to_string(), + negotiated_extension: test_compute_negotiation(driver_name), gateway_manages_lifecycle: false, supports_sandbox_authentication, driver_reports_runtime_readiness: false, @@ -5514,6 +5554,7 @@ mod tests { listed_sandboxes: Vec, current_sandboxes: Vec, workspace_rpcs_unimplemented: bool, + omit_protocol_metadata: bool, } #[tonic::async_trait] @@ -5546,6 +5587,14 @@ mod tests { resource_capabilities: None, rootfs_tar_staging_dir: String::new(), rootfs_tar_max_bytes: 0, + extension: (!self.omit_protocol_metadata).then(|| { + openshell_core::extension_protocol::extension_metadata( + ExtensionFamily::Compute, + "openshell/test-driver", + "test", + [], + ) + }), })) } @@ -5899,6 +5948,12 @@ mod tests { resource_capabilities: None, rootfs_tar_staging_dir: String::new(), rootfs_tar_max_bytes: 0, + extension: Some(openshell_core::extension_protocol::extension_metadata( + ExtensionFamily::Compute, + "openshell/controlled-test-driver", + "test", + [], + )), })) } @@ -6110,6 +6165,7 @@ mod tests { name: driver_name.to_string(), driver_name: driver_name.to_string(), driver_version: "test".to_string(), + negotiated_extension: test_compute_negotiation(driver_name), gateway_manages_lifecycle: false, supports_sandbox_authentication: false, driver_reports_runtime_readiness: false, @@ -10524,6 +10580,7 @@ mod tests { }), workspace: "default".to_string(), }], + ..Default::default() })) .await; @@ -10695,6 +10752,7 @@ mod tests { })), workspace: "default".to_string(), }], + ..Default::default() })) .await; @@ -11533,6 +11591,32 @@ mod tests { test_exporter::assert_is_root(&initialization); } + #[tokio::test] + async fn compute_driver_initialization_rejects_missing_protocol_metadata() { + let store = Arc::new(Store::connect("sqlite::memory:").await.unwrap()); + let error = ComputeRuntime::from_driver( + "legacy-driver".to_string(), + Arc::new(TestDriver { + omit_protocol_metadata: true, + ..Default::default() + }), + None, + store, + SandboxIndex::new(), + SandboxWatchBus::new(), + TracingLogBus::new(), + Arc::new(SupervisorSessionRegistry::new()), + ) + .await + .expect_err("legacy driver must fail negotiation"); + + assert!( + error + .to_string() + .contains("did not provide protocol metadata") + ); + } + #[tokio::test] #[cfg(unix)] async fn remote_compute_driver_interceptor_propagates_every_rpc() { @@ -11556,7 +11640,9 @@ mod tests { let traced = test_exporter::install_traced(); async { remote - .get_capabilities(Request::new(GetCapabilitiesRequest {})) + .get_capabilities(Request::new(GetCapabilitiesRequest { + gateway: Some(gateway_metadata(ExtensionFamily::Compute)), + })) .await .unwrap(); remote diff --git a/crates/openshell-server/src/credentials.rs b/crates/openshell-server/src/credentials.rs index 6098357f01..0d853c3126 100644 --- a/crates/openshell-server/src/credentials.rs +++ b/crates/openshell-server/src/credentials.rs @@ -25,6 +25,9 @@ use std::{ use async_trait::async_trait; #[cfg(unix)] use hyper_util::rt::TokioIo; +use openshell_core::extension_protocol::{ + ExtensionFamily, NegotiatedExtension, extension_metadata, gateway_metadata, negotiate, +}; use openshell_core::proto::credentials::v1::{ DeleteCredentialRequest, GetCredentialDriverCapabilitiesRequest, GetCredentialDriverCapabilitiesResponse, ResolveCredentialRequest, ResolveCredentialsRequest, @@ -122,6 +125,7 @@ pub struct CredentialRuntime { registry: CredentialDriverRegistry, drivers: BTreeMap>, _driver_processes: Vec>, + negotiated_extensions: Vec, } impl CredentialRuntime { @@ -154,10 +158,15 @@ impl CredentialRuntime { } } + let negotiated_extensions = drivers + .keys() + .map(|name| negotiate_builtin_credential_driver(name)) + .collect::>>()?; Ok(Self { registry, drivers, _driver_processes: Vec::new(), + negotiated_extensions, }) } @@ -184,6 +193,7 @@ impl CredentialRuntime { let registry = CredentialDriverRegistry::from_config(config)?; let mut drivers = BTreeMap::new(); let mut driver_processes = Vec::new(); + let mut negotiated_extensions = Vec::new(); let empty_config = toml::Table::new(); let default_store_config = config_file .and_then(|file| file.openshell.gateway.credential_storage.as_ref()) @@ -194,6 +204,11 @@ impl CredentialRuntime { default_store_config, registry.requires_default_store(), )?; + if drivers.contains_key(DbCredstoreCredentialDriver::NAME) { + negotiated_extensions.push(negotiate_builtin_credential_driver( + DbCredstoreCredentialDriver::NAME, + )?); + } for driver_name in registry.enabled_driver_names() { let driver_config = config_file @@ -205,12 +220,14 @@ impl CredentialRuntime { let built = build_configured_driver(driver_name, driver_config, store.clone()).await?; drivers.insert(driver_name.clone(), built.driver); + negotiated_extensions.push(built.negotiated_extension); if let Some(process) = built.process { driver_processes.push(process); } } else { let driver = build_default_in_tree_driver(driver_name, store.clone()).await?; drivers.insert(driver_name.clone(), driver); + negotiated_extensions.push(negotiate_builtin_credential_driver(driver_name)?); } } @@ -218,6 +235,7 @@ impl CredentialRuntime { registry, drivers, _driver_processes: driver_processes, + negotiated_extensions, }) } @@ -230,6 +248,11 @@ impl CredentialRuntime { self.drivers.contains_key(&driver_name) } + #[must_use] + pub fn negotiated_extensions(&self) -> &[NegotiatedExtension] { + &self.negotiated_extensions + } + pub fn storage_owns_handle(&self, handle: &CredentialHandle) -> bool { normalize_driver_name(&handle.driver) == self.registry.storage_owner_name() } @@ -1128,10 +1151,27 @@ fn connect_default_credential_store( Ok(()) } +fn negotiate_builtin_credential_driver(name: &str) -> CoreResult { + let gateway = gateway_metadata(ExtensionFamily::Credentials); + negotiate( + ExtensionFamily::Credentials, + name, + &gateway, + Some(extension_metadata( + ExtensionFamily::Credentials, + format!("openshell/{name}"), + openshell_core::VERSION, + [], + )), + ) + .map_err(|error| Error::config(error.to_string())) +} + #[derive(Debug)] struct BuiltCredentialDriver { driver: Arc, process: Option>, + negotiated_extension: NegotiatedExtension, } async fn build_configured_driver( @@ -1151,6 +1191,7 @@ async fn build_configured_driver( Ok(BuiltCredentialDriver { driver, process: None, + negotiated_extension: negotiate_builtin_credential_driver(driver_name)?, }) } CredentialDriverTransport::Uds => { @@ -1489,10 +1530,12 @@ async fn connect_uds_driver( if config.command.is_some() { spawn_uds_driver(driver_name, config, socket_path).await } else { - let channel = connect_ready_credential_driver(driver_name, socket_path).await?; + let (channel, negotiated_extension) = + connect_ready_credential_driver(driver_name, socket_path).await?; Ok(BuiltCredentialDriver { driver: Arc::new(RemoteCredentialDriver::new(channel)), process: None, + negotiated_extension, }) } } @@ -1545,7 +1588,7 @@ async fn spawn_uds_driver( command_path.display() )) })?; - let channel = wait_for_launched_credential_driver( + let (channel, negotiated_extension) = wait_for_launched_credential_driver( driver_name, socket_path, &mut child, @@ -1559,6 +1602,7 @@ async fn spawn_uds_driver( Ok(BuiltCredentialDriver { driver: Arc::new(RemoteCredentialDriver::new(channel)), process: Some(process), + negotiated_extension, }) } @@ -1610,7 +1654,7 @@ async fn wait_for_launched_credential_driver( socket_path: &Path, child: &mut tokio::process::Child, timeout: Duration, -) -> CoreResult { +) -> CoreResult<(Channel, NegotiatedExtension)> { let deadline = Instant::now() + timeout; let mut last_error: Option = None; @@ -1641,7 +1685,7 @@ async fn wait_for_launched_credential_driver( ) .await { - Ok(Ok(channel)) => return Ok(channel), + Ok(Ok(connected)) => return Ok(connected), Ok(Err(err)) => last_error = Some(err.to_string()), Err(_) => { return Err(Error::execution(format!( @@ -1666,15 +1710,29 @@ async fn wait_for_launched_credential_driver( async fn connect_ready_credential_driver( driver_name: &str, socket_path: &Path, -) -> CoreResult { +) -> CoreResult<(Channel, NegotiatedExtension)> { let channel = connect_credential_driver_socket(driver_name, socket_path).await?; let mut client = CredentialDriverClient::new(channel.clone()); - let mut request = Request::new(GetCredentialDriverCapabilitiesRequest {}); + let gateway = gateway_metadata(ExtensionFamily::Credentials); + let mut request = Request::new(GetCredentialDriverCapabilitiesRequest { + gateway: Some(gateway.clone()), + }); let timeout = Duration::from_secs(DEFAULT_CREDENTIAL_DRIVER_RPC_TIMEOUT_SECS); request.set_timeout(timeout); - await_credential_driver_capabilities(driver_name, timeout, client.get_capabilities(request)) - .await?; - Ok(channel) + let capabilities = await_credential_driver_capabilities( + driver_name, + timeout, + client.get_capabilities(request), + ) + .await?; + let negotiated_extension = negotiate( + ExtensionFamily::Credentials, + driver_name, + &gateway, + capabilities.extension, + ) + .map_err(|error| Error::config(error.to_string()))?; + Ok((channel, negotiated_extension)) } #[cfg(unix)] @@ -1684,7 +1742,7 @@ async fn await_credential_driver_capabilities( response: impl Future< Output = Result, Status>, >, -) -> CoreResult<()> { +) -> CoreResult { tokio::time::timeout(timeout, response) .await .map_err(|_| { @@ -1696,8 +1754,8 @@ async fn await_credential_driver_capabilities( Error::config(format!( "credential driver '{driver_name}' GetCapabilities failed: {status}" )) - })?; - Ok(()) + }) + .map(tonic::Response::into_inner) } #[cfg(unix)] @@ -1957,6 +2015,23 @@ mod tests { ); } + #[test] + fn built_in_credential_driver_uses_common_negotiation_snapshot() { + let runtime = CredentialRuntime::from_config( + &Config::new(None).with_credential_drivers(["test-static"]), + ) + .unwrap(); + + let negotiated = runtime.negotiated_extensions(); + assert_eq!(negotiated.len(), 1); + assert_eq!(negotiated[0].family, ExtensionFamily::Credentials); + assert_eq!(negotiated[0].configured_name, "test-static"); + assert_eq!( + negotiated[0].protocol_major, + openshell_core::extension_protocol::PROTOCOL_MAJOR + ); + } + #[test] fn registry_allows_legacy_inline_credentials_with_default_driver() { let registry = CredentialDriverRegistry::from_config(&Config::new(None)).unwrap(); diff --git a/crates/openshell-server/src/grpc/mod.rs b/crates/openshell-server/src/grpc/mod.rs index 7c089c04bf..4dfcdebf33 100644 --- a/crates/openshell-server/src/grpc/mod.rs +++ b/crates/openshell-server/src/grpc/mod.rs @@ -14,6 +14,7 @@ mod service; mod validation; pub mod workspace; +use openshell_core::extension_protocol::{ExtensionFamily, NegotiatedExtension}; use openshell_core::proto::{ AddWorkspaceMemberRequest, AddWorkspaceMemberResponse, ApproveAllDraftChunksRequest, ApproveAllDraftChunksResponse, ApproveDraftChunkRequest, ApproveDraftChunkResponse, @@ -30,14 +31,14 @@ use openshell_core::proto::{ DeleteWorkspaceRequest, DeleteWorkspaceResponse, DetachSandboxProviderRequest, DetachSandboxProviderResponse, EditDraftChunkRequest, EditDraftChunkResponse, ExchangeProviderSubjectTokenRequest, ExchangeProviderSubjectTokenResponse, ExecSandboxEvent, - ExecSandboxInput, ExecSandboxRequest, ExposeServiceRequest, FinalizeMainProcessExitRequest, - FinalizeMainProcessExitResponse, GatewayMessage, GetCurrentUserRequest, GetCurrentUserResponse, - GetDraftHistoryRequest, GetDraftHistoryResponse, GetDraftPolicyRequest, GetDraftPolicyResponse, - GetGatewayConfigRequest, GetGatewayConfigResponse, GetGatewayInfoRequest, - GetGatewayInfoResponse, GetProviderProfileRequest, GetProviderRefreshStatusRequest, - GetProviderRefreshStatusResponse, GetProviderRequest, GetSandboxConfigRequest, - GetSandboxConfigResponse, GetSandboxLogsRequest, GetSandboxLogsResponse, - GetSandboxPolicyStatusRequest, GetSandboxPolicyStatusResponse, + ExecSandboxInput, ExecSandboxRequest, ExposeServiceRequest, ExtensionKind, + FinalizeMainProcessExitRequest, FinalizeMainProcessExitResponse, GatewayMessage, + GetCurrentUserRequest, GetCurrentUserResponse, GetDraftHistoryRequest, GetDraftHistoryResponse, + GetDraftPolicyRequest, GetDraftPolicyResponse, GetGatewayConfigRequest, + GetGatewayConfigResponse, GetGatewayInfoRequest, GetGatewayInfoResponse, + GetProviderProfileRequest, GetProviderRefreshStatusRequest, GetProviderRefreshStatusResponse, + GetProviderRequest, GetSandboxConfigRequest, GetSandboxConfigResponse, GetSandboxLogsRequest, + GetSandboxLogsResponse, GetSandboxPolicyStatusRequest, GetSandboxPolicyStatusResponse, GetSandboxProviderEnvironmentRequest, GetSandboxProviderEnvironmentResponse, GetSandboxProviderStatusRequest, GetSandboxProviderStatusResponse, GetSandboxRequest, GetSandboxTemplateRequest, GetServiceRequest, GetWorkspaceRequest, GetWorkspaceResponse, @@ -49,20 +50,21 @@ use openshell_core::proto::{ ListSandboxProvidersResponse, ListSandboxTemplatesRequest, ListSandboxTemplatesResponse, ListSandboxesRequest, ListSandboxesResponse, ListServicesRequest, ListServicesResponse, ListWorkspaceMembersRequest, ListWorkspaceMembersResponse, ListWorkspacesRequest, - ListWorkspacesResponse, MemoryResourceCapabilities, ProviderProfileResponse, ProviderResponse, - PushSandboxLogsRequest, PushSandboxLogsResponse, RefreshSandboxTokenRequest, - RefreshSandboxTokenResponse, RejectDraftChunkRequest, RejectDraftChunkResponse, RelayFrame, - RemoveWorkspaceMemberRequest, RemoveWorkspaceMemberResponse, ReportEndpointStatusRequest, - ReportEndpointStatusResponse, ReportMainProcessExitRequest, ReportMainProcessExitResponse, - ReportPolicyStatusRequest, ReportPolicyStatusResponse, ReportProviderReadinessRequest, - ReportProviderReadinessResponse, ResourceCapabilities, RevokeSshSessionRequest, - RevokeSshSessionResponse, RotateProviderCredentialRequest, RotateProviderCredentialResponse, - SandboxResponse, SandboxTemplateResponse, ServiceEndpointResponse, ServiceStatus, - StartSandboxRequest, StopSandboxRequest, SubmitPolicyAnalysisRequest, - SubmitPolicyAnalysisResponse, SupervisorMessage, TcpForwardFrame, UndoDraftChunkRequest, - UndoDraftChunkResponse, UpdateConfigRequest, UpdateConfigResponse, - UpdateProviderProfilesRequest, UpdateProviderProfilesResponse, UpdateProviderRequest, - WatchSandboxRequest, open_shell_server::OpenShell, + ListWorkspacesResponse, MemoryResourceCapabilities, NegotiatedExtensionInfo, + ProviderProfileResponse, ProviderResponse, PushSandboxLogsRequest, PushSandboxLogsResponse, + RefreshSandboxTokenRequest, RefreshSandboxTokenResponse, RejectDraftChunkRequest, + RejectDraftChunkResponse, RelayFrame, RemoveWorkspaceMemberRequest, + RemoveWorkspaceMemberResponse, ReportEndpointStatusRequest, ReportEndpointStatusResponse, + ReportMainProcessExitRequest, ReportMainProcessExitResponse, ReportPolicyStatusRequest, + ReportPolicyStatusResponse, ReportProviderReadinessRequest, ReportProviderReadinessResponse, + ResourceCapabilities, RevokeSshSessionRequest, RevokeSshSessionResponse, + RotateProviderCredentialRequest, RotateProviderCredentialResponse, SandboxResponse, + SandboxTemplateResponse, ServiceEndpointResponse, ServiceStatus, StartSandboxRequest, + StopSandboxRequest, SubmitPolicyAnalysisRequest, SubmitPolicyAnalysisResponse, + SupervisorMessage, TcpForwardFrame, UndoDraftChunkRequest, UndoDraftChunkResponse, + UpdateConfigRequest, UpdateConfigResponse, UpdateProviderProfilesRequest, + UpdateProviderProfilesResponse, UpdateProviderRequest, WatchSandboxRequest, + open_shell_server::OpenShell, }; use serde::{Deserialize, Serialize}; use std::collections::BTreeMap; @@ -239,6 +241,28 @@ impl OpenShell for OpenShellService { &self, _request: Request, ) -> Result, Status> { + let mut negotiated_extensions = self + .state + .compute + .driver_info_snapshots() + .iter() + .map(|driver| driver.negotiated_extension.clone()) + .collect::>(); + negotiated_extensions.extend_from_slice(self.state.credentials.negotiated_extensions()); + negotiated_extensions + .extend_from_slice(self.state.middleware_registry.negotiated_extensions()); + if let Some(interceptors) = self.state.gateway_interceptors.as_ref() { + negotiated_extensions.extend_from_slice(interceptors.negotiated_extensions()); + } + negotiated_extensions.sort_by(|left, right| { + left.family + .cmp(&right.family) + .then_with(|| left.configured_name.cmp(&right.configured_name)) + }); + let extensions = negotiated_extensions + .iter() + .map(public_extension_info) + .collect(); let compute_drivers = self .state .compute @@ -261,6 +285,7 @@ impl OpenShell for OpenShellService { status: ServiceStatus::Healthy.into(), gateway_version: openshell_core::VERSION.to_string(), compute_drivers, + extensions, })) } @@ -818,6 +843,25 @@ impl OpenShell for OpenShellService { } } +fn public_extension_info(extension: &NegotiatedExtension) -> NegotiatedExtensionInfo { + let kind = match extension.family { + ExtensionFamily::Compute => ExtensionKind::ComputeDriver, + ExtensionFamily::Credentials => ExtensionKind::CredentialDriver, + ExtensionFamily::GatewayInterceptor => ExtensionKind::GatewayInterceptor, + ExtensionFamily::SupervisorMiddleware => ExtensionKind::SupervisorMiddleware, + }; + NegotiatedExtensionInfo { + kind: kind.into(), + configured_name: extension.configured_name.clone(), + implementation_name: extension.implementation_name.clone(), + implementation_version: extension.implementation_version.clone(), + protocol_major: extension.protocol_major, + protocol_minor: extension.protocol_minor, + supported_capabilities: extension.supported_capabilities.clone(), + required_capabilities: extension.required_capabilities.clone(), + } +} + fn public_resource_capabilities( resources: openshell_core::proto::compute::v1::ResourceCapabilities, ) -> ResourceCapabilities { @@ -992,4 +1036,26 @@ mod tests { let absent: Option = None; assert!(absent.map(public_resource_capabilities).is_none()); } + + #[test] + fn public_extension_snapshot_contains_only_negotiated_metadata() { + let negotiated = NegotiatedExtension { + family: ExtensionFamily::Credentials, + configured_name: "vault".to_string(), + implementation_name: "openshell/vault".to_string(), + implementation_version: "1.2.3".to_string(), + protocol_major: 1, + protocol_minor: 2, + supported_capabilities: vec!["openshell.credentials.contract".to_string()], + required_capabilities: vec!["openshell.credentials.contract".to_string()], + }; + + let public = public_extension_info(&negotiated); + + assert_eq!(public.kind, i32::from(ExtensionKind::CredentialDriver)); + assert_eq!(public.configured_name, "vault"); + assert_eq!(public.implementation_name, "openshell/vault"); + assert_eq!(public.protocol_major, 1); + assert_eq!(public.protocol_minor, 2); + } } diff --git a/crates/openshell-server/src/multiplex.rs b/crates/openshell-server/src/multiplex.rs index ac31017880..976e6b8a48 100644 --- a/crates/openshell-server/src/multiplex.rs +++ b/crates/openshell-server/src/multiplex.rs @@ -1546,6 +1546,12 @@ mod tests { }], provider_profiles: false, expected_audience: String::new(), + extension: Some(openshell_core::extension_protocol::extension_metadata( + openshell_core::extension_protocol::ExtensionFamily::GatewayInterceptor, + "openshell/post-commit-test", + "test", + [], + )), })) } diff --git a/crates/openshell-server/src/provider_profile_sources.rs b/crates/openshell-server/src/provider_profile_sources.rs index 819d642b1e..50b76ac07e 100644 --- a/crates/openshell-server/src/provider_profile_sources.rs +++ b/crates/openshell-server/src/provider_profile_sources.rs @@ -907,6 +907,12 @@ mod tests { Ok(Response::new(InterceptorManifest { name: "mock-profile-source".to_string(), provider_profiles: self.advertises_profiles, + extension: Some(openshell_core::extension_protocol::extension_metadata( + openshell_core::extension_protocol::ExtensionFamily::GatewayInterceptor, + "openshell/mock-profile-source", + "test", + [], + )), ..InterceptorManifest::default() })) } diff --git a/crates/openshell-server/src/storage_proto.rs b/crates/openshell-server/src/storage_proto.rs index 32250b5c77..246fd19748 100644 --- a/crates/openshell-server/src/storage_proto.rs +++ b/crates/openshell-server/src/storage_proto.rs @@ -118,7 +118,7 @@ mod tests { const STORAGE_V1_SCHEMA_SHA256: &str = "d68401809d8cea445c35233ef32412bbd041cb2ac5acaf368a0d0bf74d2ddf17"; const PUBLIC_RPC_SCHEMA_SHA256: &str = - "418130a28d1a5398d3d7f73f11b7f025d027c70f215be320dfe8e58371769f83"; + "558742ab7ac41b6914a6d0c11e341c2b8654018ce3ea2e68502e733554003bf5"; const DURABLE_SCHEMA_SHA256: &str = "557ca283c55fd46b213d5573b950ba8604cc3f4b31bad3e433eb9c5f9975138d"; const PUBLIC_DURABLE_OVERLAP_SHA256: &str = @@ -570,7 +570,7 @@ mod tests { overlap_hash.as_str(), ), ( - (294, 20), + (295, 21), (90, 15), (78, 15), PUBLIC_RPC_SCHEMA_SHA256, diff --git a/crates/openshell-server/src/test_support.rs b/crates/openshell-server/src/test_support.rs index aa5d86b798..d1c6c14f47 100644 --- a/crates/openshell-server/src/test_support.rs +++ b/crates/openshell-server/src/test_support.rs @@ -159,6 +159,12 @@ impl FakeComputeDriver { resource_capabilities: None, rootfs_tar_staging_dir: String::new(), rootfs_tar_max_bytes: 0, + extension: Some(openshell_core::extension_protocol::extension_metadata( + openshell_core::extension_protocol::ExtensionFamily::Compute, + "openshell/fake-compute-driver", + "test", + [], + )), }, gateway_listener_requirements: Vec::new(), gateway_listener_requirements_supported: true, diff --git a/crates/openshell-supervisor-middleware-builtins/src/lib.rs b/crates/openshell-supervisor-middleware-builtins/src/lib.rs index f87afafc3c..cf2e28de0e 100644 --- a/crates/openshell-supervisor-middleware-builtins/src/lib.rs +++ b/crates/openshell-supervisor-middleware-builtins/src/lib.rs @@ -193,6 +193,12 @@ impl InProcessMiddleware for BuiltinMiddlewareService { service_version: env!("CARGO_PKG_VERSION").into(), bindings: regex::describe(), expected_audience: String::new(), + extension: Some(openshell_core::extension_protocol::extension_metadata( + openshell_core::extension_protocol::ExtensionFamily::SupervisorMiddleware, + "openshell/regex", + openshell_core::VERSION, + [], + )), } } diff --git a/crates/openshell-supervisor-middleware/src/lib.rs b/crates/openshell-supervisor-middleware/src/lib.rs index d9926678c4..11caf6cbdd 100644 --- a/crates/openshell-supervisor-middleware/src/lib.rs +++ b/crates/openshell-supervisor-middleware/src/lib.rs @@ -30,12 +30,15 @@ use std::time::Duration; use miette::{Result, miette}; use prost::Message; +use openshell_core::extension_protocol::{ + ExtensionFamily, NegotiatedExtension, gateway_metadata, negotiate, +}; use openshell_core::proto::middleware::v1::supervisor_middleware_server::SupervisorMiddleware; use openshell_core::proto::{ Decision, Finding, HeaderMutation, HttpHeader, HttpRequestEvaluation, HttpRequestTarget, - MiddlewareBinding, MiddlewareManifest, NetworkMiddlewareConfig, RequestContext, SandboxPolicy, - SupervisorMiddlewareOperation, SupervisorMiddlewarePhase, SupervisorMiddlewareService, - ValidateConfigRequest, ValidateConfigResponse, + MiddlewareBinding, MiddlewareDescribeRequest, MiddlewareManifest, NetworkMiddlewareConfig, + RequestContext, SandboxPolicy, SupervisorMiddlewareOperation, SupervisorMiddlewarePhase, + SupervisorMiddlewareService, ValidateConfigRequest, ValidateConfigResponse, }; use tokio::sync::{OnceCell, OwnedSemaphorePermit, Semaphore}; use tonic::{Request, Response as TonicResponse, Status as TonicStatus}; @@ -55,7 +58,7 @@ struct GeneratedMiddlewareEndpoint { impl SupervisorMiddlewareEndpoint for GeneratedMiddlewareEndpoint { async fn describe( &self, - request: Request<()>, + request: Request, ) -> std::result::Result, TonicStatus> { self.service.describe(request).await } @@ -89,7 +92,9 @@ impl SupervisorMiddlewareEndpoint for GeneratedMiddlewareEndpoint { impl InProcessMiddleware for GeneratedMiddlewareEndpoint { async fn describe(&self) -> MiddlewareManifest { self.service - .describe(Request::new(())) + .describe(Request::new(MiddlewareDescribeRequest { + gateway: Some(gateway_metadata(ExtensionFamily::SupervisorMiddleware)), + })) .await .expect("generated in-process Describe failed") .into_inner() @@ -145,7 +150,9 @@ struct EndpointInProcessAdapter { impl InProcessMiddleware for EndpointInProcessAdapter { async fn describe(&self) -> MiddlewareManifest { self.endpoint - .describe(Request::new(())) + .describe(Request::new(MiddlewareDescribeRequest { + gateway: Some(gateway_metadata(ExtensionFamily::SupervisorMiddleware)), + })) .await .expect("in-process endpoint Describe failed") .into_inner() @@ -723,6 +730,7 @@ pub struct MiddlewareRegistry { services: Arc>>, registered_services: Arc>, middleware_names: Arc>, + negotiated_extensions: Arc>, work_admission: Arc, work_admission_waiters: Arc, session_admission: Arc, @@ -758,6 +766,7 @@ impl Default for MiddlewareRegistry { services: Arc::new(Vec::new()), registered_services: Arc::new(Vec::new()), middleware_names: Arc::new(HashSet::new()), + negotiated_extensions: Arc::new(Vec::new()), work_admission: Arc::new(Semaphore::new(MAX_CONCURRENT_MIDDLEWARE_WORK)), work_admission_waiters: Arc::new(Semaphore::new(MAX_QUEUED_MIDDLEWARE_WORK)), session_admission: Arc::new(Semaphore::new(MAX_CONCURRENT_MIDDLEWARE_SESSIONS)), @@ -1121,6 +1130,8 @@ impl MiddlewareRegistry { let mut services = Vec::with_capacity(in_process_services.len() + registrations.len()); let mut registered_services = Vec::with_capacity(registrations.len()); let mut middleware_names = HashSet::new(); + let mut negotiated_extensions = Vec::new(); + let gateway = gateway_metadata(ExtensionFamily::SupervisorMiddleware); for service in in_process_services { let service = MiddlewareDispatch::InProcess(service); @@ -1151,6 +1162,15 @@ impl MiddlewareRegistry { )); } validate_manifest_bindings(&source, &manifest, None)?; + negotiated_extensions.push( + negotiate( + ExtensionFamily::SupervisorMiddleware, + &manifest.name, + &gateway, + manifest.extension.clone(), + ) + .map_err(|error| miette!(error.to_string()))?, + ); let attachment_name = manifest.name.clone(); let manifest_cell = OnceCell::new(); manifest_cell @@ -1223,6 +1243,15 @@ impl MiddlewareRegistry { operator_max_payload_bytes, authenticated, )?; + negotiated_extensions.push( + negotiate( + ExtensionFamily::SupervisorMiddleware, + ®istration.name, + &gateway, + manifest.extension.clone(), + ) + .map_err(|error| miette!(error.to_string()))?, + ); let manifest_cell = OnceCell::new(); manifest_cell .set(manifest) @@ -1242,6 +1271,7 @@ impl MiddlewareRegistry { services: Arc::new(services), registered_services: Arc::new(registered_services), middleware_names: Arc::new(middleware_names), + negotiated_extensions: Arc::new(negotiated_extensions), work_admission: Arc::new(Semaphore::new(MAX_CONCURRENT_MIDDLEWARE_WORK)), work_admission_waiters: Arc::new(Semaphore::new(MAX_QUEUED_MIDDLEWARE_WORK)), session_admission: Arc::new(Semaphore::new(MAX_CONCURRENT_MIDDLEWARE_SESSIONS)), @@ -1304,6 +1334,11 @@ impl MiddlewareRegistry { .map(|service| service.registration.clone()) .collect() } + + #[must_use] + pub fn negotiated_extensions(&self) -> &[NegotiatedExtension] { + &self.negotiated_extensions + } } impl Default for ChainRunner { @@ -1338,6 +1373,7 @@ impl ChainRunner { })]), registered_services: Arc::new(Vec::new()), middleware_names: Arc::new(HashSet::new()), + negotiated_extensions: Arc::new(Vec::new()), work_admission: Arc::new(Semaphore::new(MAX_CONCURRENT_MIDDLEWARE_WORK)), work_admission_waiters: Arc::new(Semaphore::new(MAX_QUEUED_MIDDLEWARE_WORK)), session_admission: Arc::new(Semaphore::new(MAX_CONCURRENT_MIDDLEWARE_SESSIONS)), @@ -2181,6 +2217,7 @@ mod tests { struct BorrowedRecordingService { manifest_name: String, received: std::sync::Mutex>, + advertise_protocol: bool, } #[tonic::async_trait] @@ -2196,6 +2233,14 @@ mod tests { request_timeout: None, }], expected_audience: String::new(), + extension: self.advertise_protocol.then(|| { + openshell_core::extension_protocol::extension_metadata( + ExtensionFamily::SupervisorMiddleware, + "openshell/test-middleware", + "test", + [], + ) + }), } } @@ -2240,6 +2285,7 @@ mod tests { let service = Arc::new(BorrowedRecordingService { manifest_name: "acme/redactor".into(), received: std::sync::Mutex::new(Vec::new()), + advertise_protocol: true, }); let runner = ChainRunner::new(service.clone()); let entries = [ @@ -2332,6 +2378,12 @@ mod tests { request_timeout: None, }], expected_audience: String::new(), + extension: Some(openshell_core::extension_protocol::extension_metadata( + ExtensionFamily::SupervisorMiddleware, + "openshell/test-middleware", + "test", + [], + )), } } @@ -2423,6 +2475,12 @@ mod tests { request_timeout: Some(proto_duration("10ms")), }], expected_audience: String::new(), + extension: Some(openshell_core::extension_protocol::extension_metadata( + ExtensionFamily::SupervisorMiddleware, + "openshell/test-middleware", + "test", + [], + )), } } @@ -2632,10 +2690,12 @@ mod tests { let first: Arc = Arc::new(BorrowedRecordingService { manifest_name: "openshell/test".into(), received: std::sync::Mutex::new(Vec::new()), + advertise_protocol: true, }); let second: Arc = Arc::new(BorrowedRecordingService { manifest_name: "openshell/test".into(), received: std::sync::Mutex::new(Vec::new()), + advertise_protocol: true, }); let error = MiddlewareRegistry::connect_services(vec![first, second], Vec::new()) @@ -2648,6 +2708,25 @@ mod tests { ); } + #[tokio::test] + async fn in_process_service_without_protocol_metadata_is_rejected() { + let service: Arc = Arc::new(BorrowedRecordingService { + manifest_name: "openshell/legacy".into(), + received: std::sync::Mutex::new(Vec::new()), + advertise_protocol: false, + }); + + let error = MiddlewareRegistry::connect_services(vec![service], Vec::new()) + .await + .expect_err("legacy middleware must fail negotiation"); + + assert!( + error + .to_string() + .contains("did not provide protocol metadata") + ); + } + /// A mock middleware that returns a fixed, caller-supplied result for every /// evaluation. Used to exercise chain behavior the built-in cannot produce /// (explicit deny, metadata, findings, unsafe header mutations). @@ -2671,7 +2750,7 @@ mod tests { async fn describe( &self, - _request: Request<()>, + _request: Request, ) -> std::result::Result, tonic::Status> { Ok(tonic::Response::new(MiddlewareManifest { name: self.manifest_name.clone(), @@ -2683,6 +2762,12 @@ mod tests { request_timeout: None, }], expected_audience: String::new(), + extension: Some(openshell_core::extension_protocol::extension_metadata( + ExtensionFamily::SupervisorMiddleware, + "openshell/test-middleware", + "test", + [], + )), })) } @@ -2726,7 +2811,7 @@ mod tests { async fn describe( &self, - _request: Request<()>, + _request: Request, ) -> std::result::Result, tonic::Status> { Ok(tonic::Response::new(MiddlewareManifest { name: "test/slow".into(), @@ -2738,6 +2823,12 @@ mod tests { request_timeout: self.binding_timeout, }], expected_audience: String::new(), + extension: Some(openshell_core::extension_protocol::extension_metadata( + ExtensionFamily::SupervisorMiddleware, + "openshell/test-middleware", + "test", + [], + )), })) } @@ -2785,7 +2876,7 @@ mod tests { async fn describe( &self, - _request: Request<()>, + _request: Request, ) -> std::result::Result, tonic::Status> { Ok(tonic::Response::new(MiddlewareManifest { name: "test/two-stage".into(), @@ -2797,6 +2888,12 @@ mod tests { request_timeout: None, }], expected_audience: String::new(), + extension: Some(openshell_core::extension_protocol::extension_metadata( + ExtensionFamily::SupervisorMiddleware, + "openshell/test-middleware", + "test", + [], + )), })) } @@ -3055,7 +3152,7 @@ mod tests { async fn describe( &self, - _request: Request<()>, + _request: Request, ) -> std::result::Result, tonic::Status> { Ok(tonic::Response::new(MiddlewareManifest { name: "test/recorder".into(), @@ -3067,6 +3164,12 @@ mod tests { request_timeout: None, }], expected_audience: String::new(), + extension: Some(openshell_core::extension_protocol::extension_metadata( + ExtensionFamily::SupervisorMiddleware, + "openshell/test-middleware", + "test", + [], + )), })) } @@ -3123,6 +3226,12 @@ mod tests { request_timeout: None, }], expected_audience: String::new(), + extension: Some(openshell_core::extension_protocol::extension_metadata( + ExtensionFamily::SupervisorMiddleware, + "openshell/test-middleware", + "test", + [], + )), } } @@ -3170,7 +3279,7 @@ mod tests { async fn describe( &self, - _request: Request<()>, + _request: Request, ) -> std::result::Result, tonic::Status> { Ok(tonic::Response::new(MiddlewareManifest { name: "test/header-chain".into(), @@ -3182,6 +3291,12 @@ mod tests { request_timeout: None, }], expected_audience: String::new(), + extension: Some(openshell_core::extension_protocol::extension_metadata( + ExtensionFamily::SupervisorMiddleware, + "openshell/test-middleware", + "test", + [], + )), })) } @@ -3450,7 +3565,9 @@ mod tests { .expect("built-in manifest cache"); let manifest = service - .describe(Request::new(())) + .describe(Request::new(MiddlewareDescribeRequest { + gateway: Some(gateway_metadata(ExtensionFamily::SupervisorMiddleware)), + })) .await .expect("describe test service") .into_inner(); @@ -3484,6 +3601,7 @@ mod tests { ]), registered_services: Arc::new(vec![RegisteredMiddlewareService { registration }]), middleware_names: Arc::new(HashSet::from([builtin_name, registration_name])), + negotiated_extensions: Arc::new(Vec::new()), work_admission: Arc::new(Semaphore::new(MAX_CONCURRENT_MIDDLEWARE_WORK)), work_admission_waiters: Arc::new(Semaphore::new(MAX_QUEUED_MIDDLEWARE_WORK)), session_admission: Arc::new(Semaphore::new(MAX_CONCURRENT_MIDDLEWARE_SESSIONS)), @@ -3679,6 +3797,12 @@ mod tests { request_timeout: None, }], expected_audience: String::new(), + extension: Some(openshell_core::extension_protocol::extension_metadata( + ExtensionFamily::SupervisorMiddleware, + "openshell/test-middleware", + "test", + [], + )), }; let error = validate_external_manifest(®istration, &manifest, 4097, false) .expect_err("operator limit must fit capability"); @@ -3706,6 +3830,12 @@ mod tests { request_timeout: None, }], expected_audience: String::new(), + extension: Some(openshell_core::extension_protocol::extension_metadata( + ExtensionFamily::SupervisorMiddleware, + "openshell/test-middleware", + "test", + [], + )), }; let error = validate_external_manifest(®istration, &manifest, 4096, false) .expect_err("extreme advertised payload limit must be rejected"); @@ -3726,6 +3856,12 @@ mod tests { service_version: "test".into(), bindings: vec![binding(), binding()], expected_audience: String::new(), + extension: Some(openshell_core::extension_protocol::extension_metadata( + ExtensionFamily::SupervisorMiddleware, + "openshell/test-middleware", + "test", + [], + )), }; let error = validate_external_manifest(®istration, &manifest, 4096, false) @@ -3753,6 +3889,12 @@ mod tests { }), }], expected_audience: String::new(), + extension: Some(openshell_core::extension_protocol::extension_metadata( + ExtensionFamily::SupervisorMiddleware, + "openshell/test-middleware", + "test", + [], + )), }; validate_external_manifest(®istration, &manifest, 4096, false) @@ -3772,6 +3914,12 @@ mod tests { service_version: "test".into(), bindings: vec![binding(SupervisorMiddlewarePhase::PreCredentials)], expected_audience: String::new(), + extension: Some(openshell_core::extension_protocol::extension_metadata( + ExtensionFamily::SupervisorMiddleware, + "openshell/test-middleware", + "test", + [], + )), }; validate_manifest_bindings("test WebSocket service", &manifest, None) .expect("forward WebSocket binding is supported"); @@ -3795,6 +3943,12 @@ mod tests { request_timeout: None, }], expected_audience: String::new(), + extension: Some(openshell_core::extension_protocol::extension_metadata( + ExtensionFamily::SupervisorMiddleware, + "openshell/test-middleware", + "test", + [], + )), }; let error = validate_external_manifest(®istration, &manifest, 0, false) @@ -3819,6 +3973,12 @@ mod tests { request_timeout: None, }], expected_audience: String::new(), + extension: Some(openshell_core::extension_protocol::extension_metadata( + ExtensionFamily::SupervisorMiddleware, + "openshell/test-middleware", + "test", + [], + )), }; let error = validate_external_manifest(®istration, &manifest, 4097, false) @@ -3893,6 +4053,12 @@ mod tests { request_timeout: Some(proto_duration(timeout)), }], expected_audience: String::new(), + extension: Some(openshell_core::extension_protocol::extension_metadata( + ExtensionFamily::SupervisorMiddleware, + "openshell/test-middleware", + "test", + [], + )), }; let error = validate_external_manifest(®istration, &manifest, 4096, false) .expect_err("out-of-bounds binding timeout must be rejected"); @@ -4950,7 +5116,7 @@ mod tests { async fn describe( &self, - _request: Request<()>, + _request: Request, ) -> std::result::Result, tonic::Status> { self.describe_calls .fetch_add(1, std::sync::atomic::Ordering::SeqCst); @@ -4971,6 +5137,12 @@ mod tests { }), }], expected_audience: String::new(), + extension: Some(openshell_core::extension_protocol::extension_metadata( + ExtensionFamily::SupervisorMiddleware, + "openshell/test-middleware", + "test", + [], + )), })) } @@ -5011,7 +5183,7 @@ mod tests { impl SupervisorMiddlewareEndpoint for OpenAiRedactionService { async fn describe( &self, - request: Request<()>, + request: Request, ) -> std::result::Result, tonic::Status> { SupervisorMiddleware::describe(self, request).await } diff --git a/crates/openshell-supervisor-middleware/src/remote.rs b/crates/openshell-supervisor-middleware/src/remote.rs index 80049b69dc..78f27b8cf7 100644 --- a/crates/openshell-supervisor-middleware/src/remote.rs +++ b/crates/openshell-supervisor-middleware/src/remote.rs @@ -9,8 +9,8 @@ use openshell_core::middleware::{ use openshell_core::proto::middleware::v1::http_response_pre_return_client::HttpResponsePreReturnClient; use openshell_core::proto::middleware::v1::supervisor_middleware_client::SupervisorMiddlewareClient; use openshell_core::proto::{ - HttpRequestEvaluation, HttpRequestResult, HttpResponseEvent, MiddlewareManifest, - ValidateConfigRequest, ValidateConfigResponse, WebSocketSessionEvent, + HttpRequestEvaluation, HttpRequestResult, HttpResponseEvent, MiddlewareDescribeRequest, + MiddlewareManifest, ValidateConfigRequest, ValidateConfigResponse, WebSocketSessionEvent, }; use openshell_extension_core::{ BearerTokenInterceptor, BearerTokenSlot, ExtensionChannelConfig, ExtensionServerTrust, @@ -61,7 +61,13 @@ impl GrpcMiddlewareService { /// Forward a manifest request through the protobuf service contract. pub async fn describe(&self) -> std::result::Result, Status> { - self.service.describe(Request::new(())).await + self.service + .describe(Request::new(MiddlewareDescribeRequest { + gateway: Some(openshell_core::extension_protocol::gateway_metadata( + openshell_core::extension_protocol::ExtensionFamily::SupervisorMiddleware, + )), + })) + .await } /// Materialize the owned configuration request required by gRPC. @@ -158,7 +164,7 @@ impl RemoteMiddlewareService { impl SupervisorMiddlewareEndpoint for RemoteMiddlewareService { async fn describe( &self, - request: Request<()>, + request: Request, ) -> std::result::Result, Status> { let mut client = self.client.clone(); client.describe(request).await diff --git a/crates/openshell-supervisor-network/src/l7/relay.rs b/crates/openshell-supervisor-network/src/l7/relay.rs index 2842562d90..f7ba1941fe 100644 --- a/crates/openshell-supervisor-network/src/l7/relay.rs +++ b/crates/openshell-supervisor-network/src/l7/relay.rs @@ -4210,7 +4210,7 @@ network_policies: async fn describe( &self, - _request: tonic::Request<()>, + _request: tonic::Request, ) -> std::result::Result< tonic::Response, tonic::Status, @@ -4233,6 +4233,12 @@ network_policies: }), }], expected_audience: String::new(), + extension: Some(openshell_core::extension_protocol::extension_metadata( + openshell_core::extension_protocol::ExtensionFamily::SupervisorMiddleware, + "openshell/test-middleware", + "test", + [], + )), }, )) } @@ -6046,6 +6052,12 @@ network_policies: request_timeout: None, }], expected_audience: String::new(), + extension: Some(openshell_core::extension_protocol::extension_metadata( + openshell_core::extension_protocol::ExtensionFamily::SupervisorMiddleware, + "openshell/test-middleware", + "test", + [], + )), } } @@ -6193,6 +6205,12 @@ network_policies: request_timeout: None, }], expected_audience: String::new(), + extension: Some(openshell_core::extension_protocol::extension_metadata( + openshell_core::extension_protocol::ExtensionFamily::SupervisorMiddleware, + "openshell/test-middleware", + "test", + [], + )), } } @@ -6664,6 +6682,12 @@ network_policies: request_timeout: None, }], expected_audience: String::new(), + extension: Some(openshell_core::extension_protocol::extension_metadata( + openshell_core::extension_protocol::ExtensionFamily::SupervisorMiddleware, + "openshell/test-middleware", + "test", + [], + )), } } diff --git a/crates/openshell-supervisor-network/src/l7/websocket.rs b/crates/openshell-supervisor-network/src/l7/websocket.rs index 77ed825088..f2ea281a81 100644 --- a/crates/openshell-supervisor-network/src/l7/websocket.rs +++ b/crates/openshell-supervisor-network/src/l7/websocket.rs @@ -3550,7 +3550,7 @@ network_policies: async fn describe( &self, - _request: Request<()>, + _request: Request, ) -> std::result::Result, Status> { use openshell_core::proto::{ @@ -3571,6 +3571,12 @@ network_policies: }), }], expected_audience: String::new(), + extension: Some(openshell_core::extension_protocol::extension_metadata( + openshell_core::extension_protocol::ExtensionFamily::SupervisorMiddleware, + "openshell/test-middleware", + "test", + [], + )), })) } diff --git a/crates/openshell-supervisor-network/src/proxy.rs b/crates/openshell-supervisor-network/src/proxy.rs index 02206063a2..56d7b62ac4 100644 --- a/crates/openshell-supervisor-network/src/proxy.rs +++ b/crates/openshell-supervisor-network/src/proxy.rs @@ -6668,7 +6668,7 @@ process: impl openshell_core::middleware::SupervisorMiddlewareEndpoint for DenyWebSocketPreflight { async fn describe( &self, - _request: tonic::Request<()>, + _request: tonic::Request, ) -> std::result::Result< tonic::Response, tonic::Status, @@ -6690,6 +6690,12 @@ process: }), }], expected_audience: String::new(), + extension: Some(openshell_core::extension_protocol::extension_metadata( + openshell_core::extension_protocol::ExtensionFamily::SupervisorMiddleware, + "openshell/test-middleware", + "test", + [], + )), }, )) } @@ -6886,6 +6892,12 @@ process: request_timeout: None, }], expected_audience: String::new(), + extension: Some(openshell_core::extension_protocol::extension_metadata( + openshell_core::extension_protocol::ExtensionFamily::SupervisorMiddleware, + "openshell/test-middleware", + "test", + [], + )), } } diff --git a/docs/extensibility/extension-negotiation.mdx b/docs/extensibility/extension-negotiation.mdx new file mode 100644 index 0000000000..7f2cba3904 --- /dev/null +++ b/docs/extensibility/extension-negotiation.mdx @@ -0,0 +1,69 @@ +--- +# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +title: "Extension Protocol Negotiation" +sidebar-title: "Protocol Negotiation" +description: "Implement version and capability negotiation for OpenShell extensions." +keywords: "OpenShell Extensions, Protocol Version, Capabilities, Version Skew, Migration" +--- + +OpenShell negotiates a common metadata envelope before it uses a compute driver, credential driver, gateway interceptor, or supervisor middleware service. Family-specific fields remain in each protocol; the common envelope determines whether the peers can safely interpret them. + +## Exchange Peer Metadata + +Both peers send `openshell.extension.v1.PeerMetadata` during the family's startup RPC. The gateway sends its metadata in `GetCapabilities` or `Describe`; the extension returns its metadata in the capability response or manifest. + +Set these fields: + +- `protocol_version` identifies the extension-family contract. OpenShell starts each family at `1.0`. +- `implementation_name` identifies the implementation, such as `example/acme-compute`. +- `implementation_version` identifies the extension build. Do not put the Docker, Kubernetes, Vault, or another backend's version here. +- `supported_capabilities` lists optional behavior the peer understands. +- `required_capabilities` lists behavior the opposite peer must support. + +Capability identifiers must start with `openshell.`, contain at least three lowercase dot-separated segments, and use only lowercase ASCII letters, digits, and hyphens within each segment. Each family requires its base contract capability: + +| Family | Base capability | +| --- | --- | +| Compute driver | `openshell.compute.contract` | +| Credential driver | `openshell.credentials.contract` | +| Gateway interceptor | `openshell.gateway-interceptor.contract` | +| Supervisor middleware | `openshell.supervisor-middleware.contract` | + +Do not repeat a capability. OpenShell rejects empty, malformed, duplicate, or oversized metadata instead of normalizing ambiguous input. + +## Version-Skew Policy + +OpenShell applies this compatibility matrix at startup: + +| Peer relationship | Result | +| --- | --- | +| Same major and same minor | Accepted when both requirement sets are satisfied. | +| Same major and different minor | Accepted when both requirement sets are satisfied. Unknown optional capabilities are retained for discovery and otherwise ignored. | +| Different major | Rejected with both protocol versions in the error. | +| Missing peer metadata or protocol version | Rejected with upgrade guidance. | +| Either peer lacks a capability required by the other | Rejected with the missing capability names. | + +Minor releases must keep existing fields and behavior compatible. Add a capability when a peer must detect an optional behavior. Increment the protocol major when requirements cannot express a safe additive transition. + +## Preserve Family-Specific Capabilities + +Keep typed family data beside the common envelope. Compute resource capabilities, credential-driver feature flags, interceptor bindings, and middleware operation/phase bindings remain authoritative for their domains. Do not flatten typed values into capability strings. + +Built-in and external extensions follow the same validator. A built-in cannot bypass protocol version or requirement checks merely because it runs in the gateway process. + +## Migrate an Extension + +1. Regenerate bindings from the current OpenShell protobuf files. Supervisor middleware authors must update `Describe` from `google.protobuf.Empty` to `MiddlewareDescribeRequest`. +2. Read and validate the gateway metadata supplied in the startup request. +3. Return protocol `1.0`, a stable implementation name, the extension build version, the family base capability, and any additional supported or required capabilities. +4. Deploy the upgraded extension before upgrading the gateway. A gateway with mandatory negotiation rejects an older extension that omits metadata. +5. Run mixed-minor tests with required capabilities present and absent. Verify that a major mismatch and missing metadata fail before runtime traffic. + +The legacy compute and credential `driver_version` fields and middleware `service_version` field remain populated during migration. New integrations must use `PeerMetadata.implementation_version`; the legacy fields are diagnostic compatibility fields and may be removed in a future protocol major. + +## Inspect Negotiated Extensions + +Admins can run `openshell gateway info` or call protected `GetGatewayInfo`. The response contains a sorted snapshot captured at startup: family, configured name, implementation identity/version, protocol version, supported capabilities, and extension requirements. + +The snapshot excludes endpoints, audiences, bearer tokens, certificates, backend configuration, and free-form extension diagnostics. diff --git a/docs/extensibility/gateway-interceptors.mdx b/docs/extensibility/gateway-interceptors.mdx index bf9656a5ed..96484bafbb 100644 --- a/docs/extensibility/gateway-interceptors.mdx +++ b/docs/extensibility/gateway-interceptors.mdx @@ -48,6 +48,8 @@ An interceptor implements the `openshell.gateway_interceptor.v1.GatewayIntercept - `Evaluate` handles one selected operation phase. - `SnapshotProviderProfiles` optionally returns a provider profile catalog. +`DescribeRequest` carries gateway protocol metadata, and `InterceptorManifest.extension` returns the interceptor's protocol and implementation metadata. The gateway rejects missing metadata, incompatible majors, and unmet required capabilities before it accepts bindings. See [Extension Protocol Negotiation](/extensibility/extension-negotiation). + Each `InterceptorEvaluation` identifies the configured interceptor, manifest binding, public OpenShell service and method, authenticated principal, and active phase. The phase determines whether the payload contains a proposed operation, optional current state, or committed response. The interceptor returns an `InterceptorResult` with an allow or deny decision, an optional denial status and reason, JSON patches during `modify_operation`, and non-secret log annotations. diff --git a/docs/extensibility/supervisor-middleware.mdx b/docs/extensibility/supervisor-middleware.mdx index 13935436c4..d74c075078 100644 --- a/docs/extensibility/supervisor-middleware.mdx +++ b/docs/extensibility/supervisor-middleware.mdx @@ -84,6 +84,8 @@ Each binding returned by `Describe` may advertise a shorter `timeout` using the The gateway connects to every registered service and verifies its capabilities before accepting traffic. Gateway startup fails when a service is unavailable, reports an invalid capability, or exposes more than one binding for the same operation and phase. The manifest `name` is diagnostic metadata and does not need to match the operator registration name. Operator-run registration names cannot claim the reserved `openshell/` namespace. +`MiddlewareDescribeRequest` carries the caller's common protocol metadata, and `MiddlewareManifest.extension` returns the service's protocol and implementation metadata. This replaces the former empty `Describe` request. Regenerate service bindings and return protocol `1.0` plus `openshell.supervisor-middleware.contract` before upgrading the gateway. See [Extension Protocol Negotiation](/extensibility/extension-negotiation) for the skew policy and migration sequence. + Registration is static. Restart the gateway after adding, removing, or changing a service. See [Gateway Configuration](/reference/gateway-config#supervisor-middleware-services) for the complete gateway TOML context. ### Authenticate OpenShell Callers diff --git a/docs/reference/gateway-config.mdx b/docs/reference/gateway-config.mdx index 04890f8843..ce41a64a73 100644 --- a/docs/reference/gateway-config.mdx +++ b/docs/reference/gateway-config.mdx @@ -361,6 +361,8 @@ Each service implements the supervisor middleware gRPC contract and exposes bind The gateway connects to every registered service and validates `Describe` before it starts. The service must therefore be running before the gateway. Policy creation and full policy updates call `ValidateConfig`; an unavailable service or invalid middleware configuration rejects the policy before persistence. +Startup also requires compatible [extension protocol metadata](/extensibility/extension-negotiation). Upgrade operator-run services first; a new gateway rejects a service that omits peer metadata, uses another protocol major, or requires unsupported gateway capabilities. Protected `GetGatewayInfo` and `openshell gateway info` report the resulting non-secret snapshot. + `max_payload_bytes` is the shared operator limit for inspectable logical payloads across every binding exposed by the service. It caps HTTP request and response units, replacement bodies, and complete WebSocket text messages and replacements. Whole-response inspection uses it as the stage's total body limit. Streaming response inspection applies it to each unit. The value must be greater than zero, no larger than each binding's advertised `max_payload_bytes` capability, and no larger than the 4 MiB platform maximum. OpenShell rejects oversized values instead of silently clamping them. Binary WebSocket messages are not exposed to V1 middleware, so this field does not limit binary pass-through. Middleware gRPC servers should allow messages of at least 4 MiB plus 293 KiB so a maximum-size payload and its protobuf envelope fit on the transport. `timeout` is the operator-configured service-wide RPC timeout. It accepts the same compact duration syntax as gateway interceptors: an integer followed by `ms` or `s`, such as `500ms` or `2s`. Values must be between `10ms` and `30s`, inclusive. Omit the field to use the 500 ms platform default. A binding may advertise a shorter `timeout` in the `Describe` manifest, but it cannot extend the operator-configured deadline; OpenShell uses the smaller value. OpenShell validates both levels before accepting the service. The operator-configured service timeout applies to `Describe` and `ValidateConfig`. The effective binding timeout applies to HTTP request evaluation, HTTP response preflight and unit exchanges, WebSocket preflight, and each WebSocket message. Accepted streaming protocols have no connection-wide RPC deadline. @@ -375,6 +377,8 @@ See [Supervisor Middleware](/extensibility/supervisor-middleware) for selection, `[[openshell.gateway.interceptors]]` configures gateway-side interceptor services. The gateway calls each service's `Describe` RPC at startup, validates its declared OpenShell RPC bindings against the compiled service descriptor, and applies matching phases from a central gRPC middleware path. Interceptors can target only methods in the gateway's built-in allowlist of unary mutation RPCs. New RPCs are non-interceptable until they are deliberately added to that allowlist; adding one does not require handler-specific interceptor code. Request bodies are exposed as protobuf JSON objects. Fields marked secret in the protobuf schema are recursively omitted from requests and post-commit responses. Interceptors cannot patch an omitted field or a containing object. +Each interceptor must also complete [extension protocol negotiation](/extensibility/extension-negotiation) during `Describe`. Upgrade the interceptor first when moving from the legacy manifest: the gateway rejects missing metadata, incompatible protocol majors, and unmet requirements before serving requests. + HTTPS interceptor endpoints use the platform trust store by default. Set `tls_ca_cert_path` to a PEM certificate bundle for a private CA; normal TLS hostname verification still applies. `audience` sets the exact audience for gateway-minted service tokens and defaults to `urn:openshell:extension:interceptor:`. After authenticated `Describe` succeeds, the gateway treats a non-empty manifest `expected_audience` as a consistency assertion and refuses to start when it differs from the configured audience. A strict verifier may reject an incorrect audience before returning the manifest. When `gateway_jwt` is configured, network interceptors must use HTTPS and receive short-lived gateway-caller bearer credentials; local Unix sockets are also supported. Set `allow_insecure_transport = true` to keep a plaintext `http://` interceptor endpoint with no credential attached and a startup warning. ### Extension Token Verification Endpoints diff --git a/docs/reference/sandbox-compute-drivers.mdx b/docs/reference/sandbox-compute-drivers.mdx index d24ff67ef4..747b575214 100644 --- a/docs/reference/sandbox-compute-drivers.mdx +++ b/docs/reference/sandbox-compute-drivers.mdx @@ -141,6 +141,8 @@ which request forms a driver implements. It does not report live resource inventory, availability, or scheduling capacity, so a supported request can still fail when the selected runtime cannot provide the resource. +The same response includes the compute driver's negotiated extension snapshot. Protocol version and implementation version are separate: the implementation version identifies the OpenShell driver build, not the Docker daemon, Kubernetes server, or another compute backend. See [Extension Protocol Negotiation](/extensibility/extension-negotiation). + CPU and memory capabilities report whether the driver enforces a resource limit. GPU capabilities report whether the driver accepts a default GPU request and an explicit GPU count. An omitted `resource_capabilities` message, or an diff --git a/examples/governance-interceptor/src/main.rs b/examples/governance-interceptor/src/main.rs index 3636ec0570..1a9129437a 100644 --- a/examples/governance-interceptor/src/main.rs +++ b/examples/governance-interceptor/src/main.rs @@ -337,6 +337,12 @@ impl GovernanceInterceptorService { ), ], expected_audience: String::new(), + extension: Some(openshell_core::extension_protocol::extension_metadata( + openshell_core::extension_protocol::ExtensionFamily::GatewayInterceptor, + "openshell/provider-governance", + openshell_core::VERSION, + [], + )), } } diff --git a/examples/supervisor-middleware-content-guard/src/main.rs b/examples/supervisor-middleware-content-guard/src/main.rs index c6489d742a..8f4f6742bb 100644 --- a/examples/supervisor-middleware-content-guard/src/main.rs +++ b/examples/supervisor-middleware-content-guard/src/main.rs @@ -17,7 +17,7 @@ use openshell_core::proto::{ Decision, Finding, HttpRequestEvaluation, HttpRequestResult, HttpResponseBlockDelivery, HttpResponseBodyMode, HttpResponseBodyResult, HttpResponseBodyTransform, HttpResponseEvent, HttpResponseEventResult, HttpResponsePreflightInspect, HttpResponsePreflightResult, - HttpResponseTrailersResult, MiddlewareBinding, MiddlewareManifest, + HttpResponseTrailersResult, MiddlewareBinding, MiddlewareDescribeRequest, MiddlewareManifest, SupervisorMiddlewareOperation, SupervisorMiddlewarePhase, ValidateConfigRequest, ValidateConfigResponse, WebSocketMessage, WebSocketMessageResult, WebSocketPreflightAction, WebSocketPreflightDecision, WebSocketSessionEvent, WebSocketSessionEventResult, @@ -230,7 +230,7 @@ impl SupervisorMiddleware for ContentGuard { async fn describe( &self, - _request: Request<()>, + _request: Request, ) -> Result, Status> { Ok(Response::new(MiddlewareManifest { name: MANIFEST_NAME.into(), @@ -256,6 +256,12 @@ impl SupervisorMiddleware for ContentGuard { }, ], expected_audience: String::new(), + extension: Some(openshell_core::extension_protocol::extension_metadata( + openshell_core::extension_protocol::ExtensionFamily::SupervisorMiddleware, + MANIFEST_NAME, + openshell_core::VERSION, + [], + )), })) } @@ -678,10 +684,13 @@ mod tests { #[tokio::test] async fn manifest_advertises_request_response_and_websocket_bindings() { - let manifest = SupervisorMiddleware::describe(&ContentGuard, Request::new(())) - .await - .expect("describe") - .into_inner(); + let manifest = SupervisorMiddleware::describe( + &ContentGuard, + Request::new(MiddlewareDescribeRequest::default()), + ) + .await + .expect("describe") + .into_inner(); assert_eq!(manifest.bindings.len(), 3); assert_eq!( diff --git a/proto/compute_driver.proto b/proto/compute_driver.proto index 7147c7a6f6..64fc3d359a 100644 --- a/proto/compute_driver.proto +++ b/proto/compute_driver.proto @@ -7,6 +7,7 @@ package openshell.compute.v1; import "google/protobuf/struct.proto"; import "google/protobuf/timestamp.proto"; +import "extension.proto"; import "options.proto"; import "sandbox.proto"; @@ -71,7 +72,10 @@ service ComputeDriver { rpc DeleteWorkspace(DeleteWorkspaceRequest) returns (DeleteWorkspaceResponse); } -message GetCapabilitiesRequest {} +message GetCapabilitiesRequest { + // Gateway protocol metadata. Drivers must reject unmet requirements. + openshell.extension.v1.PeerMetadata gateway = 1; +} message GetCapabilitiesResponse { reserved 4, 5; @@ -79,7 +83,7 @@ message GetCapabilitiesResponse { // Human-readable driver name. string driver_name = 1; - // Driver implementation version string. + // Deprecated diagnostic compatibility field. Use extension.implementation_version. string driver_version = 2; // Default sandbox image recommended by the driver. string default_image = 3; @@ -101,6 +105,8 @@ message GetCapabilitiesResponse { // Maximum rootfs tar file size in bytes accepted by the driver. Zero means // the driver does not support rootfs tar sources. uint64 rootfs_tar_max_bytes = 11; + // Compute extension protocol metadata. Required for protocol negotiation. + openshell.extension.v1.PeerMetadata extension = 12; } message AuthenticateSandboxRequest { diff --git a/proto/credential_driver.proto b/proto/credential_driver.proto index fd7bb1b92c..6ddbd03ac0 100644 --- a/proto/credential_driver.proto +++ b/proto/credential_driver.proto @@ -7,6 +7,7 @@ package openshell.credentials.v1; import "datamodel.proto"; import "google/protobuf/timestamp.proto"; +import "extension.proto"; // Internal credential-driver contract used by the gateway. // @@ -33,12 +34,15 @@ service CredentialDriver { rpc ListCredentials(ListCredentialsRequest) returns (ListCredentialsResponse); } -message GetCredentialDriverCapabilitiesRequest {} +message GetCredentialDriverCapabilitiesRequest { + // Gateway protocol metadata. Drivers must reject unmet requirements. + openshell.extension.v1.PeerMetadata gateway = 1; +} message GetCredentialDriverCapabilitiesResponse { // Human-readable driver name. string driver_name = 1; - // Driver implementation version string. + // Deprecated diagnostic compatibility field. Use extension.implementation_version. string driver_version = 2; // Backend kind, such as "kubernetes-secrets" or "vault". string backend_kind = 3; @@ -46,6 +50,8 @@ message GetCredentialDriverCapabilitiesResponse { bool supports_list = 4; // True when ResolveCredentials may return expiration_time values. bool supports_expires_at = 5; + // Credential-driver protocol metadata. Required for protocol negotiation. + openshell.extension.v1.PeerMetadata extension = 6; } message StoreCredentialRequest { diff --git a/proto/extension.proto b/proto/extension.proto new file mode 100644 index 0000000000..7c505f1ae3 --- /dev/null +++ b/proto/extension.proto @@ -0,0 +1,34 @@ +// SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +// SPDX-License-Identifier: Apache-2.0 + +syntax = "proto3"; + +package openshell.extension.v1; + +// Version of an OpenShell extension protocol contract. +// +// The major version changes when peers cannot safely interoperate. Minor +// versions add optional fields or capabilities and remain compatible when both +// peers' required capabilities are satisfied. +message ProtocolVersion { + uint32 major = 1; + uint32 minor = 2; +} + +// Non-secret metadata exchanged by the gateway and an extension before use. +message PeerMetadata { + // Extension-family protocol contract version, distinct from the build. + ProtocolVersion protocol_version = 1; + + // Stable human-readable implementation identity, such as "openshell/docker". + string implementation_name = 2; + + // Implementation or build version used only for diagnostics. + string implementation_version = 3; + + // Optional namespaced capabilities this peer understands. + repeated string supported_capabilities = 4; + + // Capabilities that the opposite peer must advertise. + repeated string required_capabilities = 5; +} diff --git a/proto/gateway_interceptor.proto b/proto/gateway_interceptor.proto index 72fec90197..1bd12d9d64 100644 --- a/proto/gateway_interceptor.proto +++ b/proto/gateway_interceptor.proto @@ -6,6 +6,7 @@ syntax = "proto3"; package openshell.gateway_interceptor.v1; import "google/protobuf/struct.proto"; +import "extension.proto"; import "openshell.proto"; // GatewayInterceptor lets an external governance service evaluate gateway @@ -25,7 +26,10 @@ service GatewayInterceptor { rpc Evaluate(InterceptorEvaluation) returns (InterceptorResult); } -message DescribeRequest {} +message DescribeRequest { + // Gateway protocol metadata. Interceptors must reject unmet requirements. + openshell.extension.v1.PeerMetadata gateway = 1; +} message ProviderProfileSnapshotRequest {} @@ -106,6 +110,8 @@ message InterceptorManifest { // an incorrect audience before returning this manifest. Empty skips this // post-authentication consistency check. string expected_audience = 5; + // Gateway-interceptor protocol metadata. Required for negotiation. + openshell.extension.v1.PeerMetadata extension = 6; } message ProviderProfileSnapshot { diff --git a/proto/openshell.proto b/proto/openshell.proto index 77bc32496b..a5b4a53bf9 100644 --- a/proto/openshell.proto +++ b/proto/openshell.proto @@ -873,6 +873,34 @@ message GetGatewayInfoResponse { // Compute driver runtimes initialized by this gateway. Current gateways // return exactly one entry. repeated ComputeDriverInfo compute_drivers = 3; + + // Negotiated non-secret metadata for every initialized extension. + repeated NegotiatedExtensionInfo extensions = 4; +} + +enum ExtensionKind { + EXTENSION_KIND_UNSPECIFIED = 0; + EXTENSION_KIND_COMPUTE_DRIVER = 1; + EXTENSION_KIND_CREDENTIAL_DRIVER = 2; + EXTENSION_KIND_GATEWAY_INTERCEPTOR = 3; + EXTENSION_KIND_SUPERVISOR_MIDDLEWARE = 4; +} + +// Public, non-secret snapshot of one successful startup negotiation. +message NegotiatedExtensionInfo { + ExtensionKind kind = 1; + // Gateway/operator-selected registration name. + string configured_name = 2; + // Extension-reported implementation identity. + string implementation_name = 3; + // Extension build version, distinct from the protocol version. + string implementation_version = 4; + uint32 protocol_major = 5; + uint32 protocol_minor = 6; + // Extension-supported optional capabilities, sorted for stable output. + repeated string supported_capabilities = 7; + // Capabilities the extension requires from the gateway. + repeated string required_capabilities = 8; } // Info for one initialized compute driver runtime. diff --git a/proto/supervisor_middleware.proto b/proto/supervisor_middleware.proto index 81e1c72f86..635776d00f 100644 --- a/proto/supervisor_middleware.proto +++ b/proto/supervisor_middleware.proto @@ -5,16 +5,16 @@ syntax = "proto3"; package openshell.middleware.v1; -import "google/protobuf/empty.proto"; import "google/protobuf/struct.proto"; import "google/protobuf/duration.proto"; +import "extension.proto"; // SupervisorMiddleware discovers and configures one operator-run middleware. // It evaluates HTTP requests and WebSocket messages before credentials. // Phase-specific services share the same registration. service SupervisorMiddleware { // Describe returns the service manifest and declared bindings. - rpc Describe(google.protobuf.Empty) returns (MiddlewareManifest); + rpc Describe(MiddlewareDescribeRequest) returns (MiddlewareManifest); // ValidateConfig checks service-specific configuration for one binding. rpc ValidateConfig(ValidateConfigRequest) returns (ValidateConfigResponse); @@ -34,6 +34,12 @@ service SupervisorMiddleware { returns (stream WebSocketSessionEventResult); } +message MiddlewareDescribeRequest { + // Gateway or supervisor protocol metadata. Middleware must reject unmet + // requirements before accepting traffic. + openshell.extension.v1.PeerMetadata gateway = 1; +} + // HttpResponsePreReturn evaluates one response for one middleware stage before // OpenShell returns it to the sandbox. service HttpResponsePreReturn { @@ -49,8 +55,8 @@ message MiddlewareManifest { // Human-readable middleware service name used only for diagnostics. This is // not required to match an operator-owned registration name. string name = 1; - // Release version of the middleware service implementation, used for - // diagnostics. + // Deprecated diagnostic compatibility field. Use + // extension.implementation_version. string service_version = 2; // Bindings exposed by this middleware service. repeated MiddlewareBinding bindings = 3; @@ -60,6 +66,8 @@ message MiddlewareManifest { // reject an incorrect audience before returning this manifest. Empty skips // this post-authentication consistency check. string expected_audience = 4; + // Supervisor-middleware protocol metadata. Required for negotiation. + openshell.extension.v1.PeerMetadata extension = 5; } // MiddlewareBinding declares one operation and phase supported by a service. diff --git a/sdk/go/openshell/v1/fake/health.go b/sdk/go/openshell/v1/fake/health.go index aa581ecb9c..304107a50f 100644 --- a/sdk/go/openshell/v1/fake/health.go +++ b/sdk/go/openshell/v1/fake/health.go @@ -89,6 +89,14 @@ func copyGatewayInfo(info *types.GatewayInfo) *types.GatewayInfo { cp.ComputeDrivers = make([]types.ComputeDriverInfo, len(info.ComputeDrivers)) copy(cp.ComputeDrivers, info.ComputeDrivers) } + if info.Extensions != nil { + cp.Extensions = make([]types.ExtensionInfo, len(info.Extensions)) + for index, extension := range info.Extensions { + cp.Extensions[index] = extension + cp.Extensions[index].SupportedCapabilities = copyStringSlice(extension.SupportedCapabilities) + cp.Extensions[index].RequiredCapabilities = copyStringSlice(extension.RequiredCapabilities) + } + } return &cp } diff --git a/sdk/go/openshell/v1/fake/health_test.go b/sdk/go/openshell/v1/fake/health_test.go index 8a5ddeba75..63656ba3f6 100644 --- a/sdk/go/openshell/v1/fake/health_test.go +++ b/sdk/go/openshell/v1/fake/health_test.go @@ -84,13 +84,21 @@ func TestHealth_GetGatewayInfo_DeepCopy(t *testing.T) { ComputeDrivers: []types.ComputeDriverInfo{ {Name: "k8s"}, }, + Extensions: []types.ExtensionInfo{{ + ConfiguredName: "k8s", + SupportedCapabilities: []string{"openshell.compute.contract"}, + }}, })) info1, _ := fc.Health().GetGatewayInfo(context.Background()) info1.ComputeDrivers[0].Name = "mutated" + info1.Extensions[0].ConfiguredName = "mutated" + info1.Extensions[0].SupportedCapabilities[0] = "mutated" info2, _ := fc.Health().GetGatewayInfo(context.Background()) assert.Equal(t, "k8s", info2.ComputeDrivers[0].Name) + assert.Equal(t, "k8s", info2.Extensions[0].ConfiguredName) + assert.Equal(t, "openshell.compute.contract", info2.Extensions[0].SupportedCapabilities[0]) } func TestHealth_GetCurrentUser_Default(t *testing.T) { diff --git a/sdk/go/openshell/v1/health.go b/sdk/go/openshell/v1/health.go index 4230ca6cb2..e7745dd76b 100644 --- a/sdk/go/openshell/v1/health.go +++ b/sdk/go/openshell/v1/health.go @@ -18,6 +18,12 @@ type GatewayInfo = types.GatewayInfo // ComputeDriverInfo describes a compute backend available on the gateway. type ComputeDriverInfo = types.ComputeDriverInfo +// ExtensionInfo describes one successful gateway/extension negotiation. +type ExtensionInfo = types.ExtensionInfo + +// ExtensionKind identifies one supported extension family. +type ExtensionKind = types.ExtensionKind + // ServiceStatus describes the health state of the gateway. type ServiceStatus = types.ServiceStatus diff --git a/sdk/go/openshell/v1/internal/converter/health.go b/sdk/go/openshell/v1/internal/converter/health.go index 63ab8c3298..8e1c2b98f6 100644 --- a/sdk/go/openshell/v1/internal/converter/health.go +++ b/sdk/go/openshell/v1/internal/converter/health.go @@ -18,11 +18,46 @@ func GatewayInfoFromProto(resp *pb.GetGatewayInfoResponse) *types.GatewayInfo { for _, d := range resp.GetComputeDrivers() { drivers = append(drivers, ComputeDriverInfoFromProto(d)) } + extensions := make([]types.ExtensionInfo, 0, len(resp.GetExtensions())) + for _, extension := range resp.GetExtensions() { + extensions = append(extensions, ExtensionInfoFromProto(extension)) + } return &types.GatewayInfo{ Status: ServiceStatusFromProto(resp.GetStatus()), Version: resp.GetGatewayVersion(), ComputeDrivers: drivers, + Extensions: extensions, + } +} + +// ExtensionInfoFromProto converts a negotiated extension snapshot. +func ExtensionInfoFromProto(extension *pb.NegotiatedExtensionInfo) types.ExtensionInfo { + return types.ExtensionInfo{ + Kind: ExtensionKindFromProto(extension.GetKind()), + ConfiguredName: extension.GetConfiguredName(), + ImplementationName: extension.GetImplementationName(), + ImplementationVersion: extension.GetImplementationVersion(), + ProtocolMajor: extension.GetProtocolMajor(), + ProtocolMinor: extension.GetProtocolMinor(), + SupportedCapabilities: CopyStringSlice(extension.GetSupportedCapabilities()), + RequiredCapabilities: CopyStringSlice(extension.GetRequiredCapabilities()), + } +} + +// ExtensionKindFromProto converts the public extension family enum. +func ExtensionKindFromProto(kind pb.ExtensionKind) types.ExtensionKind { + switch kind { + case pb.ExtensionKind_EXTENSION_KIND_COMPUTE_DRIVER: + return types.ExtensionKindComputeDriver + case pb.ExtensionKind_EXTENSION_KIND_CREDENTIAL_DRIVER: + return types.ExtensionKindCredentialDriver + case pb.ExtensionKind_EXTENSION_KIND_GATEWAY_INTERCEPTOR: + return types.ExtensionKindGatewayInterceptor + case pb.ExtensionKind_EXTENSION_KIND_SUPERVISOR_MIDDLEWARE: + return types.ExtensionKindSupervisorMiddleware + default: + return types.ExtensionKindUnknown } } diff --git a/sdk/go/openshell/v1/internal/converter/health_test.go b/sdk/go/openshell/v1/internal/converter/health_test.go index d0360a9b66..ab8e0c2415 100644 --- a/sdk/go/openshell/v1/internal/converter/health_test.go +++ b/sdk/go/openshell/v1/internal/converter/health_test.go @@ -32,6 +32,17 @@ func TestGatewayInfoFromProto(t *testing.T) { }, }, }, + Extensions: []*pb.NegotiatedExtensionInfo{ + { + Kind: pb.ExtensionKind_EXTENSION_KIND_COMPUTE_DRIVER, + ConfiguredName: "k8s", + ImplementationName: "openshell/kubernetes", + ImplementationVersion: "1.5.0", + ProtocolMajor: 1, + SupportedCapabilities: []string{"openshell.compute.contract"}, + RequiredCapabilities: []string{"openshell.compute.contract"}, + }, + }, } info := GatewayInfoFromProto(proto) @@ -45,6 +56,10 @@ func TestGatewayInfoFromProto(t *testing.T) { assert.Equal(t, "2.1.0", info.ComputeDrivers[0].DriverVersion) assert.Equal(t, "docker", info.ComputeDrivers[1].Name) assert.Equal(t, "docker-engine", info.ComputeDrivers[1].DriverName) + require.Len(t, info.Extensions, 1) + assert.Equal(t, v1.ExtensionKindComputeDriver, info.Extensions[0].Kind) + assert.Equal(t, "openshell/kubernetes", info.Extensions[0].ImplementationName) + assert.Equal(t, uint32(1), info.Extensions[0].ProtocolMajor) } func TestGatewayInfoFromProto_NoDrivers(t *testing.T) { @@ -72,12 +87,20 @@ func TestGatewayInfoFromProto_DeepCopy(t *testing.T) { ComputeDrivers: []*pb.ComputeDriverInfo{ {Name: "k8s", Capabilities: &pb.ComputeDriverCapabilities{DriverName: "kubernetes"}}, }, + Extensions: []*pb.NegotiatedExtensionInfo{{ + ConfiguredName: "k8s", + SupportedCapabilities: []string{"openshell.compute.contract"}, + }}, } info := GatewayInfoFromProto(proto) proto.ComputeDrivers[0].Name = "mutated" + proto.Extensions[0].ConfiguredName = "mutated" + proto.Extensions[0].SupportedCapabilities[0] = "mutated" assert.Equal(t, "k8s", info.ComputeDrivers[0].Name) + assert.Equal(t, "k8s", info.Extensions[0].ConfiguredName) + assert.Equal(t, "openshell.compute.contract", info.Extensions[0].SupportedCapabilities[0]) } func TestServiceStatusFromProto(t *testing.T) { diff --git a/sdk/go/openshell/v1/types/health.go b/sdk/go/openshell/v1/types/health.go index 1db3ec3872..3039f1c80d 100644 --- a/sdk/go/openshell/v1/types/health.go +++ b/sdk/go/openshell/v1/types/health.go @@ -25,6 +25,31 @@ type GatewayInfo struct { Status ServiceStatus Version string ComputeDrivers []ComputeDriverInfo + Extensions []ExtensionInfo +} + +// ExtensionKind identifies one supported extension family. +type ExtensionKind string + +// Extension kind constants. +const ( + ExtensionKindComputeDriver ExtensionKind = "ComputeDriver" + ExtensionKindCredentialDriver ExtensionKind = "CredentialDriver" + ExtensionKindGatewayInterceptor ExtensionKind = "GatewayInterceptor" + ExtensionKindSupervisorMiddleware ExtensionKind = "SupervisorMiddleware" + ExtensionKindUnknown ExtensionKind = "Unknown" +) + +// ExtensionInfo describes one successful gateway/extension negotiation. +type ExtensionInfo struct { + Kind ExtensionKind + ConfiguredName string + ImplementationName string + ImplementationVersion string + ProtocolMajor uint32 + ProtocolMinor uint32 + SupportedCapabilities []string + RequiredCapabilities []string } // ComputeDriverInfo describes a compute backend available on the gateway. diff --git a/sdk/go/proto/openshellv1/openshell.pb.go b/sdk/go/proto/openshellv1/openshell.pb.go index c7cdc8e850..7111a18781 100644 --- a/sdk/go/proto/openshellv1/openshell.pb.go +++ b/sdk/go/proto/openshellv1/openshell.pb.go @@ -30,6 +30,61 @@ const ( _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) ) +type ExtensionKind int32 + +const ( + ExtensionKind_EXTENSION_KIND_UNSPECIFIED ExtensionKind = 0 + ExtensionKind_EXTENSION_KIND_COMPUTE_DRIVER ExtensionKind = 1 + ExtensionKind_EXTENSION_KIND_CREDENTIAL_DRIVER ExtensionKind = 2 + ExtensionKind_EXTENSION_KIND_GATEWAY_INTERCEPTOR ExtensionKind = 3 + ExtensionKind_EXTENSION_KIND_SUPERVISOR_MIDDLEWARE ExtensionKind = 4 +) + +// Enum value maps for ExtensionKind. +var ( + ExtensionKind_name = map[int32]string{ + 0: "EXTENSION_KIND_UNSPECIFIED", + 1: "EXTENSION_KIND_COMPUTE_DRIVER", + 2: "EXTENSION_KIND_CREDENTIAL_DRIVER", + 3: "EXTENSION_KIND_GATEWAY_INTERCEPTOR", + 4: "EXTENSION_KIND_SUPERVISOR_MIDDLEWARE", + } + ExtensionKind_value = map[string]int32{ + "EXTENSION_KIND_UNSPECIFIED": 0, + "EXTENSION_KIND_COMPUTE_DRIVER": 1, + "EXTENSION_KIND_CREDENTIAL_DRIVER": 2, + "EXTENSION_KIND_GATEWAY_INTERCEPTOR": 3, + "EXTENSION_KIND_SUPERVISOR_MIDDLEWARE": 4, + } +) + +func (x ExtensionKind) Enum() *ExtensionKind { + p := new(ExtensionKind) + *p = x + return p +} + +func (x ExtensionKind) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (ExtensionKind) Descriptor() protoreflect.EnumDescriptor { + return file_openshell_proto_enumTypes[0].Descriptor() +} + +func (ExtensionKind) Type() protoreflect.EnumType { + return &file_openshell_proto_enumTypes[0] +} + +func (x ExtensionKind) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use ExtensionKind.Descriptor instead. +func (ExtensionKind) EnumDescriptor() ([]byte, []int) { + return file_openshell_proto_rawDescGZIP(), []int{0} +} + // High-level sandbox lifecycle phase derived by the gateway. // // Clients should rely on this normalized lifecycle summary for readiness and @@ -89,11 +144,11 @@ func (x SandboxPhase) String() string { } func (SandboxPhase) Descriptor() protoreflect.EnumDescriptor { - return file_openshell_proto_enumTypes[0].Descriptor() + return file_openshell_proto_enumTypes[1].Descriptor() } func (SandboxPhase) Type() protoreflect.EnumType { - return &file_openshell_proto_enumTypes[0] + return &file_openshell_proto_enumTypes[1] } func (x SandboxPhase) Number() protoreflect.EnumNumber { @@ -102,7 +157,7 @@ func (x SandboxPhase) Number() protoreflect.EnumNumber { // Deprecated: Use SandboxPhase.Descriptor instead. func (SandboxPhase) EnumDescriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{0} + return file_openshell_proto_rawDescGZIP(), []int{1} } // Operation whose installed authority is tracked by a receipt. @@ -146,11 +201,11 @@ func (x ProviderMutationKind) String() string { } func (ProviderMutationKind) Descriptor() protoreflect.EnumDescriptor { - return file_openshell_proto_enumTypes[1].Descriptor() + return file_openshell_proto_enumTypes[2].Descriptor() } func (ProviderMutationKind) Type() protoreflect.EnumType { - return &file_openshell_proto_enumTypes[1] + return &file_openshell_proto_enumTypes[2] } func (x ProviderMutationKind) Number() protoreflect.EnumNumber { @@ -159,7 +214,7 @@ func (x ProviderMutationKind) Number() protoreflect.EnumNumber { // Deprecated: Use ProviderMutationKind.Descriptor instead. func (ProviderMutationKind) EnumDescriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{1} + return file_openshell_proto_rawDescGZIP(), []int{2} } // Readiness states describe persisted intent separately from installed state. @@ -211,11 +266,11 @@ func (x ProviderReadinessState) String() string { } func (ProviderReadinessState) Descriptor() protoreflect.EnumDescriptor { - return file_openshell_proto_enumTypes[2].Descriptor() + return file_openshell_proto_enumTypes[3].Descriptor() } func (ProviderReadinessState) Type() protoreflect.EnumType { - return &file_openshell_proto_enumTypes[2] + return &file_openshell_proto_enumTypes[3] } func (x ProviderReadinessState) Number() protoreflect.EnumNumber { @@ -224,7 +279,7 @@ func (x ProviderReadinessState) Number() protoreflect.EnumNumber { // Deprecated: Use ProviderReadinessState.Descriptor instead. func (ProviderReadinessState) EnumDescriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{2} + return file_openshell_proto_rawDescGZIP(), []int{3} } // Closed reason categories are safe to display. Raw installation errors are @@ -301,11 +356,11 @@ func (x ProviderReadinessReason) String() string { } func (ProviderReadinessReason) Descriptor() protoreflect.EnumDescriptor { - return file_openshell_proto_enumTypes[3].Descriptor() + return file_openshell_proto_enumTypes[4].Descriptor() } func (ProviderReadinessReason) Type() protoreflect.EnumType { - return &file_openshell_proto_enumTypes[3] + return &file_openshell_proto_enumTypes[4] } func (x ProviderReadinessReason) Number() protoreflect.EnumNumber { @@ -314,7 +369,7 @@ func (x ProviderReadinessReason) Number() protoreflect.EnumNumber { // Deprecated: Use ProviderReadinessReason.Descriptor instead. func (ProviderReadinessReason) EnumDescriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{3} + return file_openshell_proto_rawDescGZIP(), []int{4} } // Component whose desired state is tracked by a durable update operation. @@ -351,11 +406,11 @@ func (x ConfigComponent) String() string { } func (ConfigComponent) Descriptor() protoreflect.EnumDescriptor { - return file_openshell_proto_enumTypes[4].Descriptor() + return file_openshell_proto_enumTypes[5].Descriptor() } func (ConfigComponent) Type() protoreflect.EnumType { - return &file_openshell_proto_enumTypes[4] + return &file_openshell_proto_enumTypes[5] } func (x ConfigComponent) Number() protoreflect.EnumNumber { @@ -364,7 +419,7 @@ func (x ConfigComponent) Number() protoreflect.EnumNumber { // Deprecated: Use ConfigComponent.Descriptor instead. func (ConfigComponent) EnumDescriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{4} + return file_openshell_proto_rawDescGZIP(), []int{5} } // Result of applying a component revision at its owning runtime boundary. @@ -419,11 +474,11 @@ func (x ConfigApplyOutcome) String() string { } func (ConfigApplyOutcome) Descriptor() protoreflect.EnumDescriptor { - return file_openshell_proto_enumTypes[5].Descriptor() + return file_openshell_proto_enumTypes[6].Descriptor() } func (ConfigApplyOutcome) Type() protoreflect.EnumType { - return &file_openshell_proto_enumTypes[5] + return &file_openshell_proto_enumTypes[6] } func (x ConfigApplyOutcome) Number() protoreflect.EnumNumber { @@ -432,7 +487,7 @@ func (x ConfigApplyOutcome) Number() protoreflect.EnumNumber { // Deprecated: Use ConfigApplyOutcome.Descriptor instead. func (ConfigApplyOutcome) EnumDescriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{5} + return file_openshell_proto_rawDescGZIP(), []int{6} } // Durable lifecycle of one desired-state update operation. @@ -481,11 +536,11 @@ func (x ConfigUpdateOperationState) String() string { } func (ConfigUpdateOperationState) Descriptor() protoreflect.EnumDescriptor { - return file_openshell_proto_enumTypes[6].Descriptor() + return file_openshell_proto_enumTypes[7].Descriptor() } func (ConfigUpdateOperationState) Type() protoreflect.EnumType { - return &file_openshell_proto_enumTypes[6] + return &file_openshell_proto_enumTypes[7] } func (x ConfigUpdateOperationState) Number() protoreflect.EnumNumber { @@ -494,7 +549,7 @@ func (x ConfigUpdateOperationState) Number() protoreflect.EnumNumber { // Deprecated: Use ConfigUpdateOperationState.Descriptor instead. func (ConfigUpdateOperationState) EnumDescriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{6} + return file_openshell_proto_rawDescGZIP(), []int{7} } // Provider credential token grant configuration. @@ -532,11 +587,11 @@ func (x ProviderCredentialTokenGrantType) String() string { } func (ProviderCredentialTokenGrantType) Descriptor() protoreflect.EnumDescriptor { - return file_openshell_proto_enumTypes[7].Descriptor() + return file_openshell_proto_enumTypes[8].Descriptor() } func (ProviderCredentialTokenGrantType) Type() protoreflect.EnumType { - return &file_openshell_proto_enumTypes[7] + return &file_openshell_proto_enumTypes[8] } func (x ProviderCredentialTokenGrantType) Number() protoreflect.EnumNumber { @@ -545,7 +600,7 @@ func (x ProviderCredentialTokenGrantType) Number() protoreflect.EnumNumber { // Deprecated: Use ProviderCredentialTokenGrantType.Descriptor instead. func (ProviderCredentialTokenGrantType) EnumDescriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{7} + return file_openshell_proto_rawDescGZIP(), []int{8} } type ProviderCredentialRefreshStrategy int32 @@ -593,11 +648,11 @@ func (x ProviderCredentialRefreshStrategy) String() string { } func (ProviderCredentialRefreshStrategy) Descriptor() protoreflect.EnumDescriptor { - return file_openshell_proto_enumTypes[8].Descriptor() + return file_openshell_proto_enumTypes[9].Descriptor() } func (ProviderCredentialRefreshStrategy) Type() protoreflect.EnumType { - return &file_openshell_proto_enumTypes[8] + return &file_openshell_proto_enumTypes[9] } func (x ProviderCredentialRefreshStrategy) Number() protoreflect.EnumNumber { @@ -606,7 +661,7 @@ func (x ProviderCredentialRefreshStrategy) Number() protoreflect.EnumNumber { // Deprecated: Use ProviderCredentialRefreshStrategy.Descriptor instead. func (ProviderCredentialRefreshStrategy) EnumDescriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{8} + return file_openshell_proto_rawDescGZIP(), []int{9} } // Stable provider profile categories used by clients for grouping and filtering. @@ -658,11 +713,11 @@ func (x ProviderProfileCategory) String() string { } func (ProviderProfileCategory) Descriptor() protoreflect.EnumDescriptor { - return file_openshell_proto_enumTypes[9].Descriptor() + return file_openshell_proto_enumTypes[10].Descriptor() } func (ProviderProfileCategory) Type() protoreflect.EnumType { - return &file_openshell_proto_enumTypes[9] + return &file_openshell_proto_enumTypes[10] } func (x ProviderProfileCategory) Number() protoreflect.EnumNumber { @@ -671,7 +726,7 @@ func (x ProviderProfileCategory) Number() protoreflect.EnumNumber { // Deprecated: Use ProviderProfileCategory.Descriptor instead. func (ProviderProfileCategory) EnumDescriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{9} + return file_openshell_proto_rawDescGZIP(), []int{10} } // Policy load status. @@ -720,11 +775,11 @@ func (x PolicyStatus) String() string { } func (PolicyStatus) Descriptor() protoreflect.EnumDescriptor { - return file_openshell_proto_enumTypes[10].Descriptor() + return file_openshell_proto_enumTypes[11].Descriptor() } func (PolicyStatus) Type() protoreflect.EnumType { - return &file_openshell_proto_enumTypes[10] + return &file_openshell_proto_enumTypes[11] } func (x PolicyStatus) Number() protoreflect.EnumNumber { @@ -733,7 +788,7 @@ func (x PolicyStatus) Number() protoreflect.EnumNumber { // Deprecated: Use PolicyStatus.Descriptor instead. func (PolicyStatus) EnumDescriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{10} + return file_openshell_proto_rawDescGZIP(), []int{11} } // Service status enum. @@ -773,11 +828,11 @@ func (x ServiceStatus) String() string { } func (ServiceStatus) Descriptor() protoreflect.EnumDescriptor { - return file_openshell_proto_enumTypes[11].Descriptor() + return file_openshell_proto_enumTypes[12].Descriptor() } func (ServiceStatus) Type() protoreflect.EnumType { - return &file_openshell_proto_enumTypes[11] + return &file_openshell_proto_enumTypes[12] } func (x ServiceStatus) Number() protoreflect.EnumNumber { @@ -786,7 +841,7 @@ func (x ServiceStatus) Number() protoreflect.EnumNumber { // Deprecated: Use ServiceStatus.Descriptor instead. func (ServiceStatus) EnumDescriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{11} + return file_openshell_proto_rawDescGZIP(), []int{12} } // Workspace-scoped role for members. @@ -823,11 +878,11 @@ func (x WorkspaceRole) String() string { } func (WorkspaceRole) Descriptor() protoreflect.EnumDescriptor { - return file_openshell_proto_enumTypes[12].Descriptor() + return file_openshell_proto_enumTypes[13].Descriptor() } func (WorkspaceRole) Type() protoreflect.EnumType { - return &file_openshell_proto_enumTypes[12] + return &file_openshell_proto_enumTypes[13] } func (x WorkspaceRole) Number() protoreflect.EnumNumber { @@ -836,7 +891,7 @@ func (x WorkspaceRole) Number() protoreflect.EnumNumber { // Deprecated: Use WorkspaceRole.Descriptor instead. func (WorkspaceRole) EnumDescriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{12} + return file_openshell_proto_rawDescGZIP(), []int{13} } // Stable recovery action for the most recent provider credential refresh @@ -882,11 +937,11 @@ func (x ProviderCredentialRefreshRecoveryAction) String() string { } func (ProviderCredentialRefreshRecoveryAction) Descriptor() protoreflect.EnumDescriptor { - return file_openshell_proto_enumTypes[13].Descriptor() + return file_openshell_proto_enumTypes[14].Descriptor() } func (ProviderCredentialRefreshRecoveryAction) Type() protoreflect.EnumType { - return &file_openshell_proto_enumTypes[13] + return &file_openshell_proto_enumTypes[14] } func (x ProviderCredentialRefreshRecoveryAction) Number() protoreflect.EnumNumber { @@ -895,7 +950,7 @@ func (x ProviderCredentialRefreshRecoveryAction) Number() protoreflect.EnumNumbe // Deprecated: Use ProviderCredentialRefreshRecoveryAction.Descriptor instead. func (ProviderCredentialRefreshRecoveryAction) EnumDescriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{13} + return file_openshell_proto_rawDescGZIP(), []int{14} } // Result of a public delete, membership removal, or session revocation. @@ -945,11 +1000,11 @@ func (x DeletionOutcome) String() string { } func (DeletionOutcome) Descriptor() protoreflect.EnumDescriptor { - return file_openshell_proto_enumTypes[14].Descriptor() + return file_openshell_proto_enumTypes[15].Descriptor() } func (DeletionOutcome) Type() protoreflect.EnumType { - return &file_openshell_proto_enumTypes[14] + return &file_openshell_proto_enumTypes[15] } func (x DeletionOutcome) Number() protoreflect.EnumNumber { @@ -958,7 +1013,7 @@ func (x DeletionOutcome) Number() protoreflect.EnumNumber { // Deprecated: Use DeletionOutcome.Descriptor instead. func (DeletionOutcome) EnumDescriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{14} + return file_openshell_proto_rawDescGZIP(), []int{15} } // Last observed network result for a configured external tool endpoint. @@ -1019,11 +1074,11 @@ func (x EndpointResult) String() string { } func (EndpointResult) Descriptor() protoreflect.EnumDescriptor { - return file_openshell_proto_enumTypes[15].Descriptor() + return file_openshell_proto_enumTypes[16].Descriptor() } func (EndpointResult) Type() protoreflect.EnumType { - return &file_openshell_proto_enumTypes[15] + return &file_openshell_proto_enumTypes[16] } func (x EndpointResult) Number() protoreflect.EnumNumber { @@ -1032,7 +1087,7 @@ func (x EndpointResult) Number() protoreflect.EnumNumber { // Deprecated: Use EndpointResult.Descriptor instead. func (EndpointResult) EnumDescriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{15} + return file_openshell_proto_rawDescGZIP(), []int{16} } // IssueSandboxToken request. Empty body; identity is established by the @@ -1542,8 +1597,10 @@ type GetGatewayInfoResponse struct { // Compute driver runtimes initialized by this gateway. Current gateways // return exactly one entry. ComputeDrivers []*ComputeDriverInfo `protobuf:"bytes,3,rep,name=compute_drivers,json=computeDrivers,proto3" json:"compute_drivers,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache + // Negotiated non-secret metadata for every initialized extension. + Extensions []*NegotiatedExtensionInfo `protobuf:"bytes,4,rep,name=extensions,proto3" json:"extensions,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *GetGatewayInfoResponse) Reset() { @@ -1597,6 +1654,119 @@ func (x *GetGatewayInfoResponse) GetComputeDrivers() []*ComputeDriverInfo { return nil } +func (x *GetGatewayInfoResponse) GetExtensions() []*NegotiatedExtensionInfo { + if x != nil { + return x.Extensions + } + return nil +} + +// Public, non-secret snapshot of one successful startup negotiation. +type NegotiatedExtensionInfo struct { + state protoimpl.MessageState `protogen:"open.v1"` + Kind ExtensionKind `protobuf:"varint,1,opt,name=kind,proto3,enum=openshell.v1.ExtensionKind" json:"kind,omitempty"` + // Gateway/operator-selected registration name. + ConfiguredName string `protobuf:"bytes,2,opt,name=configured_name,json=configuredName,proto3" json:"configured_name,omitempty"` + // Extension-reported implementation identity. + ImplementationName string `protobuf:"bytes,3,opt,name=implementation_name,json=implementationName,proto3" json:"implementation_name,omitempty"` + // Extension build version, distinct from the protocol version. + ImplementationVersion string `protobuf:"bytes,4,opt,name=implementation_version,json=implementationVersion,proto3" json:"implementation_version,omitempty"` + ProtocolMajor uint32 `protobuf:"varint,5,opt,name=protocol_major,json=protocolMajor,proto3" json:"protocol_major,omitempty"` + ProtocolMinor uint32 `protobuf:"varint,6,opt,name=protocol_minor,json=protocolMinor,proto3" json:"protocol_minor,omitempty"` + // Extension-supported optional capabilities, sorted for stable output. + SupportedCapabilities []string `protobuf:"bytes,7,rep,name=supported_capabilities,json=supportedCapabilities,proto3" json:"supported_capabilities,omitempty"` + // Capabilities the extension requires from the gateway. + RequiredCapabilities []string `protobuf:"bytes,8,rep,name=required_capabilities,json=requiredCapabilities,proto3" json:"required_capabilities,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *NegotiatedExtensionInfo) Reset() { + *x = NegotiatedExtensionInfo{} + mi := &file_openshell_proto_msgTypes[10] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *NegotiatedExtensionInfo) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*NegotiatedExtensionInfo) ProtoMessage() {} + +func (x *NegotiatedExtensionInfo) ProtoReflect() protoreflect.Message { + mi := &file_openshell_proto_msgTypes[10] + 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 NegotiatedExtensionInfo.ProtoReflect.Descriptor instead. +func (*NegotiatedExtensionInfo) Descriptor() ([]byte, []int) { + return file_openshell_proto_rawDescGZIP(), []int{10} +} + +func (x *NegotiatedExtensionInfo) GetKind() ExtensionKind { + if x != nil { + return x.Kind + } + return ExtensionKind_EXTENSION_KIND_UNSPECIFIED +} + +func (x *NegotiatedExtensionInfo) GetConfiguredName() string { + if x != nil { + return x.ConfiguredName + } + return "" +} + +func (x *NegotiatedExtensionInfo) GetImplementationName() string { + if x != nil { + return x.ImplementationName + } + return "" +} + +func (x *NegotiatedExtensionInfo) GetImplementationVersion() string { + if x != nil { + return x.ImplementationVersion + } + return "" +} + +func (x *NegotiatedExtensionInfo) GetProtocolMajor() uint32 { + if x != nil { + return x.ProtocolMajor + } + return 0 +} + +func (x *NegotiatedExtensionInfo) GetProtocolMinor() uint32 { + if x != nil { + return x.ProtocolMinor + } + return 0 +} + +func (x *NegotiatedExtensionInfo) GetSupportedCapabilities() []string { + if x != nil { + return x.SupportedCapabilities + } + return nil +} + +func (x *NegotiatedExtensionInfo) GetRequiredCapabilities() []string { + if x != nil { + return x.RequiredCapabilities + } + return nil +} + // Info for one initialized compute driver runtime. type ComputeDriverInfo struct { state protoimpl.MessageState `protogen:"open.v1"` @@ -1610,7 +1780,7 @@ type ComputeDriverInfo struct { func (x *ComputeDriverInfo) Reset() { *x = ComputeDriverInfo{} - mi := &file_openshell_proto_msgTypes[10] + mi := &file_openshell_proto_msgTypes[11] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1622,7 +1792,7 @@ func (x *ComputeDriverInfo) String() string { func (*ComputeDriverInfo) ProtoMessage() {} func (x *ComputeDriverInfo) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[10] + mi := &file_openshell_proto_msgTypes[11] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1635,7 +1805,7 @@ func (x *ComputeDriverInfo) ProtoReflect() protoreflect.Message { // Deprecated: Use ComputeDriverInfo.ProtoReflect.Descriptor instead. func (*ComputeDriverInfo) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{10} + return file_openshell_proto_rawDescGZIP(), []int{11} } func (x *ComputeDriverInfo) GetName() string { @@ -1667,7 +1837,7 @@ type ComputeDriverCapabilities struct { func (x *ComputeDriverCapabilities) Reset() { *x = ComputeDriverCapabilities{} - mi := &file_openshell_proto_msgTypes[11] + mi := &file_openshell_proto_msgTypes[12] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1679,7 +1849,7 @@ func (x *ComputeDriverCapabilities) String() string { func (*ComputeDriverCapabilities) ProtoMessage() {} func (x *ComputeDriverCapabilities) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[11] + mi := &file_openshell_proto_msgTypes[12] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1692,7 +1862,7 @@ func (x *ComputeDriverCapabilities) ProtoReflect() protoreflect.Message { // Deprecated: Use ComputeDriverCapabilities.ProtoReflect.Descriptor instead. func (*ComputeDriverCapabilities) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{11} + return file_openshell_proto_rawDescGZIP(), []int{12} } func (x *ComputeDriverCapabilities) GetDriverName() string { @@ -1729,7 +1899,7 @@ type ResourceCapabilities struct { func (x *ResourceCapabilities) Reset() { *x = ResourceCapabilities{} - mi := &file_openshell_proto_msgTypes[12] + mi := &file_openshell_proto_msgTypes[13] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1741,7 +1911,7 @@ func (x *ResourceCapabilities) String() string { func (*ResourceCapabilities) ProtoMessage() {} func (x *ResourceCapabilities) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[12] + mi := &file_openshell_proto_msgTypes[13] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1754,7 +1924,7 @@ func (x *ResourceCapabilities) ProtoReflect() protoreflect.Message { // Deprecated: Use ResourceCapabilities.ProtoReflect.Descriptor instead. func (*ResourceCapabilities) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{12} + return file_openshell_proto_rawDescGZIP(), []int{13} } func (x *ResourceCapabilities) GetCpu() *CpuResourceCapabilities { @@ -1788,7 +1958,7 @@ type CpuResourceCapabilities struct { func (x *CpuResourceCapabilities) Reset() { *x = CpuResourceCapabilities{} - mi := &file_openshell_proto_msgTypes[13] + mi := &file_openshell_proto_msgTypes[14] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1800,7 +1970,7 @@ func (x *CpuResourceCapabilities) String() string { func (*CpuResourceCapabilities) ProtoMessage() {} func (x *CpuResourceCapabilities) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[13] + mi := &file_openshell_proto_msgTypes[14] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1813,7 +1983,7 @@ func (x *CpuResourceCapabilities) ProtoReflect() protoreflect.Message { // Deprecated: Use CpuResourceCapabilities.ProtoReflect.Descriptor instead. func (*CpuResourceCapabilities) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{13} + return file_openshell_proto_rawDescGZIP(), []int{14} } func (x *CpuResourceCapabilities) GetLimitSupported() bool { @@ -1833,7 +2003,7 @@ type MemoryResourceCapabilities struct { func (x *MemoryResourceCapabilities) Reset() { *x = MemoryResourceCapabilities{} - mi := &file_openshell_proto_msgTypes[14] + mi := &file_openshell_proto_msgTypes[15] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1845,7 +2015,7 @@ func (x *MemoryResourceCapabilities) String() string { func (*MemoryResourceCapabilities) ProtoMessage() {} func (x *MemoryResourceCapabilities) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[14] + mi := &file_openshell_proto_msgTypes[15] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1858,7 +2028,7 @@ func (x *MemoryResourceCapabilities) ProtoReflect() protoreflect.Message { // Deprecated: Use MemoryResourceCapabilities.ProtoReflect.Descriptor instead. func (*MemoryResourceCapabilities) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{14} + return file_openshell_proto_rawDescGZIP(), []int{15} } func (x *MemoryResourceCapabilities) GetLimitSupported() bool { @@ -1880,7 +2050,7 @@ type GpuResourceCapabilities struct { func (x *GpuResourceCapabilities) Reset() { *x = GpuResourceCapabilities{} - mi := &file_openshell_proto_msgTypes[15] + mi := &file_openshell_proto_msgTypes[16] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1892,7 +2062,7 @@ func (x *GpuResourceCapabilities) String() string { func (*GpuResourceCapabilities) ProtoMessage() {} func (x *GpuResourceCapabilities) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[15] + mi := &file_openshell_proto_msgTypes[16] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1905,7 +2075,7 @@ func (x *GpuResourceCapabilities) ProtoReflect() protoreflect.Message { // Deprecated: Use GpuResourceCapabilities.ProtoReflect.Descriptor instead. func (*GpuResourceCapabilities) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{15} + return file_openshell_proto_rawDescGZIP(), []int{16} } func (x *GpuResourceCapabilities) GetDefaultSelectionSupported() bool { @@ -1946,7 +2116,7 @@ type Sandbox struct { func (x *Sandbox) Reset() { *x = Sandbox{} - mi := &file_openshell_proto_msgTypes[16] + mi := &file_openshell_proto_msgTypes[17] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1958,7 +2128,7 @@ func (x *Sandbox) String() string { func (*Sandbox) ProtoMessage() {} func (x *Sandbox) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[16] + mi := &file_openshell_proto_msgTypes[17] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1971,7 +2141,7 @@ func (x *Sandbox) ProtoReflect() protoreflect.Message { // Deprecated: Use Sandbox.ProtoReflect.Descriptor instead. func (*Sandbox) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{16} + return file_openshell_proto_rawDescGZIP(), []int{17} } func (x *Sandbox) GetMetadata() *datamodelv1.ObjectMeta { @@ -2033,7 +2203,7 @@ type SandboxSpec struct { func (x *SandboxSpec) Reset() { *x = SandboxSpec{} - mi := &file_openshell_proto_msgTypes[17] + mi := &file_openshell_proto_msgTypes[18] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2045,7 +2215,7 @@ func (x *SandboxSpec) String() string { func (*SandboxSpec) ProtoMessage() {} func (x *SandboxSpec) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[17] + mi := &file_openshell_proto_msgTypes[18] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2058,7 +2228,7 @@ func (x *SandboxSpec) ProtoReflect() protoreflect.Message { // Deprecated: Use SandboxSpec.ProtoReflect.Descriptor instead. func (*SandboxSpec) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{17} + return file_openshell_proto_rawDescGZIP(), []int{18} } func (x *SandboxSpec) GetLogLevel() string { @@ -2134,7 +2304,7 @@ type ResourceRequirements struct { func (x *ResourceRequirements) Reset() { *x = ResourceRequirements{} - mi := &file_openshell_proto_msgTypes[18] + mi := &file_openshell_proto_msgTypes[19] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2146,7 +2316,7 @@ func (x *ResourceRequirements) String() string { func (*ResourceRequirements) ProtoMessage() {} func (x *ResourceRequirements) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[18] + mi := &file_openshell_proto_msgTypes[19] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2159,7 +2329,7 @@ func (x *ResourceRequirements) ProtoReflect() protoreflect.Message { // Deprecated: Use ResourceRequirements.ProtoReflect.Descriptor instead. func (*ResourceRequirements) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{18} + return file_openshell_proto_rawDescGZIP(), []int{19} } func (x *ResourceRequirements) GetGpu() *GpuResourceRequirements { @@ -2181,7 +2351,7 @@ type GpuResourceRequirements struct { func (x *GpuResourceRequirements) Reset() { *x = GpuResourceRequirements{} - mi := &file_openshell_proto_msgTypes[19] + mi := &file_openshell_proto_msgTypes[20] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2193,7 +2363,7 @@ func (x *GpuResourceRequirements) String() string { func (*GpuResourceRequirements) ProtoMessage() {} func (x *GpuResourceRequirements) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[19] + mi := &file_openshell_proto_msgTypes[20] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2206,7 +2376,7 @@ func (x *GpuResourceRequirements) ProtoReflect() protoreflect.Message { // Deprecated: Use GpuResourceRequirements.ProtoReflect.Descriptor instead. func (*GpuResourceRequirements) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{19} + return file_openshell_proto_rawDescGZIP(), []int{20} } func (x *GpuResourceRequirements) GetCount() uint32 { @@ -2255,7 +2425,7 @@ type SandboxTemplate struct { func (x *SandboxTemplate) Reset() { *x = SandboxTemplate{} - mi := &file_openshell_proto_msgTypes[20] + mi := &file_openshell_proto_msgTypes[21] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2267,7 +2437,7 @@ func (x *SandboxTemplate) String() string { func (*SandboxTemplate) ProtoMessage() {} func (x *SandboxTemplate) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[20] + mi := &file_openshell_proto_msgTypes[21] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2280,7 +2450,7 @@ func (x *SandboxTemplate) ProtoReflect() protoreflect.Message { // Deprecated: Use SandboxTemplate.ProtoReflect.Descriptor instead. func (*SandboxTemplate) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{20} + return file_openshell_proto_rawDescGZIP(), []int{21} } func (x *SandboxTemplate) GetImage() string { @@ -2364,7 +2534,7 @@ type SandboxWorkloadTemplate struct { func (x *SandboxWorkloadTemplate) Reset() { *x = SandboxWorkloadTemplate{} - mi := &file_openshell_proto_msgTypes[21] + mi := &file_openshell_proto_msgTypes[22] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2376,7 +2546,7 @@ func (x *SandboxWorkloadTemplate) String() string { func (*SandboxWorkloadTemplate) ProtoMessage() {} func (x *SandboxWorkloadTemplate) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[21] + mi := &file_openshell_proto_msgTypes[22] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2389,7 +2559,7 @@ func (x *SandboxWorkloadTemplate) ProtoReflect() protoreflect.Message { // Deprecated: Use SandboxWorkloadTemplate.ProtoReflect.Descriptor instead. func (*SandboxWorkloadTemplate) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{21} + return file_openshell_proto_rawDescGZIP(), []int{22} } func (x *SandboxWorkloadTemplate) GetMetadata() *datamodelv1.ObjectMeta { @@ -2420,7 +2590,7 @@ type SandboxWorkloadTemplateSpec struct { func (x *SandboxWorkloadTemplateSpec) Reset() { *x = SandboxWorkloadTemplateSpec{} - mi := &file_openshell_proto_msgTypes[22] + mi := &file_openshell_proto_msgTypes[23] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2432,7 +2602,7 @@ func (x *SandboxWorkloadTemplateSpec) String() string { func (*SandboxWorkloadTemplateSpec) ProtoMessage() {} func (x *SandboxWorkloadTemplateSpec) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[22] + mi := &file_openshell_proto_msgTypes[23] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2445,7 +2615,7 @@ func (x *SandboxWorkloadTemplateSpec) ProtoReflect() protoreflect.Message { // Deprecated: Use SandboxWorkloadTemplateSpec.ProtoReflect.Descriptor instead. func (*SandboxWorkloadTemplateSpec) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{22} + return file_openshell_proto_rawDescGZIP(), []int{23} } func (x *SandboxWorkloadTemplateSpec) GetWorkload() *SandboxWorkloadConfig { @@ -2483,7 +2653,7 @@ type SandboxWorkloadConfig struct { func (x *SandboxWorkloadConfig) Reset() { *x = SandboxWorkloadConfig{} - mi := &file_openshell_proto_msgTypes[23] + mi := &file_openshell_proto_msgTypes[24] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2495,7 +2665,7 @@ func (x *SandboxWorkloadConfig) String() string { func (*SandboxWorkloadConfig) ProtoMessage() {} func (x *SandboxWorkloadConfig) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[23] + mi := &file_openshell_proto_msgTypes[24] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2508,7 +2678,7 @@ func (x *SandboxWorkloadConfig) ProtoReflect() protoreflect.Message { // Deprecated: Use SandboxWorkloadConfig.ProtoReflect.Descriptor instead. func (*SandboxWorkloadConfig) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{23} + return file_openshell_proto_rawDescGZIP(), []int{24} } func (x *SandboxWorkloadConfig) GetImage() string { @@ -2548,7 +2718,7 @@ type SandboxResources struct { func (x *SandboxResources) Reset() { *x = SandboxResources{} - mi := &file_openshell_proto_msgTypes[24] + mi := &file_openshell_proto_msgTypes[25] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2560,7 +2730,7 @@ func (x *SandboxResources) String() string { func (*SandboxResources) ProtoMessage() {} func (x *SandboxResources) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[24] + mi := &file_openshell_proto_msgTypes[25] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2573,7 +2743,7 @@ func (x *SandboxResources) ProtoReflect() protoreflect.Message { // Deprecated: Use SandboxResources.ProtoReflect.Descriptor instead. func (*SandboxResources) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{24} + return file_openshell_proto_rawDescGZIP(), []int{25} } func (x *SandboxResources) GetCpu() string { @@ -2606,7 +2776,7 @@ type SandboxServiceLevel struct { func (x *SandboxServiceLevel) Reset() { *x = SandboxServiceLevel{} - mi := &file_openshell_proto_msgTypes[25] + mi := &file_openshell_proto_msgTypes[26] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2618,7 +2788,7 @@ func (x *SandboxServiceLevel) String() string { func (*SandboxServiceLevel) ProtoMessage() {} func (x *SandboxServiceLevel) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[25] + mi := &file_openshell_proto_msgTypes[26] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2631,7 +2801,7 @@ func (x *SandboxServiceLevel) ProtoReflect() protoreflect.Message { // Deprecated: Use SandboxServiceLevel.ProtoReflect.Descriptor instead. func (*SandboxServiceLevel) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{25} + return file_openshell_proto_rawDescGZIP(), []int{26} } func (x *SandboxServiceLevel) GetStartup() *SandboxStartup { @@ -2651,7 +2821,7 @@ type SandboxStartup struct { func (x *SandboxStartup) Reset() { *x = SandboxStartup{} - mi := &file_openshell_proto_msgTypes[26] + mi := &file_openshell_proto_msgTypes[27] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2663,7 +2833,7 @@ func (x *SandboxStartup) String() string { func (*SandboxStartup) ProtoMessage() {} func (x *SandboxStartup) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[26] + mi := &file_openshell_proto_msgTypes[27] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2676,7 +2846,7 @@ func (x *SandboxStartup) ProtoReflect() protoreflect.Message { // Deprecated: Use SandboxStartup.ProtoReflect.Descriptor instead. func (*SandboxStartup) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{26} + return file_openshell_proto_rawDescGZIP(), []int{27} } func (x *SandboxStartup) GetReadyWithin() *durationpb.Duration { @@ -2703,7 +2873,7 @@ type SandboxWorkloadTemplateProvenance struct { func (x *SandboxWorkloadTemplateProvenance) Reset() { *x = SandboxWorkloadTemplateProvenance{} - mi := &file_openshell_proto_msgTypes[27] + mi := &file_openshell_proto_msgTypes[28] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2715,7 +2885,7 @@ func (x *SandboxWorkloadTemplateProvenance) String() string { func (*SandboxWorkloadTemplateProvenance) ProtoMessage() {} func (x *SandboxWorkloadTemplateProvenance) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[27] + mi := &file_openshell_proto_msgTypes[28] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2728,7 +2898,7 @@ func (x *SandboxWorkloadTemplateProvenance) ProtoReflect() protoreflect.Message // Deprecated: Use SandboxWorkloadTemplateProvenance.ProtoReflect.Descriptor instead. func (*SandboxWorkloadTemplateProvenance) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{27} + return file_openshell_proto_rawDescGZIP(), []int{28} } func (x *SandboxWorkloadTemplateProvenance) GetName() string { @@ -2781,7 +2951,7 @@ type SandboxStatus struct { func (x *SandboxStatus) Reset() { *x = SandboxStatus{} - mi := &file_openshell_proto_msgTypes[28] + mi := &file_openshell_proto_msgTypes[29] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2793,7 +2963,7 @@ func (x *SandboxStatus) String() string { func (*SandboxStatus) ProtoMessage() {} func (x *SandboxStatus) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[28] + mi := &file_openshell_proto_msgTypes[29] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2806,7 +2976,7 @@ func (x *SandboxStatus) ProtoReflect() protoreflect.Message { // Deprecated: Use SandboxStatus.ProtoReflect.Descriptor instead. func (*SandboxStatus) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{28} + return file_openshell_proto_rawDescGZIP(), []int{29} } func (x *SandboxStatus) GetSandboxName() string { @@ -2898,7 +3068,7 @@ type SandboxCondition struct { func (x *SandboxCondition) Reset() { *x = SandboxCondition{} - mi := &file_openshell_proto_msgTypes[29] + mi := &file_openshell_proto_msgTypes[30] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2910,7 +3080,7 @@ func (x *SandboxCondition) String() string { func (*SandboxCondition) ProtoMessage() {} func (x *SandboxCondition) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[29] + mi := &file_openshell_proto_msgTypes[30] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2923,7 +3093,7 @@ func (x *SandboxCondition) ProtoReflect() protoreflect.Message { // Deprecated: Use SandboxCondition.ProtoReflect.Descriptor instead. func (*SandboxCondition) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{29} + return file_openshell_proto_rawDescGZIP(), []int{30} } func (x *SandboxCondition) GetType() string { @@ -2982,7 +3152,7 @@ type PlatformEvent struct { func (x *PlatformEvent) Reset() { *x = PlatformEvent{} - mi := &file_openshell_proto_msgTypes[30] + mi := &file_openshell_proto_msgTypes[31] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2994,7 +3164,7 @@ func (x *PlatformEvent) String() string { func (*PlatformEvent) ProtoMessage() {} func (x *PlatformEvent) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[30] + mi := &file_openshell_proto_msgTypes[31] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3007,7 +3177,7 @@ func (x *PlatformEvent) ProtoReflect() protoreflect.Message { // Deprecated: Use PlatformEvent.ProtoReflect.Descriptor instead. func (*PlatformEvent) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{30} + return file_openshell_proto_rawDescGZIP(), []int{31} } func (x *PlatformEvent) GetEventTime() *timestamppb.Timestamp { @@ -3079,7 +3249,7 @@ type CreateSandboxRequest struct { func (x *CreateSandboxRequest) Reset() { *x = CreateSandboxRequest{} - mi := &file_openshell_proto_msgTypes[31] + mi := &file_openshell_proto_msgTypes[32] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3091,7 +3261,7 @@ func (x *CreateSandboxRequest) String() string { func (*CreateSandboxRequest) ProtoMessage() {} func (x *CreateSandboxRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[31] + mi := &file_openshell_proto_msgTypes[32] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3104,7 +3274,7 @@ func (x *CreateSandboxRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use CreateSandboxRequest.ProtoReflect.Descriptor instead. func (*CreateSandboxRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{31} + return file_openshell_proto_rawDescGZIP(), []int{32} } func (x *CreateSandboxRequest) GetSpec() *SandboxSpec { @@ -3177,7 +3347,7 @@ type CreateSandboxTemplateRequest struct { func (x *CreateSandboxTemplateRequest) Reset() { *x = CreateSandboxTemplateRequest{} - mi := &file_openshell_proto_msgTypes[32] + mi := &file_openshell_proto_msgTypes[33] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3189,7 +3359,7 @@ func (x *CreateSandboxTemplateRequest) String() string { func (*CreateSandboxTemplateRequest) ProtoMessage() {} func (x *CreateSandboxTemplateRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[32] + mi := &file_openshell_proto_msgTypes[33] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3202,7 +3372,7 @@ func (x *CreateSandboxTemplateRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use CreateSandboxTemplateRequest.ProtoReflect.Descriptor instead. func (*CreateSandboxTemplateRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{32} + return file_openshell_proto_rawDescGZIP(), []int{33} } func (x *CreateSandboxTemplateRequest) GetTemplate() *SandboxWorkloadTemplate { @@ -3237,7 +3407,7 @@ type GetSandboxTemplateRequest struct { func (x *GetSandboxTemplateRequest) Reset() { *x = GetSandboxTemplateRequest{} - mi := &file_openshell_proto_msgTypes[33] + mi := &file_openshell_proto_msgTypes[34] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3249,7 +3419,7 @@ func (x *GetSandboxTemplateRequest) String() string { func (*GetSandboxTemplateRequest) ProtoMessage() {} func (x *GetSandboxTemplateRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[33] + mi := &file_openshell_proto_msgTypes[34] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3262,7 +3432,7 @@ func (x *GetSandboxTemplateRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetSandboxTemplateRequest.ProtoReflect.Descriptor instead. func (*GetSandboxTemplateRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{33} + return file_openshell_proto_rawDescGZIP(), []int{34} } func (x *GetSandboxTemplateRequest) GetName() string { @@ -3297,7 +3467,7 @@ type ListSandboxTemplatesRequest struct { func (x *ListSandboxTemplatesRequest) Reset() { *x = ListSandboxTemplatesRequest{} - mi := &file_openshell_proto_msgTypes[34] + mi := &file_openshell_proto_msgTypes[35] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3309,7 +3479,7 @@ func (x *ListSandboxTemplatesRequest) String() string { func (*ListSandboxTemplatesRequest) ProtoMessage() {} func (x *ListSandboxTemplatesRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[34] + mi := &file_openshell_proto_msgTypes[35] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3322,7 +3492,7 @@ func (x *ListSandboxTemplatesRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListSandboxTemplatesRequest.ProtoReflect.Descriptor instead. func (*ListSandboxTemplatesRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{34} + return file_openshell_proto_rawDescGZIP(), []int{35} } func (x *ListSandboxTemplatesRequest) GetPageSize() int32 { @@ -3369,7 +3539,7 @@ type DeleteSandboxTemplateRequest struct { func (x *DeleteSandboxTemplateRequest) Reset() { *x = DeleteSandboxTemplateRequest{} - mi := &file_openshell_proto_msgTypes[35] + mi := &file_openshell_proto_msgTypes[36] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3381,7 +3551,7 @@ func (x *DeleteSandboxTemplateRequest) String() string { func (*DeleteSandboxTemplateRequest) ProtoMessage() {} func (x *DeleteSandboxTemplateRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[35] + mi := &file_openshell_proto_msgTypes[36] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3394,7 +3564,7 @@ func (x *DeleteSandboxTemplateRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteSandboxTemplateRequest.ProtoReflect.Descriptor instead. func (*DeleteSandboxTemplateRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{35} + return file_openshell_proto_rawDescGZIP(), []int{36} } func (x *DeleteSandboxTemplateRequest) GetName() string { @@ -3434,7 +3604,7 @@ type SandboxTemplateResponse struct { func (x *SandboxTemplateResponse) Reset() { *x = SandboxTemplateResponse{} - mi := &file_openshell_proto_msgTypes[36] + mi := &file_openshell_proto_msgTypes[37] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3446,7 +3616,7 @@ func (x *SandboxTemplateResponse) String() string { func (*SandboxTemplateResponse) ProtoMessage() {} func (x *SandboxTemplateResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[36] + mi := &file_openshell_proto_msgTypes[37] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3459,7 +3629,7 @@ func (x *SandboxTemplateResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use SandboxTemplateResponse.ProtoReflect.Descriptor instead. func (*SandboxTemplateResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{36} + return file_openshell_proto_rawDescGZIP(), []int{37} } func (x *SandboxTemplateResponse) GetTemplate() *SandboxWorkloadTemplate { @@ -3480,7 +3650,7 @@ type ListSandboxTemplatesResponse struct { func (x *ListSandboxTemplatesResponse) Reset() { *x = ListSandboxTemplatesResponse{} - mi := &file_openshell_proto_msgTypes[37] + mi := &file_openshell_proto_msgTypes[38] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3492,7 +3662,7 @@ func (x *ListSandboxTemplatesResponse) String() string { func (*ListSandboxTemplatesResponse) ProtoMessage() {} func (x *ListSandboxTemplatesResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[37] + mi := &file_openshell_proto_msgTypes[38] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3505,7 +3675,7 @@ func (x *ListSandboxTemplatesResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListSandboxTemplatesResponse.ProtoReflect.Descriptor instead. func (*ListSandboxTemplatesResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{37} + return file_openshell_proto_rawDescGZIP(), []int{38} } func (x *ListSandboxTemplatesResponse) GetTemplates() []*SandboxWorkloadTemplate { @@ -3531,7 +3701,7 @@ type DeleteSandboxTemplateResponse struct { func (x *DeleteSandboxTemplateResponse) Reset() { *x = DeleteSandboxTemplateResponse{} - mi := &file_openshell_proto_msgTypes[38] + mi := &file_openshell_proto_msgTypes[39] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3543,7 +3713,7 @@ func (x *DeleteSandboxTemplateResponse) String() string { func (*DeleteSandboxTemplateResponse) ProtoMessage() {} func (x *DeleteSandboxTemplateResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[38] + mi := &file_openshell_proto_msgTypes[39] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3556,7 +3726,7 @@ func (x *DeleteSandboxTemplateResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteSandboxTemplateResponse.ProtoReflect.Descriptor instead. func (*DeleteSandboxTemplateResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{38} + return file_openshell_proto_rawDescGZIP(), []int{39} } func (x *DeleteSandboxTemplateResponse) GetOutcome() DeletionOutcome { @@ -3584,7 +3754,7 @@ type BeginRootfsTarStagingRequest struct { func (x *BeginRootfsTarStagingRequest) Reset() { *x = BeginRootfsTarStagingRequest{} - mi := &file_openshell_proto_msgTypes[39] + mi := &file_openshell_proto_msgTypes[40] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3596,7 +3766,7 @@ func (x *BeginRootfsTarStagingRequest) String() string { func (*BeginRootfsTarStagingRequest) ProtoMessage() {} func (x *BeginRootfsTarStagingRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[39] + mi := &file_openshell_proto_msgTypes[40] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3609,7 +3779,7 @@ func (x *BeginRootfsTarStagingRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use BeginRootfsTarStagingRequest.ProtoReflect.Descriptor instead. func (*BeginRootfsTarStagingRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{39} + return file_openshell_proto_rawDescGZIP(), []int{40} } func (x *BeginRootfsTarStagingRequest) GetFileName() string { @@ -3652,7 +3822,7 @@ type BeginRootfsTarStagingResponse struct { func (x *BeginRootfsTarStagingResponse) Reset() { *x = BeginRootfsTarStagingResponse{} - mi := &file_openshell_proto_msgTypes[40] + mi := &file_openshell_proto_msgTypes[41] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3664,7 +3834,7 @@ func (x *BeginRootfsTarStagingResponse) String() string { func (*BeginRootfsTarStagingResponse) ProtoMessage() {} func (x *BeginRootfsTarStagingResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[40] + mi := &file_openshell_proto_msgTypes[41] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3677,7 +3847,7 @@ func (x *BeginRootfsTarStagingResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use BeginRootfsTarStagingResponse.ProtoReflect.Descriptor instead. func (*BeginRootfsTarStagingResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{40} + return file_openshell_proto_rawDescGZIP(), []int{41} } func (x *BeginRootfsTarStagingResponse) GetStagingToken() string { @@ -3721,7 +3891,7 @@ type GetSandboxRequest struct { func (x *GetSandboxRequest) Reset() { *x = GetSandboxRequest{} - mi := &file_openshell_proto_msgTypes[41] + mi := &file_openshell_proto_msgTypes[42] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3733,7 +3903,7 @@ func (x *GetSandboxRequest) String() string { func (*GetSandboxRequest) ProtoMessage() {} func (x *GetSandboxRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[41] + mi := &file_openshell_proto_msgTypes[42] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3746,7 +3916,7 @@ func (x *GetSandboxRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetSandboxRequest.ProtoReflect.Descriptor instead. func (*GetSandboxRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{41} + return file_openshell_proto_rawDescGZIP(), []int{42} } func (x *GetSandboxRequest) GetName() string { @@ -3782,7 +3952,7 @@ type ListSandboxesRequest struct { func (x *ListSandboxesRequest) Reset() { *x = ListSandboxesRequest{} - mi := &file_openshell_proto_msgTypes[42] + mi := &file_openshell_proto_msgTypes[43] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3794,7 +3964,7 @@ func (x *ListSandboxesRequest) String() string { func (*ListSandboxesRequest) ProtoMessage() {} func (x *ListSandboxesRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[42] + mi := &file_openshell_proto_msgTypes[43] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3807,7 +3977,7 @@ func (x *ListSandboxesRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListSandboxesRequest.ProtoReflect.Descriptor instead. func (*ListSandboxesRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{42} + return file_openshell_proto_rawDescGZIP(), []int{43} } func (x *ListSandboxesRequest) GetPageSize() int32 { @@ -3851,7 +4021,7 @@ type ListSandboxProvidersRequest struct { func (x *ListSandboxProvidersRequest) Reset() { *x = ListSandboxProvidersRequest{} - mi := &file_openshell_proto_msgTypes[43] + mi := &file_openshell_proto_msgTypes[44] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3863,7 +4033,7 @@ func (x *ListSandboxProvidersRequest) String() string { func (*ListSandboxProvidersRequest) ProtoMessage() {} func (x *ListSandboxProvidersRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[43] + mi := &file_openshell_proto_msgTypes[44] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3876,7 +4046,7 @@ func (x *ListSandboxProvidersRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListSandboxProvidersRequest.ProtoReflect.Descriptor instead. func (*ListSandboxProvidersRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{43} + return file_openshell_proto_rawDescGZIP(), []int{44} } func (x *ListSandboxProvidersRequest) GetSandboxName() string { @@ -3916,7 +4086,7 @@ type AttachSandboxProviderRequest struct { func (x *AttachSandboxProviderRequest) Reset() { *x = AttachSandboxProviderRequest{} - mi := &file_openshell_proto_msgTypes[44] + mi := &file_openshell_proto_msgTypes[45] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3928,7 +4098,7 @@ func (x *AttachSandboxProviderRequest) String() string { func (*AttachSandboxProviderRequest) ProtoMessage() {} func (x *AttachSandboxProviderRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[44] + mi := &file_openshell_proto_msgTypes[45] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3941,7 +4111,7 @@ func (x *AttachSandboxProviderRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use AttachSandboxProviderRequest.ProtoReflect.Descriptor instead. func (*AttachSandboxProviderRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{44} + return file_openshell_proto_rawDescGZIP(), []int{45} } func (x *AttachSandboxProviderRequest) GetSandboxName() string { @@ -4002,7 +4172,7 @@ type DetachSandboxProviderRequest struct { func (x *DetachSandboxProviderRequest) Reset() { *x = DetachSandboxProviderRequest{} - mi := &file_openshell_proto_msgTypes[45] + mi := &file_openshell_proto_msgTypes[46] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4014,7 +4184,7 @@ func (x *DetachSandboxProviderRequest) String() string { func (*DetachSandboxProviderRequest) ProtoMessage() {} func (x *DetachSandboxProviderRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[45] + mi := &file_openshell_proto_msgTypes[46] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4027,7 +4197,7 @@ func (x *DetachSandboxProviderRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use DetachSandboxProviderRequest.ProtoReflect.Descriptor instead. func (*DetachSandboxProviderRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{45} + return file_openshell_proto_rawDescGZIP(), []int{46} } func (x *DetachSandboxProviderRequest) GetSandboxName() string { @@ -4084,7 +4254,7 @@ type DeleteSandboxRequest struct { func (x *DeleteSandboxRequest) Reset() { *x = DeleteSandboxRequest{} - mi := &file_openshell_proto_msgTypes[46] + mi := &file_openshell_proto_msgTypes[47] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4096,7 +4266,7 @@ func (x *DeleteSandboxRequest) String() string { func (*DeleteSandboxRequest) ProtoMessage() {} func (x *DeleteSandboxRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[46] + mi := &file_openshell_proto_msgTypes[47] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4109,7 +4279,7 @@ func (x *DeleteSandboxRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteSandboxRequest.ProtoReflect.Descriptor instead. func (*DeleteSandboxRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{46} + return file_openshell_proto_rawDescGZIP(), []int{47} } func (x *DeleteSandboxRequest) GetName() string { @@ -4156,7 +4326,7 @@ type StopSandboxRequest struct { func (x *StopSandboxRequest) Reset() { *x = StopSandboxRequest{} - mi := &file_openshell_proto_msgTypes[47] + mi := &file_openshell_proto_msgTypes[48] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4168,7 +4338,7 @@ func (x *StopSandboxRequest) String() string { func (*StopSandboxRequest) ProtoMessage() {} func (x *StopSandboxRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[47] + mi := &file_openshell_proto_msgTypes[48] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4181,7 +4351,7 @@ func (x *StopSandboxRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use StopSandboxRequest.ProtoReflect.Descriptor instead. func (*StopSandboxRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{47} + return file_openshell_proto_rawDescGZIP(), []int{48} } func (x *StopSandboxRequest) GetName() string { @@ -4221,7 +4391,7 @@ type StartSandboxRequest struct { func (x *StartSandboxRequest) Reset() { *x = StartSandboxRequest{} - mi := &file_openshell_proto_msgTypes[48] + mi := &file_openshell_proto_msgTypes[49] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4233,7 +4403,7 @@ func (x *StartSandboxRequest) String() string { func (*StartSandboxRequest) ProtoMessage() {} func (x *StartSandboxRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[48] + mi := &file_openshell_proto_msgTypes[49] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4246,7 +4416,7 @@ func (x *StartSandboxRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use StartSandboxRequest.ProtoReflect.Descriptor instead. func (*StartSandboxRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{48} + return file_openshell_proto_rawDescGZIP(), []int{49} } func (x *StartSandboxRequest) GetName() string { @@ -4280,7 +4450,7 @@ type SandboxResponse struct { func (x *SandboxResponse) Reset() { *x = SandboxResponse{} - mi := &file_openshell_proto_msgTypes[49] + mi := &file_openshell_proto_msgTypes[50] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4292,7 +4462,7 @@ func (x *SandboxResponse) String() string { func (*SandboxResponse) ProtoMessage() {} func (x *SandboxResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[49] + mi := &file_openshell_proto_msgTypes[50] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4305,7 +4475,7 @@ func (x *SandboxResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use SandboxResponse.ProtoReflect.Descriptor instead. func (*SandboxResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{49} + return file_openshell_proto_rawDescGZIP(), []int{50} } func (x *SandboxResponse) GetSandbox() *Sandbox { @@ -4327,7 +4497,7 @@ type ListSandboxesResponse struct { func (x *ListSandboxesResponse) Reset() { *x = ListSandboxesResponse{} - mi := &file_openshell_proto_msgTypes[50] + mi := &file_openshell_proto_msgTypes[51] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4339,7 +4509,7 @@ func (x *ListSandboxesResponse) String() string { func (*ListSandboxesResponse) ProtoMessage() {} func (x *ListSandboxesResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[50] + mi := &file_openshell_proto_msgTypes[51] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4352,7 +4522,7 @@ func (x *ListSandboxesResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListSandboxesResponse.ProtoReflect.Descriptor instead. func (*ListSandboxesResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{50} + return file_openshell_proto_rawDescGZIP(), []int{51} } func (x *ListSandboxesResponse) GetSandboxes() []*Sandbox { @@ -4379,7 +4549,7 @@ type ListSandboxProvidersResponse struct { func (x *ListSandboxProvidersResponse) Reset() { *x = ListSandboxProvidersResponse{} - mi := &file_openshell_proto_msgTypes[51] + mi := &file_openshell_proto_msgTypes[52] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4391,7 +4561,7 @@ func (x *ListSandboxProvidersResponse) String() string { func (*ListSandboxProvidersResponse) ProtoMessage() {} func (x *ListSandboxProvidersResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[51] + mi := &file_openshell_proto_msgTypes[52] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4404,7 +4574,7 @@ func (x *ListSandboxProvidersResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListSandboxProvidersResponse.ProtoReflect.Descriptor instead. func (*ListSandboxProvidersResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{51} + return file_openshell_proto_rawDescGZIP(), []int{52} } func (x *ListSandboxProvidersResponse) GetProviders() []*datamodelv1.Provider { @@ -4428,7 +4598,7 @@ type AttachSandboxProviderResponse struct { func (x *AttachSandboxProviderResponse) Reset() { *x = AttachSandboxProviderResponse{} - mi := &file_openshell_proto_msgTypes[52] + mi := &file_openshell_proto_msgTypes[53] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4440,7 +4610,7 @@ func (x *AttachSandboxProviderResponse) String() string { func (*AttachSandboxProviderResponse) ProtoMessage() {} func (x *AttachSandboxProviderResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[52] + mi := &file_openshell_proto_msgTypes[53] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4453,7 +4623,7 @@ func (x *AttachSandboxProviderResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use AttachSandboxProviderResponse.ProtoReflect.Descriptor instead. func (*AttachSandboxProviderResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{52} + return file_openshell_proto_rawDescGZIP(), []int{53} } func (x *AttachSandboxProviderResponse) GetSandbox() *Sandbox { @@ -4491,7 +4661,7 @@ type DetachSandboxProviderResponse struct { func (x *DetachSandboxProviderResponse) Reset() { *x = DetachSandboxProviderResponse{} - mi := &file_openshell_proto_msgTypes[53] + mi := &file_openshell_proto_msgTypes[54] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4503,7 +4673,7 @@ func (x *DetachSandboxProviderResponse) String() string { func (*DetachSandboxProviderResponse) ProtoMessage() {} func (x *DetachSandboxProviderResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[53] + mi := &file_openshell_proto_msgTypes[54] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4516,7 +4686,7 @@ func (x *DetachSandboxProviderResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use DetachSandboxProviderResponse.ProtoReflect.Descriptor instead. func (*DetachSandboxProviderResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{53} + return file_openshell_proto_rawDescGZIP(), []int{54} } func (x *DetachSandboxProviderResponse) GetSandbox() *Sandbox { @@ -4558,7 +4728,7 @@ type ProviderDesiredIdentity struct { func (x *ProviderDesiredIdentity) Reset() { *x = ProviderDesiredIdentity{} - mi := &file_openshell_proto_msgTypes[54] + mi := &file_openshell_proto_msgTypes[55] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4570,7 +4740,7 @@ func (x *ProviderDesiredIdentity) String() string { func (*ProviderDesiredIdentity) ProtoMessage() {} func (x *ProviderDesiredIdentity) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[54] + mi := &file_openshell_proto_msgTypes[55] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4583,7 +4753,7 @@ func (x *ProviderDesiredIdentity) ProtoReflect() protoreflect.Message { // Deprecated: Use ProviderDesiredIdentity.ProtoReflect.Descriptor instead. func (*ProviderDesiredIdentity) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{54} + return file_openshell_proto_rawDescGZIP(), []int{55} } func (x *ProviderDesiredIdentity) GetSandboxId() string { @@ -4658,7 +4828,7 @@ type ConfigSnapshotRevision struct { func (x *ConfigSnapshotRevision) Reset() { *x = ConfigSnapshotRevision{} - mi := &file_openshell_proto_msgTypes[55] + mi := &file_openshell_proto_msgTypes[56] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4670,7 +4840,7 @@ func (x *ConfigSnapshotRevision) String() string { func (*ConfigSnapshotRevision) ProtoMessage() {} func (x *ConfigSnapshotRevision) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[55] + mi := &file_openshell_proto_msgTypes[56] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4683,7 +4853,7 @@ func (x *ConfigSnapshotRevision) ProtoReflect() protoreflect.Message { // Deprecated: Use ConfigSnapshotRevision.ProtoReflect.Descriptor instead. func (*ConfigSnapshotRevision) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{55} + return file_openshell_proto_rawDescGZIP(), []int{56} } func (x *ConfigSnapshotRevision) GetComponent() isConfigSnapshotRevision_Component { @@ -4760,7 +4930,7 @@ type SandboxConfigRevision struct { func (x *SandboxConfigRevision) Reset() { *x = SandboxConfigRevision{} - mi := &file_openshell_proto_msgTypes[56] + mi := &file_openshell_proto_msgTypes[57] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4772,7 +4942,7 @@ func (x *SandboxConfigRevision) String() string { func (*SandboxConfigRevision) ProtoMessage() {} func (x *SandboxConfigRevision) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[56] + mi := &file_openshell_proto_msgTypes[57] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4785,7 +4955,7 @@ func (x *SandboxConfigRevision) ProtoReflect() protoreflect.Message { // Deprecated: Use SandboxConfigRevision.ProtoReflect.Descriptor instead. func (*SandboxConfigRevision) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{56} + return file_openshell_proto_rawDescGZIP(), []int{57} } func (x *SandboxConfigRevision) GetConfigRevision() uint64 { @@ -4844,7 +5014,7 @@ type ConfigUpdateOperation struct { func (x *ConfigUpdateOperation) Reset() { *x = ConfigUpdateOperation{} - mi := &file_openshell_proto_msgTypes[57] + mi := &file_openshell_proto_msgTypes[58] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4856,7 +5026,7 @@ func (x *ConfigUpdateOperation) String() string { func (*ConfigUpdateOperation) ProtoMessage() {} func (x *ConfigUpdateOperation) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[57] + mi := &file_openshell_proto_msgTypes[58] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4869,7 +5039,7 @@ func (x *ConfigUpdateOperation) ProtoReflect() protoreflect.Message { // Deprecated: Use ConfigUpdateOperation.ProtoReflect.Descriptor instead. func (*ConfigUpdateOperation) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{57} + return file_openshell_proto_rawDescGZIP(), []int{58} } func (x *ConfigUpdateOperation) GetOperationId() string { @@ -4959,7 +5129,7 @@ type ProviderMutationReceipt struct { func (x *ProviderMutationReceipt) Reset() { *x = ProviderMutationReceipt{} - mi := &file_openshell_proto_msgTypes[58] + mi := &file_openshell_proto_msgTypes[59] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4971,7 +5141,7 @@ func (x *ProviderMutationReceipt) String() string { func (*ProviderMutationReceipt) ProtoMessage() {} func (x *ProviderMutationReceipt) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[58] + mi := &file_openshell_proto_msgTypes[59] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4984,7 +5154,7 @@ func (x *ProviderMutationReceipt) ProtoReflect() protoreflect.Message { // Deprecated: Use ProviderMutationReceipt.ProtoReflect.Descriptor instead. func (*ProviderMutationReceipt) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{58} + return file_openshell_proto_rawDescGZIP(), []int{59} } func (x *ProviderMutationReceipt) GetReceiptId() string { @@ -5060,7 +5230,7 @@ type ProviderReadinessObservation struct { func (x *ProviderReadinessObservation) Reset() { *x = ProviderReadinessObservation{} - mi := &file_openshell_proto_msgTypes[59] + mi := &file_openshell_proto_msgTypes[60] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5072,7 +5242,7 @@ func (x *ProviderReadinessObservation) String() string { func (*ProviderReadinessObservation) ProtoMessage() {} func (x *ProviderReadinessObservation) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[59] + mi := &file_openshell_proto_msgTypes[60] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5085,7 +5255,7 @@ func (x *ProviderReadinessObservation) ProtoReflect() protoreflect.Message { // Deprecated: Use ProviderReadinessObservation.ProtoReflect.Descriptor instead. func (*ProviderReadinessObservation) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{59} + return file_openshell_proto_rawDescGZIP(), []int{60} } func (x *ProviderReadinessObservation) GetSessionId() string { @@ -5184,7 +5354,7 @@ type ProviderReadinessStatus struct { func (x *ProviderReadinessStatus) Reset() { *x = ProviderReadinessStatus{} - mi := &file_openshell_proto_msgTypes[60] + mi := &file_openshell_proto_msgTypes[61] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5196,7 +5366,7 @@ func (x *ProviderReadinessStatus) String() string { func (*ProviderReadinessStatus) ProtoMessage() {} func (x *ProviderReadinessStatus) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[60] + mi := &file_openshell_proto_msgTypes[61] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5209,7 +5379,7 @@ func (x *ProviderReadinessStatus) ProtoReflect() protoreflect.Message { // Deprecated: Use ProviderReadinessStatus.ProtoReflect.Descriptor instead. func (*ProviderReadinessStatus) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{60} + return file_openshell_proto_rawDescGZIP(), []int{61} } func (x *ProviderReadinessStatus) GetReceipt() *ProviderMutationReceipt { @@ -5282,7 +5452,7 @@ type GetSandboxProviderStatusRequest struct { func (x *GetSandboxProviderStatusRequest) Reset() { *x = GetSandboxProviderStatusRequest{} - mi := &file_openshell_proto_msgTypes[61] + mi := &file_openshell_proto_msgTypes[62] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5294,7 +5464,7 @@ func (x *GetSandboxProviderStatusRequest) String() string { func (*GetSandboxProviderStatusRequest) ProtoMessage() {} func (x *GetSandboxProviderStatusRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[61] + mi := &file_openshell_proto_msgTypes[62] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5307,7 +5477,7 @@ func (x *GetSandboxProviderStatusRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetSandboxProviderStatusRequest.ProtoReflect.Descriptor instead. func (*GetSandboxProviderStatusRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{61} + return file_openshell_proto_rawDescGZIP(), []int{62} } func (x *GetSandboxProviderStatusRequest) GetSandboxName() string { @@ -5347,7 +5517,7 @@ type GetSandboxProviderStatusResponse struct { func (x *GetSandboxProviderStatusResponse) Reset() { *x = GetSandboxProviderStatusResponse{} - mi := &file_openshell_proto_msgTypes[62] + mi := &file_openshell_proto_msgTypes[63] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5359,7 +5529,7 @@ func (x *GetSandboxProviderStatusResponse) String() string { func (*GetSandboxProviderStatusResponse) ProtoMessage() {} func (x *GetSandboxProviderStatusResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[62] + mi := &file_openshell_proto_msgTypes[63] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5372,7 +5542,7 @@ func (x *GetSandboxProviderStatusResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use GetSandboxProviderStatusResponse.ProtoReflect.Descriptor instead. func (*GetSandboxProviderStatusResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{62} + return file_openshell_proto_rawDescGZIP(), []int{63} } func (x *GetSandboxProviderStatusResponse) GetStatus() *ProviderReadinessStatus { @@ -5394,7 +5564,7 @@ type ReportProviderReadinessRequest struct { func (x *ReportProviderReadinessRequest) Reset() { *x = ReportProviderReadinessRequest{} - mi := &file_openshell_proto_msgTypes[63] + mi := &file_openshell_proto_msgTypes[64] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5406,7 +5576,7 @@ func (x *ReportProviderReadinessRequest) String() string { func (*ReportProviderReadinessRequest) ProtoMessage() {} func (x *ReportProviderReadinessRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[63] + mi := &file_openshell_proto_msgTypes[64] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5419,7 +5589,7 @@ func (x *ReportProviderReadinessRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ReportProviderReadinessRequest.ProtoReflect.Descriptor instead. func (*ReportProviderReadinessRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{63} + return file_openshell_proto_rawDescGZIP(), []int{64} } func (x *ReportProviderReadinessRequest) GetSandboxId() string { @@ -5449,7 +5619,7 @@ type ReportProviderReadinessResponse struct { func (x *ReportProviderReadinessResponse) Reset() { *x = ReportProviderReadinessResponse{} - mi := &file_openshell_proto_msgTypes[64] + mi := &file_openshell_proto_msgTypes[65] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5461,7 +5631,7 @@ func (x *ReportProviderReadinessResponse) String() string { func (*ReportProviderReadinessResponse) ProtoMessage() {} func (x *ReportProviderReadinessResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[64] + mi := &file_openshell_proto_msgTypes[65] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5474,7 +5644,7 @@ func (x *ReportProviderReadinessResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ReportProviderReadinessResponse.ProtoReflect.Descriptor instead. func (*ReportProviderReadinessResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{64} + return file_openshell_proto_rawDescGZIP(), []int{65} } func (x *ReportProviderReadinessResponse) GetAcceptedSequence() uint64 { @@ -5511,7 +5681,7 @@ type DeleteSandboxResponse struct { func (x *DeleteSandboxResponse) Reset() { *x = DeleteSandboxResponse{} - mi := &file_openshell_proto_msgTypes[65] + mi := &file_openshell_proto_msgTypes[66] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5523,7 +5693,7 @@ func (x *DeleteSandboxResponse) String() string { func (*DeleteSandboxResponse) ProtoMessage() {} func (x *DeleteSandboxResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[65] + mi := &file_openshell_proto_msgTypes[66] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5536,7 +5706,7 @@ func (x *DeleteSandboxResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteSandboxResponse.ProtoReflect.Descriptor instead. func (*DeleteSandboxResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{65} + return file_openshell_proto_rawDescGZIP(), []int{66} } func (x *DeleteSandboxResponse) GetOutcome() DeletionOutcome { @@ -5564,7 +5734,7 @@ type CreateSshSessionRequest struct { func (x *CreateSshSessionRequest) Reset() { *x = CreateSshSessionRequest{} - mi := &file_openshell_proto_msgTypes[66] + mi := &file_openshell_proto_msgTypes[67] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5576,7 +5746,7 @@ func (x *CreateSshSessionRequest) String() string { func (*CreateSshSessionRequest) ProtoMessage() {} func (x *CreateSshSessionRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[66] + mi := &file_openshell_proto_msgTypes[67] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5589,7 +5759,7 @@ func (x *CreateSshSessionRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use CreateSshSessionRequest.ProtoReflect.Descriptor instead. func (*CreateSshSessionRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{66} + return file_openshell_proto_rawDescGZIP(), []int{67} } func (x *CreateSshSessionRequest) GetSandboxId() string { @@ -5632,7 +5802,7 @@ type CreateSshSessionResponse struct { func (x *CreateSshSessionResponse) Reset() { *x = CreateSshSessionResponse{} - mi := &file_openshell_proto_msgTypes[67] + mi := &file_openshell_proto_msgTypes[68] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5644,7 +5814,7 @@ func (x *CreateSshSessionResponse) String() string { func (*CreateSshSessionResponse) ProtoMessage() {} func (x *CreateSshSessionResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[67] + mi := &file_openshell_proto_msgTypes[68] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5657,7 +5827,7 @@ func (x *CreateSshSessionResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use CreateSshSessionResponse.ProtoReflect.Descriptor instead. func (*CreateSshSessionResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{67} + return file_openshell_proto_rawDescGZIP(), []int{68} } func (x *CreateSshSessionResponse) GetSandboxId() string { @@ -5731,7 +5901,7 @@ type ExposeServiceRequest struct { func (x *ExposeServiceRequest) Reset() { *x = ExposeServiceRequest{} - mi := &file_openshell_proto_msgTypes[68] + mi := &file_openshell_proto_msgTypes[69] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5743,7 +5913,7 @@ func (x *ExposeServiceRequest) String() string { func (*ExposeServiceRequest) ProtoMessage() {} func (x *ExposeServiceRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[68] + mi := &file_openshell_proto_msgTypes[69] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5756,7 +5926,7 @@ func (x *ExposeServiceRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ExposeServiceRequest.ProtoReflect.Descriptor instead. func (*ExposeServiceRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{68} + return file_openshell_proto_rawDescGZIP(), []int{69} } func (x *ExposeServiceRequest) GetSandbox() string { @@ -5816,7 +5986,7 @@ type GetServiceRequest struct { func (x *GetServiceRequest) Reset() { *x = GetServiceRequest{} - mi := &file_openshell_proto_msgTypes[69] + mi := &file_openshell_proto_msgTypes[70] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5828,7 +5998,7 @@ func (x *GetServiceRequest) String() string { func (*GetServiceRequest) ProtoMessage() {} func (x *GetServiceRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[69] + mi := &file_openshell_proto_msgTypes[70] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5841,7 +6011,7 @@ func (x *GetServiceRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetServiceRequest.ProtoReflect.Descriptor instead. func (*GetServiceRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{69} + return file_openshell_proto_rawDescGZIP(), []int{70} } func (x *GetServiceRequest) GetSandbox() string { @@ -5884,7 +6054,7 @@ type ListServicesRequest struct { func (x *ListServicesRequest) Reset() { *x = ListServicesRequest{} - mi := &file_openshell_proto_msgTypes[70] + mi := &file_openshell_proto_msgTypes[71] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5896,7 +6066,7 @@ func (x *ListServicesRequest) String() string { func (*ListServicesRequest) ProtoMessage() {} func (x *ListServicesRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[70] + mi := &file_openshell_proto_msgTypes[71] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5909,7 +6079,7 @@ func (x *ListServicesRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListServicesRequest.ProtoReflect.Descriptor instead. func (*ListServicesRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{70} + return file_openshell_proto_rawDescGZIP(), []int{71} } func (x *ListServicesRequest) GetSandbox() string { @@ -5952,7 +6122,7 @@ type ListServicesResponse struct { func (x *ListServicesResponse) Reset() { *x = ListServicesResponse{} - mi := &file_openshell_proto_msgTypes[71] + mi := &file_openshell_proto_msgTypes[72] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5964,7 +6134,7 @@ func (x *ListServicesResponse) String() string { func (*ListServicesResponse) ProtoMessage() {} func (x *ListServicesResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[71] + mi := &file_openshell_proto_msgTypes[72] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5977,7 +6147,7 @@ func (x *ListServicesResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListServicesResponse.ProtoReflect.Descriptor instead. func (*ListServicesResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{71} + return file_openshell_proto_rawDescGZIP(), []int{72} } func (x *ListServicesResponse) GetServices() []*ServiceEndpointResponse { @@ -6013,7 +6183,7 @@ type DeleteServiceRequest struct { func (x *DeleteServiceRequest) Reset() { *x = DeleteServiceRequest{} - mi := &file_openshell_proto_msgTypes[72] + mi := &file_openshell_proto_msgTypes[73] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6025,7 +6195,7 @@ func (x *DeleteServiceRequest) String() string { func (*DeleteServiceRequest) ProtoMessage() {} func (x *DeleteServiceRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[72] + mi := &file_openshell_proto_msgTypes[73] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6038,7 +6208,7 @@ func (x *DeleteServiceRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteServiceRequest.ProtoReflect.Descriptor instead. func (*DeleteServiceRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{72} + return file_openshell_proto_rawDescGZIP(), []int{73} } func (x *DeleteServiceRequest) GetSandbox() string { @@ -6086,7 +6256,7 @@ type DeleteServiceResponse struct { func (x *DeleteServiceResponse) Reset() { *x = DeleteServiceResponse{} - mi := &file_openshell_proto_msgTypes[73] + mi := &file_openshell_proto_msgTypes[74] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6098,7 +6268,7 @@ func (x *DeleteServiceResponse) String() string { func (*DeleteServiceResponse) ProtoMessage() {} func (x *DeleteServiceResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[73] + mi := &file_openshell_proto_msgTypes[74] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6111,7 +6281,7 @@ func (x *DeleteServiceResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteServiceResponse.ProtoReflect.Descriptor instead. func (*DeleteServiceResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{73} + return file_openshell_proto_rawDescGZIP(), []int{74} } func (x *DeleteServiceResponse) GetOutcome() DeletionOutcome { @@ -6142,7 +6312,7 @@ type ServiceEndpoint struct { func (x *ServiceEndpoint) Reset() { *x = ServiceEndpoint{} - mi := &file_openshell_proto_msgTypes[74] + mi := &file_openshell_proto_msgTypes[75] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6154,7 +6324,7 @@ func (x *ServiceEndpoint) String() string { func (*ServiceEndpoint) ProtoMessage() {} func (x *ServiceEndpoint) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[74] + mi := &file_openshell_proto_msgTypes[75] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6167,7 +6337,7 @@ func (x *ServiceEndpoint) ProtoReflect() protoreflect.Message { // Deprecated: Use ServiceEndpoint.ProtoReflect.Descriptor instead. func (*ServiceEndpoint) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{74} + return file_openshell_proto_rawDescGZIP(), []int{75} } func (x *ServiceEndpoint) GetMetadata() *datamodelv1.ObjectMeta { @@ -6223,7 +6393,7 @@ type ServiceEndpointResponse struct { func (x *ServiceEndpointResponse) Reset() { *x = ServiceEndpointResponse{} - mi := &file_openshell_proto_msgTypes[75] + mi := &file_openshell_proto_msgTypes[76] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6235,7 +6405,7 @@ func (x *ServiceEndpointResponse) String() string { func (*ServiceEndpointResponse) ProtoMessage() {} func (x *ServiceEndpointResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[75] + mi := &file_openshell_proto_msgTypes[76] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6248,7 +6418,7 @@ func (x *ServiceEndpointResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ServiceEndpointResponse.ProtoReflect.Descriptor instead. func (*ServiceEndpointResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{75} + return file_openshell_proto_rawDescGZIP(), []int{76} } func (x *ServiceEndpointResponse) GetEndpoint() *ServiceEndpoint { @@ -6279,7 +6449,7 @@ type RevokeSshSessionRequest struct { func (x *RevokeSshSessionRequest) Reset() { *x = RevokeSshSessionRequest{} - mi := &file_openshell_proto_msgTypes[76] + mi := &file_openshell_proto_msgTypes[77] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6291,7 +6461,7 @@ func (x *RevokeSshSessionRequest) String() string { func (*RevokeSshSessionRequest) ProtoMessage() {} func (x *RevokeSshSessionRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[76] + mi := &file_openshell_proto_msgTypes[77] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6304,7 +6474,7 @@ func (x *RevokeSshSessionRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use RevokeSshSessionRequest.ProtoReflect.Descriptor instead. func (*RevokeSshSessionRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{76} + return file_openshell_proto_rawDescGZIP(), []int{77} } func (x *RevokeSshSessionRequest) GetToken() string { @@ -6331,7 +6501,7 @@ type RevokeSshSessionResponse struct { func (x *RevokeSshSessionResponse) Reset() { *x = RevokeSshSessionResponse{} - mi := &file_openshell_proto_msgTypes[77] + mi := &file_openshell_proto_msgTypes[78] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6343,7 +6513,7 @@ func (x *RevokeSshSessionResponse) String() string { func (*RevokeSshSessionResponse) ProtoMessage() {} func (x *RevokeSshSessionResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[77] + mi := &file_openshell_proto_msgTypes[78] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6356,7 +6526,7 @@ func (x *RevokeSshSessionResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use RevokeSshSessionResponse.ProtoReflect.Descriptor instead. func (*RevokeSshSessionResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{77} + return file_openshell_proto_rawDescGZIP(), []int{78} } func (x *RevokeSshSessionResponse) GetOutcome() DeletionOutcome { @@ -6399,7 +6569,7 @@ type ExecSandboxRequest struct { func (x *ExecSandboxRequest) Reset() { *x = ExecSandboxRequest{} - mi := &file_openshell_proto_msgTypes[78] + mi := &file_openshell_proto_msgTypes[79] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6411,7 +6581,7 @@ func (x *ExecSandboxRequest) String() string { func (*ExecSandboxRequest) ProtoMessage() {} func (x *ExecSandboxRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[78] + mi := &file_openshell_proto_msgTypes[79] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6424,7 +6594,7 @@ func (x *ExecSandboxRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ExecSandboxRequest.ProtoReflect.Descriptor instead. func (*ExecSandboxRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{78} + return file_openshell_proto_rawDescGZIP(), []int{79} } func (x *ExecSandboxRequest) GetSandboxId() string { @@ -6507,7 +6677,7 @@ type ExecSandboxStdout struct { func (x *ExecSandboxStdout) Reset() { *x = ExecSandboxStdout{} - mi := &file_openshell_proto_msgTypes[79] + mi := &file_openshell_proto_msgTypes[80] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6519,7 +6689,7 @@ func (x *ExecSandboxStdout) String() string { func (*ExecSandboxStdout) ProtoMessage() {} func (x *ExecSandboxStdout) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[79] + mi := &file_openshell_proto_msgTypes[80] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6532,7 +6702,7 @@ func (x *ExecSandboxStdout) ProtoReflect() protoreflect.Message { // Deprecated: Use ExecSandboxStdout.ProtoReflect.Descriptor instead. func (*ExecSandboxStdout) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{79} + return file_openshell_proto_rawDescGZIP(), []int{80} } func (x *ExecSandboxStdout) GetData() []byte { @@ -6552,7 +6722,7 @@ type ExecSandboxStderr struct { func (x *ExecSandboxStderr) Reset() { *x = ExecSandboxStderr{} - mi := &file_openshell_proto_msgTypes[80] + mi := &file_openshell_proto_msgTypes[81] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6564,7 +6734,7 @@ func (x *ExecSandboxStderr) String() string { func (*ExecSandboxStderr) ProtoMessage() {} func (x *ExecSandboxStderr) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[80] + mi := &file_openshell_proto_msgTypes[81] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6577,7 +6747,7 @@ func (x *ExecSandboxStderr) ProtoReflect() protoreflect.Message { // Deprecated: Use ExecSandboxStderr.ProtoReflect.Descriptor instead. func (*ExecSandboxStderr) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{80} + return file_openshell_proto_rawDescGZIP(), []int{81} } func (x *ExecSandboxStderr) GetData() []byte { @@ -6597,7 +6767,7 @@ type ExecSandboxExit struct { func (x *ExecSandboxExit) Reset() { *x = ExecSandboxExit{} - mi := &file_openshell_proto_msgTypes[81] + mi := &file_openshell_proto_msgTypes[82] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6609,7 +6779,7 @@ func (x *ExecSandboxExit) String() string { func (*ExecSandboxExit) ProtoMessage() {} func (x *ExecSandboxExit) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[81] + mi := &file_openshell_proto_msgTypes[82] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6622,7 +6792,7 @@ func (x *ExecSandboxExit) ProtoReflect() protoreflect.Message { // Deprecated: Use ExecSandboxExit.ProtoReflect.Descriptor instead. func (*ExecSandboxExit) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{81} + return file_openshell_proto_rawDescGZIP(), []int{82} } func (x *ExecSandboxExit) GetExitCode() int32 { @@ -6647,7 +6817,7 @@ type ExecSandboxEvent struct { func (x *ExecSandboxEvent) Reset() { *x = ExecSandboxEvent{} - mi := &file_openshell_proto_msgTypes[82] + mi := &file_openshell_proto_msgTypes[83] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6659,7 +6829,7 @@ func (x *ExecSandboxEvent) String() string { func (*ExecSandboxEvent) ProtoMessage() {} func (x *ExecSandboxEvent) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[82] + mi := &file_openshell_proto_msgTypes[83] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6672,7 +6842,7 @@ func (x *ExecSandboxEvent) ProtoReflect() protoreflect.Message { // Deprecated: Use ExecSandboxEvent.ProtoReflect.Descriptor instead. func (*ExecSandboxEvent) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{82} + return file_openshell_proto_rawDescGZIP(), []int{83} } func (x *ExecSandboxEvent) GetPayload() isExecSandboxEvent_Payload { @@ -6754,7 +6924,7 @@ type TcpForwardInit struct { func (x *TcpForwardInit) Reset() { *x = TcpForwardInit{} - mi := &file_openshell_proto_msgTypes[83] + mi := &file_openshell_proto_msgTypes[84] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6766,7 +6936,7 @@ func (x *TcpForwardInit) String() string { func (*TcpForwardInit) ProtoMessage() {} func (x *TcpForwardInit) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[83] + mi := &file_openshell_proto_msgTypes[84] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6779,7 +6949,7 @@ func (x *TcpForwardInit) ProtoReflect() protoreflect.Message { // Deprecated: Use TcpForwardInit.ProtoReflect.Descriptor instead. func (*TcpForwardInit) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{83} + return file_openshell_proto_rawDescGZIP(), []int{84} } func (x *TcpForwardInit) GetSandboxId() string { @@ -6858,7 +7028,7 @@ type TcpForwardFrame struct { func (x *TcpForwardFrame) Reset() { *x = TcpForwardFrame{} - mi := &file_openshell_proto_msgTypes[84] + mi := &file_openshell_proto_msgTypes[85] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6870,7 +7040,7 @@ func (x *TcpForwardFrame) String() string { func (*TcpForwardFrame) ProtoMessage() {} func (x *TcpForwardFrame) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[84] + mi := &file_openshell_proto_msgTypes[85] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6883,7 +7053,7 @@ func (x *TcpForwardFrame) ProtoReflect() protoreflect.Message { // Deprecated: Use TcpForwardFrame.ProtoReflect.Descriptor instead. func (*TcpForwardFrame) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{84} + return file_openshell_proto_rawDescGZIP(), []int{85} } func (x *TcpForwardFrame) GetPayload() isTcpForwardFrame_Payload { @@ -6942,7 +7112,7 @@ type ExecSandboxInput struct { func (x *ExecSandboxInput) Reset() { *x = ExecSandboxInput{} - mi := &file_openshell_proto_msgTypes[85] + mi := &file_openshell_proto_msgTypes[86] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6954,7 +7124,7 @@ func (x *ExecSandboxInput) String() string { func (*ExecSandboxInput) ProtoMessage() {} func (x *ExecSandboxInput) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[85] + mi := &file_openshell_proto_msgTypes[86] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6967,7 +7137,7 @@ func (x *ExecSandboxInput) ProtoReflect() protoreflect.Message { // Deprecated: Use ExecSandboxInput.ProtoReflect.Descriptor instead. func (*ExecSandboxInput) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{85} + return file_openshell_proto_rawDescGZIP(), []int{86} } func (x *ExecSandboxInput) GetPayload() isExecSandboxInput_Payload { @@ -7040,7 +7210,7 @@ type ExecSandboxWindowResize struct { func (x *ExecSandboxWindowResize) Reset() { *x = ExecSandboxWindowResize{} - mi := &file_openshell_proto_msgTypes[86] + mi := &file_openshell_proto_msgTypes[87] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7052,7 +7222,7 @@ func (x *ExecSandboxWindowResize) String() string { func (*ExecSandboxWindowResize) ProtoMessage() {} func (x *ExecSandboxWindowResize) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[86] + mi := &file_openshell_proto_msgTypes[87] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7065,7 +7235,7 @@ func (x *ExecSandboxWindowResize) ProtoReflect() protoreflect.Message { // Deprecated: Use ExecSandboxWindowResize.ProtoReflect.Descriptor instead. func (*ExecSandboxWindowResize) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{86} + return file_openshell_proto_rawDescGZIP(), []int{87} } func (x *ExecSandboxWindowResize) GetCols() uint32 { @@ -7101,7 +7271,7 @@ type SshSession struct { func (x *SshSession) Reset() { *x = SshSession{} - mi := &file_openshell_proto_msgTypes[87] + mi := &file_openshell_proto_msgTypes[88] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7113,7 +7283,7 @@ func (x *SshSession) String() string { func (*SshSession) ProtoMessage() {} func (x *SshSession) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[87] + mi := &file_openshell_proto_msgTypes[88] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7126,7 +7296,7 @@ func (x *SshSession) ProtoReflect() protoreflect.Message { // Deprecated: Use SshSession.ProtoReflect.Descriptor instead. func (*SshSession) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{87} + return file_openshell_proto_rawDescGZIP(), []int{88} } func (x *SshSession) GetMetadata() *datamodelv1.ObjectMeta { @@ -7195,7 +7365,7 @@ type WatchSandboxRequest struct { func (x *WatchSandboxRequest) Reset() { *x = WatchSandboxRequest{} - mi := &file_openshell_proto_msgTypes[88] + mi := &file_openshell_proto_msgTypes[89] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7207,7 +7377,7 @@ func (x *WatchSandboxRequest) String() string { func (*WatchSandboxRequest) ProtoMessage() {} func (x *WatchSandboxRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[88] + mi := &file_openshell_proto_msgTypes[89] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7220,7 +7390,7 @@ func (x *WatchSandboxRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use WatchSandboxRequest.ProtoReflect.Descriptor instead. func (*WatchSandboxRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{88} + return file_openshell_proto_rawDescGZIP(), []int{89} } func (x *WatchSandboxRequest) GetId() string { @@ -7310,7 +7480,7 @@ type SandboxStreamEvent struct { func (x *SandboxStreamEvent) Reset() { *x = SandboxStreamEvent{} - mi := &file_openshell_proto_msgTypes[89] + mi := &file_openshell_proto_msgTypes[90] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7322,7 +7492,7 @@ func (x *SandboxStreamEvent) String() string { func (*SandboxStreamEvent) ProtoMessage() {} func (x *SandboxStreamEvent) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[89] + mi := &file_openshell_proto_msgTypes[90] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7335,7 +7505,7 @@ func (x *SandboxStreamEvent) ProtoReflect() protoreflect.Message { // Deprecated: Use SandboxStreamEvent.ProtoReflect.Descriptor instead. func (*SandboxStreamEvent) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{89} + return file_openshell_proto_rawDescGZIP(), []int{90} } func (x *SandboxStreamEvent) GetPayload() isSandboxStreamEvent_Payload { @@ -7448,7 +7618,7 @@ type SandboxLogLine struct { func (x *SandboxLogLine) Reset() { *x = SandboxLogLine{} - mi := &file_openshell_proto_msgTypes[90] + mi := &file_openshell_proto_msgTypes[91] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7460,7 +7630,7 @@ func (x *SandboxLogLine) String() string { func (*SandboxLogLine) ProtoMessage() {} func (x *SandboxLogLine) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[90] + mi := &file_openshell_proto_msgTypes[91] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7473,7 +7643,7 @@ func (x *SandboxLogLine) ProtoReflect() protoreflect.Message { // Deprecated: Use SandboxLogLine.ProtoReflect.Descriptor instead. func (*SandboxLogLine) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{90} + return file_openshell_proto_rawDescGZIP(), []int{91} } func (x *SandboxLogLine) GetSandboxId() string { @@ -7534,7 +7704,7 @@ type SandboxStreamWarning struct { func (x *SandboxStreamWarning) Reset() { *x = SandboxStreamWarning{} - mi := &file_openshell_proto_msgTypes[91] + mi := &file_openshell_proto_msgTypes[92] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7546,7 +7716,7 @@ func (x *SandboxStreamWarning) String() string { func (*SandboxStreamWarning) ProtoMessage() {} func (x *SandboxStreamWarning) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[91] + mi := &file_openshell_proto_msgTypes[92] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7559,7 +7729,7 @@ func (x *SandboxStreamWarning) ProtoReflect() protoreflect.Message { // Deprecated: Use SandboxStreamWarning.ProtoReflect.Descriptor instead. func (*SandboxStreamWarning) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{91} + return file_openshell_proto_rawDescGZIP(), []int{92} } func (x *SandboxStreamWarning) GetMessage() string { @@ -7584,7 +7754,7 @@ type CreateProviderRequest struct { func (x *CreateProviderRequest) Reset() { *x = CreateProviderRequest{} - mi := &file_openshell_proto_msgTypes[92] + mi := &file_openshell_proto_msgTypes[93] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7596,7 +7766,7 @@ func (x *CreateProviderRequest) String() string { func (*CreateProviderRequest) ProtoMessage() {} func (x *CreateProviderRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[92] + mi := &file_openshell_proto_msgTypes[93] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7609,7 +7779,7 @@ func (x *CreateProviderRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use CreateProviderRequest.ProtoReflect.Descriptor instead. func (*CreateProviderRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{92} + return file_openshell_proto_rawDescGZIP(), []int{93} } func (x *CreateProviderRequest) GetProvider() *datamodelv1.Provider { @@ -7645,7 +7815,7 @@ type GetProviderRequest struct { func (x *GetProviderRequest) Reset() { *x = GetProviderRequest{} - mi := &file_openshell_proto_msgTypes[93] + mi := &file_openshell_proto_msgTypes[94] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7657,7 +7827,7 @@ func (x *GetProviderRequest) String() string { func (*GetProviderRequest) ProtoMessage() {} func (x *GetProviderRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[93] + mi := &file_openshell_proto_msgTypes[94] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7670,7 +7840,7 @@ func (x *GetProviderRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetProviderRequest.ProtoReflect.Descriptor instead. func (*GetProviderRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{93} + return file_openshell_proto_rawDescGZIP(), []int{94} } func (x *GetProviderRequest) GetName() string { @@ -7704,7 +7874,7 @@ type ListProvidersRequest struct { func (x *ListProvidersRequest) Reset() { *x = ListProvidersRequest{} - mi := &file_openshell_proto_msgTypes[94] + mi := &file_openshell_proto_msgTypes[95] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7716,7 +7886,7 @@ func (x *ListProvidersRequest) String() string { func (*ListProvidersRequest) ProtoMessage() {} func (x *ListProvidersRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[94] + mi := &file_openshell_proto_msgTypes[95] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7729,7 +7899,7 @@ func (x *ListProvidersRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListProvidersRequest.ProtoReflect.Descriptor instead. func (*ListProvidersRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{94} + return file_openshell_proto_rawDescGZIP(), []int{95} } func (x *ListProvidersRequest) GetPageSize() int32 { @@ -7774,7 +7944,7 @@ type UpdateProviderRequest struct { func (x *UpdateProviderRequest) Reset() { *x = UpdateProviderRequest{} - mi := &file_openshell_proto_msgTypes[95] + mi := &file_openshell_proto_msgTypes[96] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7786,7 +7956,7 @@ func (x *UpdateProviderRequest) String() string { func (*UpdateProviderRequest) ProtoMessage() {} func (x *UpdateProviderRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[95] + mi := &file_openshell_proto_msgTypes[96] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7799,7 +7969,7 @@ func (x *UpdateProviderRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use UpdateProviderRequest.ProtoReflect.Descriptor instead. func (*UpdateProviderRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{95} + return file_openshell_proto_rawDescGZIP(), []int{96} } func (x *UpdateProviderRequest) GetProvider() *datamodelv1.Provider { @@ -7853,7 +8023,7 @@ type DeleteProviderRequest struct { func (x *DeleteProviderRequest) Reset() { *x = DeleteProviderRequest{} - mi := &file_openshell_proto_msgTypes[96] + mi := &file_openshell_proto_msgTypes[97] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7865,7 +8035,7 @@ func (x *DeleteProviderRequest) String() string { func (*DeleteProviderRequest) ProtoMessage() {} func (x *DeleteProviderRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[96] + mi := &file_openshell_proto_msgTypes[97] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7878,7 +8048,7 @@ func (x *DeleteProviderRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteProviderRequest.ProtoReflect.Descriptor instead. func (*DeleteProviderRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{96} + return file_openshell_proto_rawDescGZIP(), []int{97} } func (x *DeleteProviderRequest) GetName() string { @@ -7924,7 +8094,7 @@ type ProviderResponse struct { func (x *ProviderResponse) Reset() { *x = ProviderResponse{} - mi := &file_openshell_proto_msgTypes[97] + mi := &file_openshell_proto_msgTypes[98] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7936,7 +8106,7 @@ func (x *ProviderResponse) String() string { func (*ProviderResponse) ProtoMessage() {} func (x *ProviderResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[97] + mi := &file_openshell_proto_msgTypes[98] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7949,7 +8119,7 @@ func (x *ProviderResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ProviderResponse.ProtoReflect.Descriptor instead. func (*ProviderResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{97} + return file_openshell_proto_rawDescGZIP(), []int{98} } func (x *ProviderResponse) GetProvider() *datamodelv1.Provider { @@ -7985,7 +8155,7 @@ type ListProvidersResponse struct { func (x *ListProvidersResponse) Reset() { *x = ListProvidersResponse{} - mi := &file_openshell_proto_msgTypes[98] + mi := &file_openshell_proto_msgTypes[99] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7997,7 +8167,7 @@ func (x *ListProvidersResponse) String() string { func (*ListProvidersResponse) ProtoMessage() {} func (x *ListProvidersResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[98] + mi := &file_openshell_proto_msgTypes[99] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8010,7 +8180,7 @@ func (x *ListProvidersResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListProvidersResponse.ProtoReflect.Descriptor instead. func (*ListProvidersResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{98} + return file_openshell_proto_rawDescGZIP(), []int{99} } func (x *ListProvidersResponse) GetProviders() []*datamodelv1.Provider { @@ -8045,7 +8215,7 @@ type ListProviderProfilesRequest struct { func (x *ListProviderProfilesRequest) Reset() { *x = ListProviderProfilesRequest{} - mi := &file_openshell_proto_msgTypes[99] + mi := &file_openshell_proto_msgTypes[100] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8057,7 +8227,7 @@ func (x *ListProviderProfilesRequest) String() string { func (*ListProviderProfilesRequest) ProtoMessage() {} func (x *ListProviderProfilesRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[99] + mi := &file_openshell_proto_msgTypes[100] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8070,7 +8240,7 @@ func (x *ListProviderProfilesRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListProviderProfilesRequest.ProtoReflect.Descriptor instead. func (*ListProviderProfilesRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{99} + return file_openshell_proto_rawDescGZIP(), []int{100} } func (x *ListProviderProfilesRequest) GetPageSize() int32 { @@ -8108,7 +8278,7 @@ type GetProviderProfileRequest struct { func (x *GetProviderProfileRequest) Reset() { *x = GetProviderProfileRequest{} - mi := &file_openshell_proto_msgTypes[100] + mi := &file_openshell_proto_msgTypes[101] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8120,7 +8290,7 @@ func (x *GetProviderProfileRequest) String() string { func (*GetProviderProfileRequest) ProtoMessage() {} func (x *GetProviderProfileRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[100] + mi := &file_openshell_proto_msgTypes[101] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8133,7 +8303,7 @@ func (x *GetProviderProfileRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetProviderProfileRequest.ProtoReflect.Descriptor instead. func (*GetProviderProfileRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{100} + return file_openshell_proto_rawDescGZIP(), []int{101} } func (x *GetProviderProfileRequest) GetId() string { @@ -8161,7 +8331,7 @@ type ProviderProfileImportItem struct { func (x *ProviderProfileImportItem) Reset() { *x = ProviderProfileImportItem{} - mi := &file_openshell_proto_msgTypes[101] + mi := &file_openshell_proto_msgTypes[102] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8173,7 +8343,7 @@ func (x *ProviderProfileImportItem) String() string { func (*ProviderProfileImportItem) ProtoMessage() {} func (x *ProviderProfileImportItem) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[101] + mi := &file_openshell_proto_msgTypes[102] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8186,7 +8356,7 @@ func (x *ProviderProfileImportItem) ProtoReflect() protoreflect.Message { // Deprecated: Use ProviderProfileImportItem.ProtoReflect.Descriptor instead. func (*ProviderProfileImportItem) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{101} + return file_openshell_proto_rawDescGZIP(), []int{102} } func (x *ProviderProfileImportItem) GetProfile() *ProviderProfile { @@ -8217,7 +8387,7 @@ type ProviderProfileDiagnostic struct { func (x *ProviderProfileDiagnostic) Reset() { *x = ProviderProfileDiagnostic{} - mi := &file_openshell_proto_msgTypes[102] + mi := &file_openshell_proto_msgTypes[103] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8229,7 +8399,7 @@ func (x *ProviderProfileDiagnostic) String() string { func (*ProviderProfileDiagnostic) ProtoMessage() {} func (x *ProviderProfileDiagnostic) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[102] + mi := &file_openshell_proto_msgTypes[103] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8242,7 +8412,7 @@ func (x *ProviderProfileDiagnostic) ProtoReflect() protoreflect.Message { // Deprecated: Use ProviderProfileDiagnostic.ProtoReflect.Descriptor instead. func (*ProviderProfileDiagnostic) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{102} + return file_openshell_proto_rawDescGZIP(), []int{103} } func (x *ProviderProfileDiagnostic) GetSource() string { @@ -8299,7 +8469,7 @@ type ProviderCredentialTokenGrantAudienceOverride struct { func (x *ProviderCredentialTokenGrantAudienceOverride) Reset() { *x = ProviderCredentialTokenGrantAudienceOverride{} - mi := &file_openshell_proto_msgTypes[103] + mi := &file_openshell_proto_msgTypes[104] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8311,7 +8481,7 @@ func (x *ProviderCredentialTokenGrantAudienceOverride) String() string { func (*ProviderCredentialTokenGrantAudienceOverride) ProtoMessage() {} func (x *ProviderCredentialTokenGrantAudienceOverride) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[103] + mi := &file_openshell_proto_msgTypes[104] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8324,7 +8494,7 @@ func (x *ProviderCredentialTokenGrantAudienceOverride) ProtoReflect() protorefle // Deprecated: Use ProviderCredentialTokenGrantAudienceOverride.ProtoReflect.Descriptor instead. func (*ProviderCredentialTokenGrantAudienceOverride) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{103} + return file_openshell_proto_rawDescGZIP(), []int{104} } func (x *ProviderCredentialTokenGrantAudienceOverride) GetHost() string { @@ -8378,7 +8548,7 @@ type ProviderCredentialTokenGrantSubjectToken struct { func (x *ProviderCredentialTokenGrantSubjectToken) Reset() { *x = ProviderCredentialTokenGrantSubjectToken{} - mi := &file_openshell_proto_msgTypes[104] + mi := &file_openshell_proto_msgTypes[105] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8390,7 +8560,7 @@ func (x *ProviderCredentialTokenGrantSubjectToken) String() string { func (*ProviderCredentialTokenGrantSubjectToken) ProtoMessage() {} func (x *ProviderCredentialTokenGrantSubjectToken) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[104] + mi := &file_openshell_proto_msgTypes[105] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8403,7 +8573,7 @@ func (x *ProviderCredentialTokenGrantSubjectToken) ProtoReflect() protoreflect.M // Deprecated: Use ProviderCredentialTokenGrantSubjectToken.ProtoReflect.Descriptor instead. func (*ProviderCredentialTokenGrantSubjectToken) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{104} + return file_openshell_proto_rawDescGZIP(), []int{105} } func (x *ProviderCredentialTokenGrantSubjectToken) GetSource() string { @@ -8459,7 +8629,7 @@ type ProviderCredentialTokenGrant struct { func (x *ProviderCredentialTokenGrant) Reset() { *x = ProviderCredentialTokenGrant{} - mi := &file_openshell_proto_msgTypes[105] + mi := &file_openshell_proto_msgTypes[106] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8471,7 +8641,7 @@ func (x *ProviderCredentialTokenGrant) String() string { func (*ProviderCredentialTokenGrant) ProtoMessage() {} func (x *ProviderCredentialTokenGrant) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[105] + mi := &file_openshell_proto_msgTypes[106] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8484,7 +8654,7 @@ func (x *ProviderCredentialTokenGrant) ProtoReflect() protoreflect.Message { // Deprecated: Use ProviderCredentialTokenGrant.ProtoReflect.Descriptor instead. func (*ProviderCredentialTokenGrant) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{105} + return file_openshell_proto_rawDescGZIP(), []int{106} } func (x *ProviderCredentialTokenGrant) GetTokenEndpoint() string { @@ -8576,7 +8746,7 @@ type ProviderProfileCredential struct { func (x *ProviderProfileCredential) Reset() { *x = ProviderProfileCredential{} - mi := &file_openshell_proto_msgTypes[106] + mi := &file_openshell_proto_msgTypes[107] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8588,7 +8758,7 @@ func (x *ProviderProfileCredential) String() string { func (*ProviderProfileCredential) ProtoMessage() {} func (x *ProviderProfileCredential) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[106] + mi := &file_openshell_proto_msgTypes[107] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8601,7 +8771,7 @@ func (x *ProviderProfileCredential) ProtoReflect() protoreflect.Message { // Deprecated: Use ProviderProfileCredential.ProtoReflect.Descriptor instead. func (*ProviderProfileCredential) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{106} + return file_openshell_proto_rawDescGZIP(), []int{107} } func (x *ProviderProfileCredential) GetName() string { @@ -8686,7 +8856,7 @@ type ProviderCredentialRefreshMaterial struct { func (x *ProviderCredentialRefreshMaterial) Reset() { *x = ProviderCredentialRefreshMaterial{} - mi := &file_openshell_proto_msgTypes[107] + mi := &file_openshell_proto_msgTypes[108] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8698,7 +8868,7 @@ func (x *ProviderCredentialRefreshMaterial) String() string { func (*ProviderCredentialRefreshMaterial) ProtoMessage() {} func (x *ProviderCredentialRefreshMaterial) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[107] + mi := &file_openshell_proto_msgTypes[108] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8711,7 +8881,7 @@ func (x *ProviderCredentialRefreshMaterial) ProtoReflect() protoreflect.Message // Deprecated: Use ProviderCredentialRefreshMaterial.ProtoReflect.Descriptor instead. func (*ProviderCredentialRefreshMaterial) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{107} + return file_openshell_proto_rawDescGZIP(), []int{108} } func (x *ProviderCredentialRefreshMaterial) GetName() string { @@ -8756,7 +8926,7 @@ type ProviderCredentialRefreshOutput struct { func (x *ProviderCredentialRefreshOutput) Reset() { *x = ProviderCredentialRefreshOutput{} - mi := &file_openshell_proto_msgTypes[108] + mi := &file_openshell_proto_msgTypes[109] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8768,7 +8938,7 @@ func (x *ProviderCredentialRefreshOutput) String() string { func (*ProviderCredentialRefreshOutput) ProtoMessage() {} func (x *ProviderCredentialRefreshOutput) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[108] + mi := &file_openshell_proto_msgTypes[109] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8781,7 +8951,7 @@ func (x *ProviderCredentialRefreshOutput) ProtoReflect() protoreflect.Message { // Deprecated: Use ProviderCredentialRefreshOutput.ProtoReflect.Descriptor instead. func (*ProviderCredentialRefreshOutput) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{108} + return file_openshell_proto_rawDescGZIP(), []int{109} } func (x *ProviderCredentialRefreshOutput) GetOutput() string { @@ -8813,7 +8983,7 @@ type ProviderCredentialRefresh struct { func (x *ProviderCredentialRefresh) Reset() { *x = ProviderCredentialRefresh{} - mi := &file_openshell_proto_msgTypes[109] + mi := &file_openshell_proto_msgTypes[110] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8825,7 +8995,7 @@ func (x *ProviderCredentialRefresh) String() string { func (*ProviderCredentialRefresh) ProtoMessage() {} func (x *ProviderCredentialRefresh) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[109] + mi := &file_openshell_proto_msgTypes[110] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8838,7 +9008,7 @@ func (x *ProviderCredentialRefresh) ProtoReflect() protoreflect.Message { // Deprecated: Use ProviderCredentialRefresh.ProtoReflect.Descriptor instead. func (*ProviderCredentialRefresh) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{109} + return file_openshell_proto_rawDescGZIP(), []int{110} } func (x *ProviderCredentialRefresh) GetStrategy() ProviderCredentialRefreshStrategy { @@ -8919,7 +9089,7 @@ type ProviderCredentialRefreshStatus struct { func (x *ProviderCredentialRefreshStatus) Reset() { *x = ProviderCredentialRefreshStatus{} - mi := &file_openshell_proto_msgTypes[110] + mi := &file_openshell_proto_msgTypes[111] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8931,7 +9101,7 @@ func (x *ProviderCredentialRefreshStatus) String() string { func (*ProviderCredentialRefreshStatus) ProtoMessage() {} func (x *ProviderCredentialRefreshStatus) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[110] + mi := &file_openshell_proto_msgTypes[111] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8944,7 +9114,7 @@ func (x *ProviderCredentialRefreshStatus) ProtoReflect() protoreflect.Message { // Deprecated: Use ProviderCredentialRefreshStatus.ProtoReflect.Descriptor instead. func (*ProviderCredentialRefreshStatus) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{110} + return file_openshell_proto_rawDescGZIP(), []int{111} } func (x *ProviderCredentialRefreshStatus) GetProviderName() string { @@ -9049,7 +9219,7 @@ type ProviderProfileDiscovery struct { func (x *ProviderProfileDiscovery) Reset() { *x = ProviderProfileDiscovery{} - mi := &file_openshell_proto_msgTypes[111] + mi := &file_openshell_proto_msgTypes[112] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9061,7 +9231,7 @@ func (x *ProviderProfileDiscovery) String() string { func (*ProviderProfileDiscovery) ProtoMessage() {} func (x *ProviderProfileDiscovery) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[111] + mi := &file_openshell_proto_msgTypes[112] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9074,7 +9244,7 @@ func (x *ProviderProfileDiscovery) ProtoReflect() protoreflect.Message { // Deprecated: Use ProviderProfileDiscovery.ProtoReflect.Descriptor instead. func (*ProviderProfileDiscovery) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{111} + return file_openshell_proto_rawDescGZIP(), []int{112} } func (x *ProviderProfileDiscovery) GetCredentials() []string { @@ -9096,7 +9266,7 @@ type GetProviderRefreshStatusRequest struct { func (x *GetProviderRefreshStatusRequest) Reset() { *x = GetProviderRefreshStatusRequest{} - mi := &file_openshell_proto_msgTypes[112] + mi := &file_openshell_proto_msgTypes[113] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9108,7 +9278,7 @@ func (x *GetProviderRefreshStatusRequest) String() string { func (*GetProviderRefreshStatusRequest) ProtoMessage() {} func (x *GetProviderRefreshStatusRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[112] + mi := &file_openshell_proto_msgTypes[113] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9121,7 +9291,7 @@ func (x *GetProviderRefreshStatusRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetProviderRefreshStatusRequest.ProtoReflect.Descriptor instead. func (*GetProviderRefreshStatusRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{112} + return file_openshell_proto_rawDescGZIP(), []int{113} } func (x *GetProviderRefreshStatusRequest) GetProvider() string { @@ -9154,7 +9324,7 @@ type GetProviderRefreshStatusResponse struct { func (x *GetProviderRefreshStatusResponse) Reset() { *x = GetProviderRefreshStatusResponse{} - mi := &file_openshell_proto_msgTypes[113] + mi := &file_openshell_proto_msgTypes[114] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9166,7 +9336,7 @@ func (x *GetProviderRefreshStatusResponse) String() string { func (*GetProviderRefreshStatusResponse) ProtoMessage() {} func (x *GetProviderRefreshStatusResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[113] + mi := &file_openshell_proto_msgTypes[114] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9179,7 +9349,7 @@ func (x *GetProviderRefreshStatusResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use GetProviderRefreshStatusResponse.ProtoReflect.Descriptor instead. func (*GetProviderRefreshStatusResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{113} + return file_openshell_proto_rawDescGZIP(), []int{114} } func (x *GetProviderRefreshStatusResponse) GetCredentials() []*ProviderCredentialRefreshStatus { @@ -9211,7 +9381,7 @@ type ConfigureProviderRefreshRequest struct { func (x *ConfigureProviderRefreshRequest) Reset() { *x = ConfigureProviderRefreshRequest{} - mi := &file_openshell_proto_msgTypes[114] + mi := &file_openshell_proto_msgTypes[115] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9223,7 +9393,7 @@ func (x *ConfigureProviderRefreshRequest) String() string { func (*ConfigureProviderRefreshRequest) ProtoMessage() {} func (x *ConfigureProviderRefreshRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[114] + mi := &file_openshell_proto_msgTypes[115] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9236,7 +9406,7 @@ func (x *ConfigureProviderRefreshRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ConfigureProviderRefreshRequest.ProtoReflect.Descriptor instead. func (*ConfigureProviderRefreshRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{114} + return file_openshell_proto_rawDescGZIP(), []int{115} } func (x *ConfigureProviderRefreshRequest) GetProvider() string { @@ -9304,7 +9474,7 @@ type ConfigureProviderRefreshResponse struct { func (x *ConfigureProviderRefreshResponse) Reset() { *x = ConfigureProviderRefreshResponse{} - mi := &file_openshell_proto_msgTypes[115] + mi := &file_openshell_proto_msgTypes[116] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9316,7 +9486,7 @@ func (x *ConfigureProviderRefreshResponse) String() string { func (*ConfigureProviderRefreshResponse) ProtoMessage() {} func (x *ConfigureProviderRefreshResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[115] + mi := &file_openshell_proto_msgTypes[116] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9329,7 +9499,7 @@ func (x *ConfigureProviderRefreshResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ConfigureProviderRefreshResponse.ProtoReflect.Descriptor instead. func (*ConfigureProviderRefreshResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{115} + return file_openshell_proto_rawDescGZIP(), []int{116} } func (x *ConfigureProviderRefreshResponse) GetStatus() *ProviderCredentialRefreshStatus { @@ -9354,7 +9524,7 @@ type RotateProviderCredentialRequest struct { func (x *RotateProviderCredentialRequest) Reset() { *x = RotateProviderCredentialRequest{} - mi := &file_openshell_proto_msgTypes[116] + mi := &file_openshell_proto_msgTypes[117] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9366,7 +9536,7 @@ func (x *RotateProviderCredentialRequest) String() string { func (*RotateProviderCredentialRequest) ProtoMessage() {} func (x *RotateProviderCredentialRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[116] + mi := &file_openshell_proto_msgTypes[117] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9379,7 +9549,7 @@ func (x *RotateProviderCredentialRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use RotateProviderCredentialRequest.ProtoReflect.Descriptor instead. func (*RotateProviderCredentialRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{116} + return file_openshell_proto_rawDescGZIP(), []int{117} } func (x *RotateProviderCredentialRequest) GetProvider() string { @@ -9419,7 +9589,7 @@ type RotateProviderCredentialResponse struct { func (x *RotateProviderCredentialResponse) Reset() { *x = RotateProviderCredentialResponse{} - mi := &file_openshell_proto_msgTypes[117] + mi := &file_openshell_proto_msgTypes[118] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9431,7 +9601,7 @@ func (x *RotateProviderCredentialResponse) String() string { func (*RotateProviderCredentialResponse) ProtoMessage() {} func (x *RotateProviderCredentialResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[117] + mi := &file_openshell_proto_msgTypes[118] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9444,7 +9614,7 @@ func (x *RotateProviderCredentialResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use RotateProviderCredentialResponse.ProtoReflect.Descriptor instead. func (*RotateProviderCredentialResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{117} + return file_openshell_proto_rawDescGZIP(), []int{118} } func (x *RotateProviderCredentialResponse) GetStatus() *ProviderCredentialRefreshStatus { @@ -9470,7 +9640,7 @@ type DeleteProviderRefreshRequest struct { func (x *DeleteProviderRefreshRequest) Reset() { *x = DeleteProviderRefreshRequest{} - mi := &file_openshell_proto_msgTypes[118] + mi := &file_openshell_proto_msgTypes[119] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9482,7 +9652,7 @@ func (x *DeleteProviderRefreshRequest) String() string { func (*DeleteProviderRefreshRequest) ProtoMessage() {} func (x *DeleteProviderRefreshRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[118] + mi := &file_openshell_proto_msgTypes[119] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9495,7 +9665,7 @@ func (x *DeleteProviderRefreshRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteProviderRefreshRequest.ProtoReflect.Descriptor instead. func (*DeleteProviderRefreshRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{118} + return file_openshell_proto_rawDescGZIP(), []int{119} } func (x *DeleteProviderRefreshRequest) GetProvider() string { @@ -9542,7 +9712,7 @@ type DeleteProviderRefreshResponse struct { func (x *DeleteProviderRefreshResponse) Reset() { *x = DeleteProviderRefreshResponse{} - mi := &file_openshell_proto_msgTypes[119] + mi := &file_openshell_proto_msgTypes[120] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9554,7 +9724,7 @@ func (x *DeleteProviderRefreshResponse) String() string { func (*DeleteProviderRefreshResponse) ProtoMessage() {} func (x *DeleteProviderRefreshResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[119] + mi := &file_openshell_proto_msgTypes[120] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9567,7 +9737,7 @@ func (x *DeleteProviderRefreshResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteProviderRefreshResponse.ProtoReflect.Descriptor instead. func (*DeleteProviderRefreshResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{119} + return file_openshell_proto_rawDescGZIP(), []int{120} } func (x *DeleteProviderRefreshResponse) GetOutcome() DeletionOutcome { @@ -9607,7 +9777,7 @@ type ProviderProfile struct { func (x *ProviderProfile) Reset() { *x = ProviderProfile{} - mi := &file_openshell_proto_msgTypes[120] + mi := &file_openshell_proto_msgTypes[121] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9619,7 +9789,7 @@ func (x *ProviderProfile) String() string { func (*ProviderProfile) ProtoMessage() {} func (x *ProviderProfile) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[120] + mi := &file_openshell_proto_msgTypes[121] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9632,7 +9802,7 @@ func (x *ProviderProfile) ProtoReflect() protoreflect.Message { // Deprecated: Use ProviderProfile.ProtoReflect.Descriptor instead. func (*ProviderProfile) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{120} + return file_openshell_proto_rawDescGZIP(), []int{121} } func (x *ProviderProfile) GetId() string { @@ -9736,7 +9906,7 @@ type ProviderProfileResponse struct { func (x *ProviderProfileResponse) Reset() { *x = ProviderProfileResponse{} - mi := &file_openshell_proto_msgTypes[121] + mi := &file_openshell_proto_msgTypes[122] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9748,7 +9918,7 @@ func (x *ProviderProfileResponse) String() string { func (*ProviderProfileResponse) ProtoMessage() {} func (x *ProviderProfileResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[121] + mi := &file_openshell_proto_msgTypes[122] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9761,7 +9931,7 @@ func (x *ProviderProfileResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ProviderProfileResponse.ProtoReflect.Descriptor instead. func (*ProviderProfileResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{121} + return file_openshell_proto_rawDescGZIP(), []int{122} } func (x *ProviderProfileResponse) GetProfile() *ProviderProfile { @@ -9783,7 +9953,7 @@ type ListProviderProfilesResponse struct { func (x *ListProviderProfilesResponse) Reset() { *x = ListProviderProfilesResponse{} - mi := &file_openshell_proto_msgTypes[122] + mi := &file_openshell_proto_msgTypes[123] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9795,7 +9965,7 @@ func (x *ListProviderProfilesResponse) String() string { func (*ListProviderProfilesResponse) ProtoMessage() {} func (x *ListProviderProfilesResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[122] + mi := &file_openshell_proto_msgTypes[123] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9808,7 +9978,7 @@ func (x *ListProviderProfilesResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListProviderProfilesResponse.ProtoReflect.Descriptor instead. func (*ListProviderProfilesResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{122} + return file_openshell_proto_rawDescGZIP(), []int{123} } func (x *ListProviderProfilesResponse) GetProfiles() []*ProviderProfile { @@ -9841,7 +10011,7 @@ type ImportProviderProfilesRequest struct { func (x *ImportProviderProfilesRequest) Reset() { *x = ImportProviderProfilesRequest{} - mi := &file_openshell_proto_msgTypes[123] + mi := &file_openshell_proto_msgTypes[124] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9853,7 +10023,7 @@ func (x *ImportProviderProfilesRequest) String() string { func (*ImportProviderProfilesRequest) ProtoMessage() {} func (x *ImportProviderProfilesRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[123] + mi := &file_openshell_proto_msgTypes[124] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9866,7 +10036,7 @@ func (x *ImportProviderProfilesRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ImportProviderProfilesRequest.ProtoReflect.Descriptor instead. func (*ImportProviderProfilesRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{123} + return file_openshell_proto_rawDescGZIP(), []int{124} } func (x *ImportProviderProfilesRequest) GetProfiles() []*ProviderProfileImportItem { @@ -9902,7 +10072,7 @@ type ImportProviderProfilesResponse struct { func (x *ImportProviderProfilesResponse) Reset() { *x = ImportProviderProfilesResponse{} - mi := &file_openshell_proto_msgTypes[124] + mi := &file_openshell_proto_msgTypes[125] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9914,7 +10084,7 @@ func (x *ImportProviderProfilesResponse) String() string { func (*ImportProviderProfilesResponse) ProtoMessage() {} func (x *ImportProviderProfilesResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[124] + mi := &file_openshell_proto_msgTypes[125] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9927,7 +10097,7 @@ func (x *ImportProviderProfilesResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ImportProviderProfilesResponse.ProtoReflect.Descriptor instead. func (*ImportProviderProfilesResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{124} + return file_openshell_proto_rawDescGZIP(), []int{125} } func (x *ImportProviderProfilesResponse) GetDiagnostics() []*ProviderProfileDiagnostic { @@ -9974,7 +10144,7 @@ type UpdateProviderProfilesRequest struct { func (x *UpdateProviderProfilesRequest) Reset() { *x = UpdateProviderProfilesRequest{} - mi := &file_openshell_proto_msgTypes[125] + mi := &file_openshell_proto_msgTypes[126] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9986,7 +10156,7 @@ func (x *UpdateProviderProfilesRequest) String() string { func (*UpdateProviderProfilesRequest) ProtoMessage() {} func (x *UpdateProviderProfilesRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[125] + mi := &file_openshell_proto_msgTypes[126] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9999,7 +10169,7 @@ func (x *UpdateProviderProfilesRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use UpdateProviderProfilesRequest.ProtoReflect.Descriptor instead. func (*UpdateProviderProfilesRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{125} + return file_openshell_proto_rawDescGZIP(), []int{126} } func (x *UpdateProviderProfilesRequest) GetProfile() *ProviderProfileImportItem { @@ -10049,7 +10219,7 @@ type UpdateProviderProfilesResponse struct { func (x *UpdateProviderProfilesResponse) Reset() { *x = UpdateProviderProfilesResponse{} - mi := &file_openshell_proto_msgTypes[126] + mi := &file_openshell_proto_msgTypes[127] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10061,7 +10231,7 @@ func (x *UpdateProviderProfilesResponse) String() string { func (*UpdateProviderProfilesResponse) ProtoMessage() {} func (x *UpdateProviderProfilesResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[126] + mi := &file_openshell_proto_msgTypes[127] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10074,7 +10244,7 @@ func (x *UpdateProviderProfilesResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use UpdateProviderProfilesResponse.ProtoReflect.Descriptor instead. func (*UpdateProviderProfilesResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{126} + return file_openshell_proto_rawDescGZIP(), []int{127} } func (x *UpdateProviderProfilesResponse) GetDiagnostics() []*ProviderProfileDiagnostic { @@ -10111,7 +10281,7 @@ type LintProviderProfilesRequest struct { func (x *LintProviderProfilesRequest) Reset() { *x = LintProviderProfilesRequest{} - mi := &file_openshell_proto_msgTypes[127] + mi := &file_openshell_proto_msgTypes[128] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10123,7 +10293,7 @@ func (x *LintProviderProfilesRequest) String() string { func (*LintProviderProfilesRequest) ProtoMessage() {} func (x *LintProviderProfilesRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[127] + mi := &file_openshell_proto_msgTypes[128] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10136,7 +10306,7 @@ func (x *LintProviderProfilesRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use LintProviderProfilesRequest.ProtoReflect.Descriptor instead. func (*LintProviderProfilesRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{127} + return file_openshell_proto_rawDescGZIP(), []int{128} } func (x *LintProviderProfilesRequest) GetProfiles() []*ProviderProfileImportItem { @@ -10164,7 +10334,7 @@ type LintProviderProfilesResponse struct { func (x *LintProviderProfilesResponse) Reset() { *x = LintProviderProfilesResponse{} - mi := &file_openshell_proto_msgTypes[128] + mi := &file_openshell_proto_msgTypes[129] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10176,7 +10346,7 @@ func (x *LintProviderProfilesResponse) String() string { func (*LintProviderProfilesResponse) ProtoMessage() {} func (x *LintProviderProfilesResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[128] + mi := &file_openshell_proto_msgTypes[129] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10189,7 +10359,7 @@ func (x *LintProviderProfilesResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use LintProviderProfilesResponse.ProtoReflect.Descriptor instead. func (*LintProviderProfilesResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{128} + return file_openshell_proto_rawDescGZIP(), []int{129} } func (x *LintProviderProfilesResponse) GetDiagnostics() []*ProviderProfileDiagnostic { @@ -10216,7 +10386,7 @@ type DeleteProviderResponse struct { func (x *DeleteProviderResponse) Reset() { *x = DeleteProviderResponse{} - mi := &file_openshell_proto_msgTypes[129] + mi := &file_openshell_proto_msgTypes[130] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10228,7 +10398,7 @@ func (x *DeleteProviderResponse) String() string { func (*DeleteProviderResponse) ProtoMessage() {} func (x *DeleteProviderResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[129] + mi := &file_openshell_proto_msgTypes[130] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10241,7 +10411,7 @@ func (x *DeleteProviderResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteProviderResponse.ProtoReflect.Descriptor instead. func (*DeleteProviderResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{129} + return file_openshell_proto_rawDescGZIP(), []int{130} } func (x *DeleteProviderResponse) GetOutcome() DeletionOutcome { @@ -10268,7 +10438,7 @@ type DeleteProviderProfileRequest struct { func (x *DeleteProviderProfileRequest) Reset() { *x = DeleteProviderProfileRequest{} - mi := &file_openshell_proto_msgTypes[130] + mi := &file_openshell_proto_msgTypes[131] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10280,7 +10450,7 @@ func (x *DeleteProviderProfileRequest) String() string { func (*DeleteProviderProfileRequest) ProtoMessage() {} func (x *DeleteProviderProfileRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[130] + mi := &file_openshell_proto_msgTypes[131] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10293,7 +10463,7 @@ func (x *DeleteProviderProfileRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteProviderProfileRequest.ProtoReflect.Descriptor instead. func (*DeleteProviderProfileRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{130} + return file_openshell_proto_rawDescGZIP(), []int{131} } func (x *DeleteProviderProfileRequest) GetId() string { @@ -10334,7 +10504,7 @@ type DeleteProviderProfileResponse struct { func (x *DeleteProviderProfileResponse) Reset() { *x = DeleteProviderProfileResponse{} - mi := &file_openshell_proto_msgTypes[131] + mi := &file_openshell_proto_msgTypes[132] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10346,7 +10516,7 @@ func (x *DeleteProviderProfileResponse) String() string { func (*DeleteProviderProfileResponse) ProtoMessage() {} func (x *DeleteProviderProfileResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[131] + mi := &file_openshell_proto_msgTypes[132] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10359,7 +10529,7 @@ func (x *DeleteProviderProfileResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteProviderProfileResponse.ProtoReflect.Descriptor instead. func (*DeleteProviderProfileResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{131} + return file_openshell_proto_rawDescGZIP(), []int{132} } func (x *DeleteProviderProfileResponse) GetOutcome() DeletionOutcome { @@ -10384,7 +10554,7 @@ type GetSandboxProviderEnvironmentRequest struct { func (x *GetSandboxProviderEnvironmentRequest) Reset() { *x = GetSandboxProviderEnvironmentRequest{} - mi := &file_openshell_proto_msgTypes[132] + mi := &file_openshell_proto_msgTypes[133] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10396,7 +10566,7 @@ func (x *GetSandboxProviderEnvironmentRequest) String() string { func (*GetSandboxProviderEnvironmentRequest) ProtoMessage() {} func (x *GetSandboxProviderEnvironmentRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[132] + mi := &file_openshell_proto_msgTypes[133] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10409,7 +10579,7 @@ func (x *GetSandboxProviderEnvironmentRequest) ProtoReflect() protoreflect.Messa // Deprecated: Use GetSandboxProviderEnvironmentRequest.ProtoReflect.Descriptor instead. func (*GetSandboxProviderEnvironmentRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{132} + return file_openshell_proto_rawDescGZIP(), []int{133} } func (x *GetSandboxProviderEnvironmentRequest) GetSandboxId() string { @@ -10438,7 +10608,7 @@ type StaticCredentialEndpointBinding struct { func (x *StaticCredentialEndpointBinding) Reset() { *x = StaticCredentialEndpointBinding{} - mi := &file_openshell_proto_msgTypes[133] + mi := &file_openshell_proto_msgTypes[134] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10450,7 +10620,7 @@ func (x *StaticCredentialEndpointBinding) String() string { func (*StaticCredentialEndpointBinding) ProtoMessage() {} func (x *StaticCredentialEndpointBinding) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[133] + mi := &file_openshell_proto_msgTypes[134] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10463,7 +10633,7 @@ func (x *StaticCredentialEndpointBinding) ProtoReflect() protoreflect.Message { // Deprecated: Use StaticCredentialEndpointBinding.ProtoReflect.Descriptor instead. func (*StaticCredentialEndpointBinding) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{133} + return file_openshell_proto_rawDescGZIP(), []int{134} } func (x *StaticCredentialEndpointBinding) GetHost() string { @@ -10507,7 +10677,7 @@ type StaticCredentialBinding struct { func (x *StaticCredentialBinding) Reset() { *x = StaticCredentialBinding{} - mi := &file_openshell_proto_msgTypes[134] + mi := &file_openshell_proto_msgTypes[135] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10519,7 +10689,7 @@ func (x *StaticCredentialBinding) String() string { func (*StaticCredentialBinding) ProtoMessage() {} func (x *StaticCredentialBinding) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[134] + mi := &file_openshell_proto_msgTypes[135] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10532,7 +10702,7 @@ func (x *StaticCredentialBinding) ProtoReflect() protoreflect.Message { // Deprecated: Use StaticCredentialBinding.ProtoReflect.Descriptor instead. func (*StaticCredentialBinding) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{134} + return file_openshell_proto_rawDescGZIP(), []int{135} } func (x *StaticCredentialBinding) GetEndpoints() []*StaticCredentialEndpointBinding { @@ -10589,7 +10759,7 @@ type GetSandboxProviderEnvironmentResponse struct { func (x *GetSandboxProviderEnvironmentResponse) Reset() { *x = GetSandboxProviderEnvironmentResponse{} - mi := &file_openshell_proto_msgTypes[135] + mi := &file_openshell_proto_msgTypes[136] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10601,7 +10771,7 @@ func (x *GetSandboxProviderEnvironmentResponse) String() string { func (*GetSandboxProviderEnvironmentResponse) ProtoMessage() {} func (x *GetSandboxProviderEnvironmentResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[135] + mi := &file_openshell_proto_msgTypes[136] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10614,7 +10784,7 @@ func (x *GetSandboxProviderEnvironmentResponse) ProtoReflect() protoreflect.Mess // Deprecated: Use GetSandboxProviderEnvironmentResponse.ProtoReflect.Descriptor instead. func (*GetSandboxProviderEnvironmentResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{135} + return file_openshell_proto_rawDescGZIP(), []int{136} } func (x *GetSandboxProviderEnvironmentResponse) GetEnvironment() map[string]string { @@ -10697,7 +10867,7 @@ type ExchangeProviderSubjectTokenRequest struct { func (x *ExchangeProviderSubjectTokenRequest) Reset() { *x = ExchangeProviderSubjectTokenRequest{} - mi := &file_openshell_proto_msgTypes[136] + mi := &file_openshell_proto_msgTypes[137] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10709,7 +10879,7 @@ func (x *ExchangeProviderSubjectTokenRequest) String() string { func (*ExchangeProviderSubjectTokenRequest) ProtoMessage() {} func (x *ExchangeProviderSubjectTokenRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[136] + mi := &file_openshell_proto_msgTypes[137] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10722,7 +10892,7 @@ func (x *ExchangeProviderSubjectTokenRequest) ProtoReflect() protoreflect.Messag // Deprecated: Use ExchangeProviderSubjectTokenRequest.ProtoReflect.Descriptor instead. func (*ExchangeProviderSubjectTokenRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{136} + return file_openshell_proto_rawDescGZIP(), []int{137} } func (x *ExchangeProviderSubjectTokenRequest) GetSandboxId() string { @@ -10764,7 +10934,7 @@ type ExchangeProviderSubjectTokenResponse struct { func (x *ExchangeProviderSubjectTokenResponse) Reset() { *x = ExchangeProviderSubjectTokenResponse{} - mi := &file_openshell_proto_msgTypes[137] + mi := &file_openshell_proto_msgTypes[138] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10776,7 +10946,7 @@ func (x *ExchangeProviderSubjectTokenResponse) String() string { func (*ExchangeProviderSubjectTokenResponse) ProtoMessage() {} func (x *ExchangeProviderSubjectTokenResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[137] + mi := &file_openshell_proto_msgTypes[138] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10789,7 +10959,7 @@ func (x *ExchangeProviderSubjectTokenResponse) ProtoReflect() protoreflect.Messa // Deprecated: Use ExchangeProviderSubjectTokenResponse.ProtoReflect.Descriptor instead. func (*ExchangeProviderSubjectTokenResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{137} + return file_openshell_proto_rawDescGZIP(), []int{138} } func (x *ExchangeProviderSubjectTokenResponse) GetAccessToken() string { @@ -10864,7 +11034,7 @@ type UpdateConfigRequest struct { func (x *UpdateConfigRequest) Reset() { *x = UpdateConfigRequest{} - mi := &file_openshell_proto_msgTypes[138] + mi := &file_openshell_proto_msgTypes[139] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10876,7 +11046,7 @@ func (x *UpdateConfigRequest) String() string { func (*UpdateConfigRequest) ProtoMessage() {} func (x *UpdateConfigRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[138] + mi := &file_openshell_proto_msgTypes[139] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10889,7 +11059,7 @@ func (x *UpdateConfigRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use UpdateConfigRequest.ProtoReflect.Descriptor instead. func (*UpdateConfigRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{138} + return file_openshell_proto_rawDescGZIP(), []int{139} } func (x *UpdateConfigRequest) GetName() string { @@ -10986,7 +11156,7 @@ type PolicyMergeOperation struct { func (x *PolicyMergeOperation) Reset() { *x = PolicyMergeOperation{} - mi := &file_openshell_proto_msgTypes[139] + mi := &file_openshell_proto_msgTypes[140] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10998,7 +11168,7 @@ func (x *PolicyMergeOperation) String() string { func (*PolicyMergeOperation) ProtoMessage() {} func (x *PolicyMergeOperation) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[139] + mi := &file_openshell_proto_msgTypes[140] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11011,7 +11181,7 @@ func (x *PolicyMergeOperation) ProtoReflect() protoreflect.Message { // Deprecated: Use PolicyMergeOperation.ProtoReflect.Descriptor instead. func (*PolicyMergeOperation) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{139} + return file_openshell_proto_rawDescGZIP(), []int{140} } func (x *PolicyMergeOperation) GetOperation() isPolicyMergeOperation_Operation { @@ -11125,7 +11295,7 @@ type AddNetworkRule struct { func (x *AddNetworkRule) Reset() { *x = AddNetworkRule{} - mi := &file_openshell_proto_msgTypes[140] + mi := &file_openshell_proto_msgTypes[141] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11137,7 +11307,7 @@ func (x *AddNetworkRule) String() string { func (*AddNetworkRule) ProtoMessage() {} func (x *AddNetworkRule) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[140] + mi := &file_openshell_proto_msgTypes[141] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11150,7 +11320,7 @@ func (x *AddNetworkRule) ProtoReflect() protoreflect.Message { // Deprecated: Use AddNetworkRule.ProtoReflect.Descriptor instead. func (*AddNetworkRule) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{140} + return file_openshell_proto_rawDescGZIP(), []int{141} } func (x *AddNetworkRule) GetRuleName() string { @@ -11178,7 +11348,7 @@ type RemoveNetworkEndpoint struct { func (x *RemoveNetworkEndpoint) Reset() { *x = RemoveNetworkEndpoint{} - mi := &file_openshell_proto_msgTypes[141] + mi := &file_openshell_proto_msgTypes[142] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11190,7 +11360,7 @@ func (x *RemoveNetworkEndpoint) String() string { func (*RemoveNetworkEndpoint) ProtoMessage() {} func (x *RemoveNetworkEndpoint) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[141] + mi := &file_openshell_proto_msgTypes[142] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11203,7 +11373,7 @@ func (x *RemoveNetworkEndpoint) ProtoReflect() protoreflect.Message { // Deprecated: Use RemoveNetworkEndpoint.ProtoReflect.Descriptor instead. func (*RemoveNetworkEndpoint) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{141} + return file_openshell_proto_rawDescGZIP(), []int{142} } func (x *RemoveNetworkEndpoint) GetRuleName() string { @@ -11236,7 +11406,7 @@ type RemoveNetworkRule struct { func (x *RemoveNetworkRule) Reset() { *x = RemoveNetworkRule{} - mi := &file_openshell_proto_msgTypes[142] + mi := &file_openshell_proto_msgTypes[143] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11248,7 +11418,7 @@ func (x *RemoveNetworkRule) String() string { func (*RemoveNetworkRule) ProtoMessage() {} func (x *RemoveNetworkRule) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[142] + mi := &file_openshell_proto_msgTypes[143] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11261,7 +11431,7 @@ func (x *RemoveNetworkRule) ProtoReflect() protoreflect.Message { // Deprecated: Use RemoveNetworkRule.ProtoReflect.Descriptor instead. func (*RemoveNetworkRule) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{142} + return file_openshell_proto_rawDescGZIP(), []int{143} } func (x *RemoveNetworkRule) GetRuleName() string { @@ -11282,7 +11452,7 @@ type AddDenyRules struct { func (x *AddDenyRules) Reset() { *x = AddDenyRules{} - mi := &file_openshell_proto_msgTypes[143] + mi := &file_openshell_proto_msgTypes[144] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11294,7 +11464,7 @@ func (x *AddDenyRules) String() string { func (*AddDenyRules) ProtoMessage() {} func (x *AddDenyRules) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[143] + mi := &file_openshell_proto_msgTypes[144] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11307,7 +11477,7 @@ func (x *AddDenyRules) ProtoReflect() protoreflect.Message { // Deprecated: Use AddDenyRules.ProtoReflect.Descriptor instead. func (*AddDenyRules) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{143} + return file_openshell_proto_rawDescGZIP(), []int{144} } func (x *AddDenyRules) GetHost() string { @@ -11342,7 +11512,7 @@ type AddAllowRules struct { func (x *AddAllowRules) Reset() { *x = AddAllowRules{} - mi := &file_openshell_proto_msgTypes[144] + mi := &file_openshell_proto_msgTypes[145] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11354,7 +11524,7 @@ func (x *AddAllowRules) String() string { func (*AddAllowRules) ProtoMessage() {} func (x *AddAllowRules) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[144] + mi := &file_openshell_proto_msgTypes[145] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11367,7 +11537,7 @@ func (x *AddAllowRules) ProtoReflect() protoreflect.Message { // Deprecated: Use AddAllowRules.ProtoReflect.Descriptor instead. func (*AddAllowRules) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{144} + return file_openshell_proto_rawDescGZIP(), []int{145} } func (x *AddAllowRules) GetHost() string { @@ -11401,7 +11571,7 @@ type RemoveNetworkBinary struct { func (x *RemoveNetworkBinary) Reset() { *x = RemoveNetworkBinary{} - mi := &file_openshell_proto_msgTypes[145] + mi := &file_openshell_proto_msgTypes[146] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11413,7 +11583,7 @@ func (x *RemoveNetworkBinary) String() string { func (*RemoveNetworkBinary) ProtoMessage() {} func (x *RemoveNetworkBinary) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[145] + mi := &file_openshell_proto_msgTypes[146] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11426,7 +11596,7 @@ func (x *RemoveNetworkBinary) ProtoReflect() protoreflect.Message { // Deprecated: Use RemoveNetworkBinary.ProtoReflect.Descriptor instead. func (*RemoveNetworkBinary) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{145} + return file_openshell_proto_rawDescGZIP(), []int{146} } func (x *RemoveNetworkBinary) GetRuleName() string { @@ -11462,7 +11632,7 @@ type UpdateConfigResponse struct { func (x *UpdateConfigResponse) Reset() { *x = UpdateConfigResponse{} - mi := &file_openshell_proto_msgTypes[146] + mi := &file_openshell_proto_msgTypes[147] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11474,7 +11644,7 @@ func (x *UpdateConfigResponse) String() string { func (*UpdateConfigResponse) ProtoMessage() {} func (x *UpdateConfigResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[146] + mi := &file_openshell_proto_msgTypes[147] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11487,7 +11657,7 @@ func (x *UpdateConfigResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use UpdateConfigResponse.ProtoReflect.Descriptor instead. func (*UpdateConfigResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{146} + return file_openshell_proto_rawDescGZIP(), []int{147} } func (x *UpdateConfigResponse) GetVersion() uint32 { @@ -11543,7 +11713,7 @@ type GetSandboxPolicyStatusRequest struct { func (x *GetSandboxPolicyStatusRequest) Reset() { *x = GetSandboxPolicyStatusRequest{} - mi := &file_openshell_proto_msgTypes[147] + mi := &file_openshell_proto_msgTypes[148] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11555,7 +11725,7 @@ func (x *GetSandboxPolicyStatusRequest) String() string { func (*GetSandboxPolicyStatusRequest) ProtoMessage() {} func (x *GetSandboxPolicyStatusRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[147] + mi := &file_openshell_proto_msgTypes[148] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11568,7 +11738,7 @@ func (x *GetSandboxPolicyStatusRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetSandboxPolicyStatusRequest.ProtoReflect.Descriptor instead. func (*GetSandboxPolicyStatusRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{147} + return file_openshell_proto_rawDescGZIP(), []int{148} } func (x *GetSandboxPolicyStatusRequest) GetName() string { @@ -11612,7 +11782,7 @@ type GetSandboxPolicyStatusResponse struct { func (x *GetSandboxPolicyStatusResponse) Reset() { *x = GetSandboxPolicyStatusResponse{} - mi := &file_openshell_proto_msgTypes[148] + mi := &file_openshell_proto_msgTypes[149] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11624,7 +11794,7 @@ func (x *GetSandboxPolicyStatusResponse) String() string { func (*GetSandboxPolicyStatusResponse) ProtoMessage() {} func (x *GetSandboxPolicyStatusResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[148] + mi := &file_openshell_proto_msgTypes[149] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11637,7 +11807,7 @@ func (x *GetSandboxPolicyStatusResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use GetSandboxPolicyStatusResponse.ProtoReflect.Descriptor instead. func (*GetSandboxPolicyStatusResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{148} + return file_openshell_proto_rawDescGZIP(), []int{149} } func (x *GetSandboxPolicyStatusResponse) GetRevision() *SandboxPolicyRevision { @@ -11676,7 +11846,7 @@ type ListSandboxPoliciesRequest struct { func (x *ListSandboxPoliciesRequest) Reset() { *x = ListSandboxPoliciesRequest{} - mi := &file_openshell_proto_msgTypes[149] + mi := &file_openshell_proto_msgTypes[150] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11688,7 +11858,7 @@ func (x *ListSandboxPoliciesRequest) String() string { func (*ListSandboxPoliciesRequest) ProtoMessage() {} func (x *ListSandboxPoliciesRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[149] + mi := &file_openshell_proto_msgTypes[150] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11701,7 +11871,7 @@ func (x *ListSandboxPoliciesRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListSandboxPoliciesRequest.ProtoReflect.Descriptor instead. func (*ListSandboxPoliciesRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{149} + return file_openshell_proto_rawDescGZIP(), []int{150} } func (x *ListSandboxPoliciesRequest) GetName() string { @@ -11753,7 +11923,7 @@ type ListSandboxPoliciesResponse struct { func (x *ListSandboxPoliciesResponse) Reset() { *x = ListSandboxPoliciesResponse{} - mi := &file_openshell_proto_msgTypes[150] + mi := &file_openshell_proto_msgTypes[151] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11765,7 +11935,7 @@ func (x *ListSandboxPoliciesResponse) String() string { func (*ListSandboxPoliciesResponse) ProtoMessage() {} func (x *ListSandboxPoliciesResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[150] + mi := &file_openshell_proto_msgTypes[151] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11778,7 +11948,7 @@ func (x *ListSandboxPoliciesResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListSandboxPoliciesResponse.ProtoReflect.Descriptor instead. func (*ListSandboxPoliciesResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{150} + return file_openshell_proto_rawDescGZIP(), []int{151} } func (x *ListSandboxPoliciesResponse) GetRevisions() []*SandboxPolicyRevision { @@ -11812,7 +11982,7 @@ type ReportPolicyStatusRequest struct { func (x *ReportPolicyStatusRequest) Reset() { *x = ReportPolicyStatusRequest{} - mi := &file_openshell_proto_msgTypes[151] + mi := &file_openshell_proto_msgTypes[152] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11824,7 +11994,7 @@ func (x *ReportPolicyStatusRequest) String() string { func (*ReportPolicyStatusRequest) ProtoMessage() {} func (x *ReportPolicyStatusRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[151] + mi := &file_openshell_proto_msgTypes[152] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11837,7 +12007,7 @@ func (x *ReportPolicyStatusRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ReportPolicyStatusRequest.ProtoReflect.Descriptor instead. func (*ReportPolicyStatusRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{151} + return file_openshell_proto_rawDescGZIP(), []int{152} } func (x *ReportPolicyStatusRequest) GetSandboxId() string { @@ -11877,7 +12047,7 @@ type ReportPolicyStatusResponse struct { func (x *ReportPolicyStatusResponse) Reset() { *x = ReportPolicyStatusResponse{} - mi := &file_openshell_proto_msgTypes[152] + mi := &file_openshell_proto_msgTypes[153] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11889,7 +12059,7 @@ func (x *ReportPolicyStatusResponse) String() string { func (*ReportPolicyStatusResponse) ProtoMessage() {} func (x *ReportPolicyStatusResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[152] + mi := &file_openshell_proto_msgTypes[153] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11902,7 +12072,7 @@ func (x *ReportPolicyStatusResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ReportPolicyStatusResponse.ProtoReflect.Descriptor instead. func (*ReportPolicyStatusResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{152} + return file_openshell_proto_rawDescGZIP(), []int{153} } // A versioned policy revision with metadata. @@ -11935,7 +12105,7 @@ type SandboxPolicyRevision struct { func (x *SandboxPolicyRevision) Reset() { *x = SandboxPolicyRevision{} - mi := &file_openshell_proto_msgTypes[153] + mi := &file_openshell_proto_msgTypes[154] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11947,7 +12117,7 @@ func (x *SandboxPolicyRevision) String() string { func (*SandboxPolicyRevision) ProtoMessage() {} func (x *SandboxPolicyRevision) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[153] + mi := &file_openshell_proto_msgTypes[154] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11960,7 +12130,7 @@ func (x *SandboxPolicyRevision) ProtoReflect() protoreflect.Message { // Deprecated: Use SandboxPolicyRevision.ProtoReflect.Descriptor instead. func (*SandboxPolicyRevision) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{153} + return file_openshell_proto_rawDescGZIP(), []int{154} } func (x *SandboxPolicyRevision) GetVersion() uint32 { @@ -12040,7 +12210,7 @@ type GetSandboxLogsRequest struct { func (x *GetSandboxLogsRequest) Reset() { *x = GetSandboxLogsRequest{} - mi := &file_openshell_proto_msgTypes[154] + mi := &file_openshell_proto_msgTypes[155] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12052,7 +12222,7 @@ func (x *GetSandboxLogsRequest) String() string { func (*GetSandboxLogsRequest) ProtoMessage() {} func (x *GetSandboxLogsRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[154] + mi := &file_openshell_proto_msgTypes[155] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12065,7 +12235,7 @@ func (x *GetSandboxLogsRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetSandboxLogsRequest.ProtoReflect.Descriptor instead. func (*GetSandboxLogsRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{154} + return file_openshell_proto_rawDescGZIP(), []int{155} } func (x *GetSandboxLogsRequest) GetSandboxId() string { @@ -12123,7 +12293,7 @@ type PushSandboxLogsRequest struct { func (x *PushSandboxLogsRequest) Reset() { *x = PushSandboxLogsRequest{} - mi := &file_openshell_proto_msgTypes[155] + mi := &file_openshell_proto_msgTypes[156] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12135,7 +12305,7 @@ func (x *PushSandboxLogsRequest) String() string { func (*PushSandboxLogsRequest) ProtoMessage() {} func (x *PushSandboxLogsRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[155] + mi := &file_openshell_proto_msgTypes[156] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12148,7 +12318,7 @@ func (x *PushSandboxLogsRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use PushSandboxLogsRequest.ProtoReflect.Descriptor instead. func (*PushSandboxLogsRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{155} + return file_openshell_proto_rawDescGZIP(), []int{156} } func (x *PushSandboxLogsRequest) GetSandboxId() string { @@ -12174,7 +12344,7 @@ type PushSandboxLogsResponse struct { func (x *PushSandboxLogsResponse) Reset() { *x = PushSandboxLogsResponse{} - mi := &file_openshell_proto_msgTypes[156] + mi := &file_openshell_proto_msgTypes[157] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12186,7 +12356,7 @@ func (x *PushSandboxLogsResponse) String() string { func (*PushSandboxLogsResponse) ProtoMessage() {} func (x *PushSandboxLogsResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[156] + mi := &file_openshell_proto_msgTypes[157] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12199,7 +12369,7 @@ func (x *PushSandboxLogsResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use PushSandboxLogsResponse.ProtoReflect.Descriptor instead. func (*PushSandboxLogsResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{156} + return file_openshell_proto_rawDescGZIP(), []int{157} } // Get sandbox logs response. @@ -12215,7 +12385,7 @@ type GetSandboxLogsResponse struct { func (x *GetSandboxLogsResponse) Reset() { *x = GetSandboxLogsResponse{} - mi := &file_openshell_proto_msgTypes[157] + mi := &file_openshell_proto_msgTypes[158] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12227,7 +12397,7 @@ func (x *GetSandboxLogsResponse) String() string { func (*GetSandboxLogsResponse) ProtoMessage() {} func (x *GetSandboxLogsResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[157] + mi := &file_openshell_proto_msgTypes[158] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12240,7 +12410,7 @@ func (x *GetSandboxLogsResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use GetSandboxLogsResponse.ProtoReflect.Descriptor instead. func (*GetSandboxLogsResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{157} + return file_openshell_proto_rawDescGZIP(), []int{158} } func (x *GetSandboxLogsResponse) GetLogs() []*SandboxLogLine { @@ -12273,7 +12443,7 @@ type SupervisorMessage struct { func (x *SupervisorMessage) Reset() { *x = SupervisorMessage{} - mi := &file_openshell_proto_msgTypes[158] + mi := &file_openshell_proto_msgTypes[159] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12285,7 +12455,7 @@ func (x *SupervisorMessage) String() string { func (*SupervisorMessage) ProtoMessage() {} func (x *SupervisorMessage) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[158] + mi := &file_openshell_proto_msgTypes[159] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12298,7 +12468,7 @@ func (x *SupervisorMessage) ProtoReflect() protoreflect.Message { // Deprecated: Use SupervisorMessage.ProtoReflect.Descriptor instead. func (*SupervisorMessage) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{158} + return file_openshell_proto_rawDescGZIP(), []int{159} } func (x *SupervisorMessage) GetPayload() isSupervisorMessage_Payload { @@ -12389,7 +12559,7 @@ type GatewayMessage struct { func (x *GatewayMessage) Reset() { *x = GatewayMessage{} - mi := &file_openshell_proto_msgTypes[159] + mi := &file_openshell_proto_msgTypes[160] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12401,7 +12571,7 @@ func (x *GatewayMessage) String() string { func (*GatewayMessage) ProtoMessage() {} func (x *GatewayMessage) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[159] + mi := &file_openshell_proto_msgTypes[160] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12414,7 +12584,7 @@ func (x *GatewayMessage) ProtoReflect() protoreflect.Message { // Deprecated: Use GatewayMessage.ProtoReflect.Descriptor instead. func (*GatewayMessage) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{159} + return file_openshell_proto_rawDescGZIP(), []int{160} } func (x *GatewayMessage) GetPayload() isGatewayMessage_Payload { @@ -12518,7 +12688,7 @@ type SupervisorHello struct { func (x *SupervisorHello) Reset() { *x = SupervisorHello{} - mi := &file_openshell_proto_msgTypes[160] + mi := &file_openshell_proto_msgTypes[161] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12530,7 +12700,7 @@ func (x *SupervisorHello) String() string { func (*SupervisorHello) ProtoMessage() {} func (x *SupervisorHello) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[160] + mi := &file_openshell_proto_msgTypes[161] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12543,7 +12713,7 @@ func (x *SupervisorHello) ProtoReflect() protoreflect.Message { // Deprecated: Use SupervisorHello.ProtoReflect.Descriptor instead. func (*SupervisorHello) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{160} + return file_openshell_proto_rawDescGZIP(), []int{161} } func (x *SupervisorHello) GetSandboxId() string { @@ -12580,7 +12750,7 @@ type SessionAccepted struct { func (x *SessionAccepted) Reset() { *x = SessionAccepted{} - mi := &file_openshell_proto_msgTypes[161] + mi := &file_openshell_proto_msgTypes[162] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12592,7 +12762,7 @@ func (x *SessionAccepted) String() string { func (*SessionAccepted) ProtoMessage() {} func (x *SessionAccepted) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[161] + mi := &file_openshell_proto_msgTypes[162] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12605,7 +12775,7 @@ func (x *SessionAccepted) ProtoReflect() protoreflect.Message { // Deprecated: Use SessionAccepted.ProtoReflect.Descriptor instead. func (*SessionAccepted) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{161} + return file_openshell_proto_rawDescGZIP(), []int{162} } func (x *SessionAccepted) GetSessionId() string { @@ -12633,7 +12803,7 @@ type SessionRejected struct { func (x *SessionRejected) Reset() { *x = SessionRejected{} - mi := &file_openshell_proto_msgTypes[162] + mi := &file_openshell_proto_msgTypes[163] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12645,7 +12815,7 @@ func (x *SessionRejected) String() string { func (*SessionRejected) ProtoMessage() {} func (x *SessionRejected) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[162] + mi := &file_openshell_proto_msgTypes[163] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12658,7 +12828,7 @@ func (x *SessionRejected) ProtoReflect() protoreflect.Message { // Deprecated: Use SessionRejected.ProtoReflect.Descriptor instead. func (*SessionRejected) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{162} + return file_openshell_proto_rawDescGZIP(), []int{163} } func (x *SessionRejected) GetReason() string { @@ -12677,7 +12847,7 @@ type SupervisorHeartbeat struct { func (x *SupervisorHeartbeat) Reset() { *x = SupervisorHeartbeat{} - mi := &file_openshell_proto_msgTypes[163] + mi := &file_openshell_proto_msgTypes[164] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12689,7 +12859,7 @@ func (x *SupervisorHeartbeat) String() string { func (*SupervisorHeartbeat) ProtoMessage() {} func (x *SupervisorHeartbeat) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[163] + mi := &file_openshell_proto_msgTypes[164] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12702,7 +12872,7 @@ func (x *SupervisorHeartbeat) ProtoReflect() protoreflect.Message { // Deprecated: Use SupervisorHeartbeat.ProtoReflect.Descriptor instead. func (*SupervisorHeartbeat) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{163} + return file_openshell_proto_rawDescGZIP(), []int{164} } // Gateway heartbeat. @@ -12714,7 +12884,7 @@ type GatewayHeartbeat struct { func (x *GatewayHeartbeat) Reset() { *x = GatewayHeartbeat{} - mi := &file_openshell_proto_msgTypes[164] + mi := &file_openshell_proto_msgTypes[165] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12726,7 +12896,7 @@ func (x *GatewayHeartbeat) String() string { func (*GatewayHeartbeat) ProtoMessage() {} func (x *GatewayHeartbeat) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[164] + mi := &file_openshell_proto_msgTypes[165] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12739,7 +12909,7 @@ func (x *GatewayHeartbeat) ProtoReflect() protoreflect.Message { // Deprecated: Use GatewayHeartbeat.ProtoReflect.Descriptor instead. func (*GatewayHeartbeat) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{164} + return file_openshell_proto_rawDescGZIP(), []int{165} } // Terminal result reported before the supervisor shuts down. A successful RPC @@ -12756,7 +12926,7 @@ type ReportMainProcessExitRequest struct { func (x *ReportMainProcessExitRequest) Reset() { *x = ReportMainProcessExitRequest{} - mi := &file_openshell_proto_msgTypes[165] + mi := &file_openshell_proto_msgTypes[166] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12768,7 +12938,7 @@ func (x *ReportMainProcessExitRequest) String() string { func (*ReportMainProcessExitRequest) ProtoMessage() {} func (x *ReportMainProcessExitRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[165] + mi := &file_openshell_proto_msgTypes[166] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12781,7 +12951,7 @@ func (x *ReportMainProcessExitRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ReportMainProcessExitRequest.ProtoReflect.Descriptor instead. func (*ReportMainProcessExitRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{165} + return file_openshell_proto_rawDescGZIP(), []int{166} } func (x *ReportMainProcessExitRequest) GetSandboxId() string { @@ -12813,7 +12983,7 @@ type ReportMainProcessExitResponse struct { func (x *ReportMainProcessExitResponse) Reset() { *x = ReportMainProcessExitResponse{} - mi := &file_openshell_proto_msgTypes[166] + mi := &file_openshell_proto_msgTypes[167] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12825,7 +12995,7 @@ func (x *ReportMainProcessExitResponse) String() string { func (*ReportMainProcessExitResponse) ProtoMessage() {} func (x *ReportMainProcessExitResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[166] + mi := &file_openshell_proto_msgTypes[167] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12838,7 +13008,7 @@ func (x *ReportMainProcessExitResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ReportMainProcessExitResponse.ProtoReflect.Descriptor instead. func (*ReportMainProcessExitResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{166} + return file_openshell_proto_rawDescGZIP(), []int{167} } // Terminal-delivery completion reported after all expected foreground SSH @@ -12853,7 +13023,7 @@ type FinalizeMainProcessExitRequest struct { func (x *FinalizeMainProcessExitRequest) Reset() { *x = FinalizeMainProcessExitRequest{} - mi := &file_openshell_proto_msgTypes[167] + mi := &file_openshell_proto_msgTypes[168] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12865,7 +13035,7 @@ func (x *FinalizeMainProcessExitRequest) String() string { func (*FinalizeMainProcessExitRequest) ProtoMessage() {} func (x *FinalizeMainProcessExitRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[167] + mi := &file_openshell_proto_msgTypes[168] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12878,7 +13048,7 @@ func (x *FinalizeMainProcessExitRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use FinalizeMainProcessExitRequest.ProtoReflect.Descriptor instead. func (*FinalizeMainProcessExitRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{167} + return file_openshell_proto_rawDescGZIP(), []int{168} } func (x *FinalizeMainProcessExitRequest) GetSandboxId() string { @@ -12903,7 +13073,7 @@ type FinalizeMainProcessExitResponse struct { func (x *FinalizeMainProcessExitResponse) Reset() { *x = FinalizeMainProcessExitResponse{} - mi := &file_openshell_proto_msgTypes[168] + mi := &file_openshell_proto_msgTypes[169] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12915,7 +13085,7 @@ func (x *FinalizeMainProcessExitResponse) String() string { func (*FinalizeMainProcessExitResponse) ProtoMessage() {} func (x *FinalizeMainProcessExitResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[168] + mi := &file_openshell_proto_msgTypes[169] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12928,7 +13098,7 @@ func (x *FinalizeMainProcessExitResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use FinalizeMainProcessExitResponse.ProtoReflect.Descriptor instead. func (*FinalizeMainProcessExitResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{168} + return file_openshell_proto_rawDescGZIP(), []int{169} } // Gateway requests the supervisor to open a relay channel. @@ -12957,7 +13127,7 @@ type RelayOpen struct { func (x *RelayOpen) Reset() { *x = RelayOpen{} - mi := &file_openshell_proto_msgTypes[169] + mi := &file_openshell_proto_msgTypes[170] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12969,7 +13139,7 @@ func (x *RelayOpen) String() string { func (*RelayOpen) ProtoMessage() {} func (x *RelayOpen) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[169] + mi := &file_openshell_proto_msgTypes[170] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12982,7 +13152,7 @@ func (x *RelayOpen) ProtoReflect() protoreflect.Message { // Deprecated: Use RelayOpen.ProtoReflect.Descriptor instead. func (*RelayOpen) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{169} + return file_openshell_proto_rawDescGZIP(), []int{170} } func (x *RelayOpen) GetChannelId() string { @@ -13049,7 +13219,7 @@ type SshRelayTarget struct { func (x *SshRelayTarget) Reset() { *x = SshRelayTarget{} - mi := &file_openshell_proto_msgTypes[170] + mi := &file_openshell_proto_msgTypes[171] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13061,7 +13231,7 @@ func (x *SshRelayTarget) String() string { func (*SshRelayTarget) ProtoMessage() {} func (x *SshRelayTarget) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[170] + mi := &file_openshell_proto_msgTypes[171] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13074,7 +13244,7 @@ func (x *SshRelayTarget) ProtoReflect() protoreflect.Message { // Deprecated: Use SshRelayTarget.ProtoReflect.Descriptor instead. func (*SshRelayTarget) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{170} + return file_openshell_proto_rawDescGZIP(), []int{171} } // TCP target dialed by the supervisor from inside the sandbox. @@ -13090,7 +13260,7 @@ type TcpRelayTarget struct { func (x *TcpRelayTarget) Reset() { *x = TcpRelayTarget{} - mi := &file_openshell_proto_msgTypes[171] + mi := &file_openshell_proto_msgTypes[172] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13102,7 +13272,7 @@ func (x *TcpRelayTarget) String() string { func (*TcpRelayTarget) ProtoMessage() {} func (x *TcpRelayTarget) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[171] + mi := &file_openshell_proto_msgTypes[172] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13115,7 +13285,7 @@ func (x *TcpRelayTarget) ProtoReflect() protoreflect.Message { // Deprecated: Use TcpRelayTarget.ProtoReflect.Descriptor instead. func (*TcpRelayTarget) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{171} + return file_openshell_proto_rawDescGZIP(), []int{172} } func (x *TcpRelayTarget) GetHost() string { @@ -13143,7 +13313,7 @@ type RelayInit struct { func (x *RelayInit) Reset() { *x = RelayInit{} - mi := &file_openshell_proto_msgTypes[172] + mi := &file_openshell_proto_msgTypes[173] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13155,7 +13325,7 @@ func (x *RelayInit) String() string { func (*RelayInit) ProtoMessage() {} func (x *RelayInit) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[172] + mi := &file_openshell_proto_msgTypes[173] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13168,7 +13338,7 @@ func (x *RelayInit) ProtoReflect() protoreflect.Message { // Deprecated: Use RelayInit.ProtoReflect.Descriptor instead. func (*RelayInit) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{172} + return file_openshell_proto_rawDescGZIP(), []int{173} } func (x *RelayInit) GetChannelId() string { @@ -13195,7 +13365,7 @@ type RelayFrame struct { func (x *RelayFrame) Reset() { *x = RelayFrame{} - mi := &file_openshell_proto_msgTypes[173] + mi := &file_openshell_proto_msgTypes[174] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13207,7 +13377,7 @@ func (x *RelayFrame) String() string { func (*RelayFrame) ProtoMessage() {} func (x *RelayFrame) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[173] + mi := &file_openshell_proto_msgTypes[174] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13220,7 +13390,7 @@ func (x *RelayFrame) ProtoReflect() protoreflect.Message { // Deprecated: Use RelayFrame.ProtoReflect.Descriptor instead. func (*RelayFrame) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{173} + return file_openshell_proto_rawDescGZIP(), []int{174} } func (x *RelayFrame) GetPayload() isRelayFrame_Payload { @@ -13279,7 +13449,7 @@ type RelayOpenResult struct { func (x *RelayOpenResult) Reset() { *x = RelayOpenResult{} - mi := &file_openshell_proto_msgTypes[174] + mi := &file_openshell_proto_msgTypes[175] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13291,7 +13461,7 @@ func (x *RelayOpenResult) String() string { func (*RelayOpenResult) ProtoMessage() {} func (x *RelayOpenResult) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[174] + mi := &file_openshell_proto_msgTypes[175] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13304,7 +13474,7 @@ func (x *RelayOpenResult) ProtoReflect() protoreflect.Message { // Deprecated: Use RelayOpenResult.ProtoReflect.Descriptor instead. func (*RelayOpenResult) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{174} + return file_openshell_proto_rawDescGZIP(), []int{175} } func (x *RelayOpenResult) GetChannelId() string { @@ -13341,7 +13511,7 @@ type RelayClose struct { func (x *RelayClose) Reset() { *x = RelayClose{} - mi := &file_openshell_proto_msgTypes[175] + mi := &file_openshell_proto_msgTypes[176] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13353,7 +13523,7 @@ func (x *RelayClose) String() string { func (*RelayClose) ProtoMessage() {} func (x *RelayClose) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[175] + mi := &file_openshell_proto_msgTypes[176] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13366,7 +13536,7 @@ func (x *RelayClose) ProtoReflect() protoreflect.Message { // Deprecated: Use RelayClose.ProtoReflect.Descriptor instead. func (*RelayClose) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{175} + return file_openshell_proto_rawDescGZIP(), []int{176} } func (x *RelayClose) GetChannelId() string { @@ -13400,7 +13570,7 @@ type L7RequestSample struct { func (x *L7RequestSample) Reset() { *x = L7RequestSample{} - mi := &file_openshell_proto_msgTypes[176] + mi := &file_openshell_proto_msgTypes[177] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13412,7 +13582,7 @@ func (x *L7RequestSample) String() string { func (*L7RequestSample) ProtoMessage() {} func (x *L7RequestSample) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[176] + mi := &file_openshell_proto_msgTypes[177] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13425,7 +13595,7 @@ func (x *L7RequestSample) ProtoReflect() protoreflect.Message { // Deprecated: Use L7RequestSample.ProtoReflect.Descriptor instead. func (*L7RequestSample) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{176} + return file_openshell_proto_rawDescGZIP(), []int{177} } func (x *L7RequestSample) GetMethod() string { @@ -13499,7 +13669,7 @@ type DenialSummary struct { func (x *DenialSummary) Reset() { *x = DenialSummary{} - mi := &file_openshell_proto_msgTypes[177] + mi := &file_openshell_proto_msgTypes[178] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13511,7 +13681,7 @@ func (x *DenialSummary) String() string { func (*DenialSummary) ProtoMessage() {} func (x *DenialSummary) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[177] + mi := &file_openshell_proto_msgTypes[178] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13524,7 +13694,7 @@ func (x *DenialSummary) ProtoReflect() protoreflect.Message { // Deprecated: Use DenialSummary.ProtoReflect.Descriptor instead. func (*DenialSummary) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{177} + return file_openshell_proto_rawDescGZIP(), []int{178} } func (x *DenialSummary) GetSandboxId() string { @@ -13659,7 +13829,7 @@ type DenialGroupCount struct { func (x *DenialGroupCount) Reset() { *x = DenialGroupCount{} - mi := &file_openshell_proto_msgTypes[178] + mi := &file_openshell_proto_msgTypes[179] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13671,7 +13841,7 @@ func (x *DenialGroupCount) String() string { func (*DenialGroupCount) ProtoMessage() {} func (x *DenialGroupCount) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[178] + mi := &file_openshell_proto_msgTypes[179] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13684,7 +13854,7 @@ func (x *DenialGroupCount) ProtoReflect() protoreflect.Message { // Deprecated: Use DenialGroupCount.ProtoReflect.Descriptor instead. func (*DenialGroupCount) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{178} + return file_openshell_proto_rawDescGZIP(), []int{179} } func (x *DenialGroupCount) GetDenyGroup() string { @@ -13717,7 +13887,7 @@ type NetworkActivitySummary struct { func (x *NetworkActivitySummary) Reset() { *x = NetworkActivitySummary{} - mi := &file_openshell_proto_msgTypes[179] + mi := &file_openshell_proto_msgTypes[180] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13729,7 +13899,7 @@ func (x *NetworkActivitySummary) String() string { func (*NetworkActivitySummary) ProtoMessage() {} func (x *NetworkActivitySummary) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[179] + mi := &file_openshell_proto_msgTypes[180] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13742,7 +13912,7 @@ func (x *NetworkActivitySummary) ProtoReflect() protoreflect.Message { // Deprecated: Use NetworkActivitySummary.ProtoReflect.Descriptor instead. func (*NetworkActivitySummary) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{179} + return file_openshell_proto_rawDescGZIP(), []int{180} } func (x *NetworkActivitySummary) GetNetworkActivityCount() uint32 { @@ -13830,7 +14000,7 @@ type PolicyChunk struct { func (x *PolicyChunk) Reset() { *x = PolicyChunk{} - mi := &file_openshell_proto_msgTypes[180] + mi := &file_openshell_proto_msgTypes[181] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13842,7 +14012,7 @@ func (x *PolicyChunk) String() string { func (*PolicyChunk) ProtoMessage() {} func (x *PolicyChunk) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[180] + mi := &file_openshell_proto_msgTypes[181] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13855,7 +14025,7 @@ func (x *PolicyChunk) ProtoReflect() protoreflect.Message { // Deprecated: Use PolicyChunk.ProtoReflect.Descriptor instead. func (*PolicyChunk) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{180} + return file_openshell_proto_rawDescGZIP(), []int{181} } func (x *PolicyChunk) GetId() string { @@ -14043,7 +14213,7 @@ type DraftPolicyUpdate struct { func (x *DraftPolicyUpdate) Reset() { *x = DraftPolicyUpdate{} - mi := &file_openshell_proto_msgTypes[181] + mi := &file_openshell_proto_msgTypes[182] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14055,7 +14225,7 @@ func (x *DraftPolicyUpdate) String() string { func (*DraftPolicyUpdate) ProtoMessage() {} func (x *DraftPolicyUpdate) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[181] + mi := &file_openshell_proto_msgTypes[182] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14068,7 +14238,7 @@ func (x *DraftPolicyUpdate) ProtoReflect() protoreflect.Message { // Deprecated: Use DraftPolicyUpdate.ProtoReflect.Descriptor instead. func (*DraftPolicyUpdate) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{181} + return file_openshell_proto_rawDescGZIP(), []int{182} } func (x *DraftPolicyUpdate) GetDraftVersion() uint64 { @@ -14126,7 +14296,7 @@ type SubmitPolicyAnalysisRequest struct { func (x *SubmitPolicyAnalysisRequest) Reset() { *x = SubmitPolicyAnalysisRequest{} - mi := &file_openshell_proto_msgTypes[182] + mi := &file_openshell_proto_msgTypes[183] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14138,7 +14308,7 @@ func (x *SubmitPolicyAnalysisRequest) String() string { func (*SubmitPolicyAnalysisRequest) ProtoMessage() {} func (x *SubmitPolicyAnalysisRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[182] + mi := &file_openshell_proto_msgTypes[183] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14151,7 +14321,7 @@ func (x *SubmitPolicyAnalysisRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use SubmitPolicyAnalysisRequest.ProtoReflect.Descriptor instead. func (*SubmitPolicyAnalysisRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{182} + return file_openshell_proto_rawDescGZIP(), []int{183} } func (x *SubmitPolicyAnalysisRequest) GetSummaries() []*DenialSummary { @@ -14214,7 +14384,7 @@ type SubmitPolicyAnalysisResponse struct { func (x *SubmitPolicyAnalysisResponse) Reset() { *x = SubmitPolicyAnalysisResponse{} - mi := &file_openshell_proto_msgTypes[183] + mi := &file_openshell_proto_msgTypes[184] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14226,7 +14396,7 @@ func (x *SubmitPolicyAnalysisResponse) String() string { func (*SubmitPolicyAnalysisResponse) ProtoMessage() {} func (x *SubmitPolicyAnalysisResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[183] + mi := &file_openshell_proto_msgTypes[184] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14239,7 +14409,7 @@ func (x *SubmitPolicyAnalysisResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use SubmitPolicyAnalysisResponse.ProtoReflect.Descriptor instead. func (*SubmitPolicyAnalysisResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{183} + return file_openshell_proto_rawDescGZIP(), []int{184} } func (x *SubmitPolicyAnalysisResponse) GetAcceptedChunks() uint32 { @@ -14285,7 +14455,7 @@ type GetDraftPolicyRequest struct { func (x *GetDraftPolicyRequest) Reset() { *x = GetDraftPolicyRequest{} - mi := &file_openshell_proto_msgTypes[184] + mi := &file_openshell_proto_msgTypes[185] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14297,7 +14467,7 @@ func (x *GetDraftPolicyRequest) String() string { func (*GetDraftPolicyRequest) ProtoMessage() {} func (x *GetDraftPolicyRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[184] + mi := &file_openshell_proto_msgTypes[185] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14310,7 +14480,7 @@ func (x *GetDraftPolicyRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetDraftPolicyRequest.ProtoReflect.Descriptor instead. func (*GetDraftPolicyRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{184} + return file_openshell_proto_rawDescGZIP(), []int{185} } func (x *GetDraftPolicyRequest) GetName() string { @@ -14350,7 +14520,7 @@ type GetDraftPolicyResponse struct { func (x *GetDraftPolicyResponse) Reset() { *x = GetDraftPolicyResponse{} - mi := &file_openshell_proto_msgTypes[185] + mi := &file_openshell_proto_msgTypes[186] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14362,7 +14532,7 @@ func (x *GetDraftPolicyResponse) String() string { func (*GetDraftPolicyResponse) ProtoMessage() {} func (x *GetDraftPolicyResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[185] + mi := &file_openshell_proto_msgTypes[186] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14375,7 +14545,7 @@ func (x *GetDraftPolicyResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use GetDraftPolicyResponse.ProtoReflect.Descriptor instead. func (*GetDraftPolicyResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{185} + return file_openshell_proto_rawDescGZIP(), []int{186} } func (x *GetDraftPolicyResponse) GetChunks() []*PolicyChunk { @@ -14427,7 +14597,7 @@ type ApproveDraftChunkRequest struct { func (x *ApproveDraftChunkRequest) Reset() { *x = ApproveDraftChunkRequest{} - mi := &file_openshell_proto_msgTypes[186] + mi := &file_openshell_proto_msgTypes[187] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14439,7 +14609,7 @@ func (x *ApproveDraftChunkRequest) String() string { func (*ApproveDraftChunkRequest) ProtoMessage() {} func (x *ApproveDraftChunkRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[186] + mi := &file_openshell_proto_msgTypes[187] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14452,7 +14622,7 @@ func (x *ApproveDraftChunkRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ApproveDraftChunkRequest.ProtoReflect.Descriptor instead. func (*ApproveDraftChunkRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{186} + return file_openshell_proto_rawDescGZIP(), []int{187} } func (x *ApproveDraftChunkRequest) GetName() string { @@ -14502,7 +14672,7 @@ type ApproveDraftChunkResponse struct { func (x *ApproveDraftChunkResponse) Reset() { *x = ApproveDraftChunkResponse{} - mi := &file_openshell_proto_msgTypes[187] + mi := &file_openshell_proto_msgTypes[188] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14514,7 +14684,7 @@ func (x *ApproveDraftChunkResponse) String() string { func (*ApproveDraftChunkResponse) ProtoMessage() {} func (x *ApproveDraftChunkResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[187] + mi := &file_openshell_proto_msgTypes[188] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14527,7 +14697,7 @@ func (x *ApproveDraftChunkResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ApproveDraftChunkResponse.ProtoReflect.Descriptor instead. func (*ApproveDraftChunkResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{187} + return file_openshell_proto_rawDescGZIP(), []int{188} } func (x *ApproveDraftChunkResponse) GetPolicyVersion() uint32 { @@ -14564,7 +14734,7 @@ type RejectDraftChunkRequest struct { func (x *RejectDraftChunkRequest) Reset() { *x = RejectDraftChunkRequest{} - mi := &file_openshell_proto_msgTypes[188] + mi := &file_openshell_proto_msgTypes[189] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14576,7 +14746,7 @@ func (x *RejectDraftChunkRequest) String() string { func (*RejectDraftChunkRequest) ProtoMessage() {} func (x *RejectDraftChunkRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[188] + mi := &file_openshell_proto_msgTypes[189] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14589,7 +14759,7 @@ func (x *RejectDraftChunkRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use RejectDraftChunkRequest.ProtoReflect.Descriptor instead. func (*RejectDraftChunkRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{188} + return file_openshell_proto_rawDescGZIP(), []int{189} } func (x *RejectDraftChunkRequest) GetName() string { @@ -14635,7 +14805,7 @@ type RejectDraftChunkResponse struct { func (x *RejectDraftChunkResponse) Reset() { *x = RejectDraftChunkResponse{} - mi := &file_openshell_proto_msgTypes[189] + mi := &file_openshell_proto_msgTypes[190] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14647,7 +14817,7 @@ func (x *RejectDraftChunkResponse) String() string { func (*RejectDraftChunkResponse) ProtoMessage() {} func (x *RejectDraftChunkResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[189] + mi := &file_openshell_proto_msgTypes[190] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14660,7 +14830,7 @@ func (x *RejectDraftChunkResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use RejectDraftChunkResponse.ProtoReflect.Descriptor instead. func (*RejectDraftChunkResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{189} + return file_openshell_proto_rawDescGZIP(), []int{190} } // Approve all pending chunks. @@ -14674,7 +14844,7 @@ type DraftChunkApproval struct { func (x *DraftChunkApproval) Reset() { *x = DraftChunkApproval{} - mi := &file_openshell_proto_msgTypes[190] + mi := &file_openshell_proto_msgTypes[191] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14686,7 +14856,7 @@ func (x *DraftChunkApproval) String() string { func (*DraftChunkApproval) ProtoMessage() {} func (x *DraftChunkApproval) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[190] + mi := &file_openshell_proto_msgTypes[191] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14699,7 +14869,7 @@ func (x *DraftChunkApproval) ProtoReflect() protoreflect.Message { // Deprecated: Use DraftChunkApproval.ProtoReflect.Descriptor instead. func (*DraftChunkApproval) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{190} + return file_openshell_proto_rawDescGZIP(), []int{191} } func (x *DraftChunkApproval) GetChunkId() string { @@ -14736,7 +14906,7 @@ type ApproveAllDraftChunksRequest struct { func (x *ApproveAllDraftChunksRequest) Reset() { *x = ApproveAllDraftChunksRequest{} - mi := &file_openshell_proto_msgTypes[191] + mi := &file_openshell_proto_msgTypes[192] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14748,7 +14918,7 @@ func (x *ApproveAllDraftChunksRequest) String() string { func (*ApproveAllDraftChunksRequest) ProtoMessage() {} func (x *ApproveAllDraftChunksRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[191] + mi := &file_openshell_proto_msgTypes[192] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14761,7 +14931,7 @@ func (x *ApproveAllDraftChunksRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ApproveAllDraftChunksRequest.ProtoReflect.Descriptor instead. func (*ApproveAllDraftChunksRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{191} + return file_openshell_proto_rawDescGZIP(), []int{192} } func (x *ApproveAllDraftChunksRequest) GetName() string { @@ -14816,7 +14986,7 @@ type ApproveAllDraftChunksResponse struct { func (x *ApproveAllDraftChunksResponse) Reset() { *x = ApproveAllDraftChunksResponse{} - mi := &file_openshell_proto_msgTypes[192] + mi := &file_openshell_proto_msgTypes[193] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14828,7 +14998,7 @@ func (x *ApproveAllDraftChunksResponse) String() string { func (*ApproveAllDraftChunksResponse) ProtoMessage() {} func (x *ApproveAllDraftChunksResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[192] + mi := &file_openshell_proto_msgTypes[193] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14841,7 +15011,7 @@ func (x *ApproveAllDraftChunksResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ApproveAllDraftChunksResponse.ProtoReflect.Descriptor instead. func (*ApproveAllDraftChunksResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{192} + return file_openshell_proto_rawDescGZIP(), []int{193} } func (x *ApproveAllDraftChunksResponse) GetPolicyVersion() uint32 { @@ -14892,7 +15062,7 @@ type EditDraftChunkRequest struct { func (x *EditDraftChunkRequest) Reset() { *x = EditDraftChunkRequest{} - mi := &file_openshell_proto_msgTypes[193] + mi := &file_openshell_proto_msgTypes[194] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14904,7 +15074,7 @@ func (x *EditDraftChunkRequest) String() string { func (*EditDraftChunkRequest) ProtoMessage() {} func (x *EditDraftChunkRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[193] + mi := &file_openshell_proto_msgTypes[194] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14917,7 +15087,7 @@ func (x *EditDraftChunkRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use EditDraftChunkRequest.ProtoReflect.Descriptor instead. func (*EditDraftChunkRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{193} + return file_openshell_proto_rawDescGZIP(), []int{194} } func (x *EditDraftChunkRequest) GetName() string { @@ -14963,7 +15133,7 @@ type EditDraftChunkResponse struct { func (x *EditDraftChunkResponse) Reset() { *x = EditDraftChunkResponse{} - mi := &file_openshell_proto_msgTypes[194] + mi := &file_openshell_proto_msgTypes[195] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14975,7 +15145,7 @@ func (x *EditDraftChunkResponse) String() string { func (*EditDraftChunkResponse) ProtoMessage() {} func (x *EditDraftChunkResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[194] + mi := &file_openshell_proto_msgTypes[195] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14988,7 +15158,7 @@ func (x *EditDraftChunkResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use EditDraftChunkResponse.ProtoReflect.Descriptor instead. func (*EditDraftChunkResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{194} + return file_openshell_proto_rawDescGZIP(), []int{195} } // Reverse an approval (remove merged rule from active policy). @@ -15009,7 +15179,7 @@ type UndoDraftChunkRequest struct { func (x *UndoDraftChunkRequest) Reset() { *x = UndoDraftChunkRequest{} - mi := &file_openshell_proto_msgTypes[195] + mi := &file_openshell_proto_msgTypes[196] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -15021,7 +15191,7 @@ func (x *UndoDraftChunkRequest) String() string { func (*UndoDraftChunkRequest) ProtoMessage() {} func (x *UndoDraftChunkRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[195] + mi := &file_openshell_proto_msgTypes[196] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15034,7 +15204,7 @@ func (x *UndoDraftChunkRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use UndoDraftChunkRequest.ProtoReflect.Descriptor instead. func (*UndoDraftChunkRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{195} + return file_openshell_proto_rawDescGZIP(), []int{196} } func (x *UndoDraftChunkRequest) GetName() string { @@ -15077,7 +15247,7 @@ type UndoDraftChunkResponse struct { func (x *UndoDraftChunkResponse) Reset() { *x = UndoDraftChunkResponse{} - mi := &file_openshell_proto_msgTypes[196] + mi := &file_openshell_proto_msgTypes[197] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -15089,7 +15259,7 @@ func (x *UndoDraftChunkResponse) String() string { func (*UndoDraftChunkResponse) ProtoMessage() {} func (x *UndoDraftChunkResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[196] + mi := &file_openshell_proto_msgTypes[197] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15102,7 +15272,7 @@ func (x *UndoDraftChunkResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use UndoDraftChunkResponse.ProtoReflect.Descriptor instead. func (*UndoDraftChunkResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{196} + return file_openshell_proto_rawDescGZIP(), []int{197} } func (x *UndoDraftChunkResponse) GetPolicyVersion() uint32 { @@ -15135,7 +15305,7 @@ type ClearDraftChunksRequest struct { func (x *ClearDraftChunksRequest) Reset() { *x = ClearDraftChunksRequest{} - mi := &file_openshell_proto_msgTypes[197] + mi := &file_openshell_proto_msgTypes[198] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -15147,7 +15317,7 @@ func (x *ClearDraftChunksRequest) String() string { func (*ClearDraftChunksRequest) ProtoMessage() {} func (x *ClearDraftChunksRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[197] + mi := &file_openshell_proto_msgTypes[198] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15160,7 +15330,7 @@ func (x *ClearDraftChunksRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ClearDraftChunksRequest.ProtoReflect.Descriptor instead. func (*ClearDraftChunksRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{197} + return file_openshell_proto_rawDescGZIP(), []int{198} } func (x *ClearDraftChunksRequest) GetName() string { @@ -15194,7 +15364,7 @@ type ClearDraftChunksResponse struct { func (x *ClearDraftChunksResponse) Reset() { *x = ClearDraftChunksResponse{} - mi := &file_openshell_proto_msgTypes[198] + mi := &file_openshell_proto_msgTypes[199] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -15206,7 +15376,7 @@ func (x *ClearDraftChunksResponse) String() string { func (*ClearDraftChunksResponse) ProtoMessage() {} func (x *ClearDraftChunksResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[198] + mi := &file_openshell_proto_msgTypes[199] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15219,7 +15389,7 @@ func (x *ClearDraftChunksResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ClearDraftChunksResponse.ProtoReflect.Descriptor instead. func (*ClearDraftChunksResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{198} + return file_openshell_proto_rawDescGZIP(), []int{199} } func (x *ClearDraftChunksResponse) GetChunksCleared() uint32 { @@ -15242,7 +15412,7 @@ type GetDraftHistoryRequest struct { func (x *GetDraftHistoryRequest) Reset() { *x = GetDraftHistoryRequest{} - mi := &file_openshell_proto_msgTypes[199] + mi := &file_openshell_proto_msgTypes[200] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -15254,7 +15424,7 @@ func (x *GetDraftHistoryRequest) String() string { func (*GetDraftHistoryRequest) ProtoMessage() {} func (x *GetDraftHistoryRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[199] + mi := &file_openshell_proto_msgTypes[200] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15267,7 +15437,7 @@ func (x *GetDraftHistoryRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetDraftHistoryRequest.ProtoReflect.Descriptor instead. func (*GetDraftHistoryRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{199} + return file_openshell_proto_rawDescGZIP(), []int{200} } func (x *GetDraftHistoryRequest) GetName() string { @@ -15301,7 +15471,7 @@ type DraftHistoryEntry struct { func (x *DraftHistoryEntry) Reset() { *x = DraftHistoryEntry{} - mi := &file_openshell_proto_msgTypes[200] + mi := &file_openshell_proto_msgTypes[201] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -15313,7 +15483,7 @@ func (x *DraftHistoryEntry) String() string { func (*DraftHistoryEntry) ProtoMessage() {} func (x *DraftHistoryEntry) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[200] + mi := &file_openshell_proto_msgTypes[201] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15326,7 +15496,7 @@ func (x *DraftHistoryEntry) ProtoReflect() protoreflect.Message { // Deprecated: Use DraftHistoryEntry.ProtoReflect.Descriptor instead. func (*DraftHistoryEntry) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{200} + return file_openshell_proto_rawDescGZIP(), []int{201} } func (x *DraftHistoryEntry) GetEventTime() *timestamppb.Timestamp { @@ -15367,7 +15537,7 @@ type GetDraftHistoryResponse struct { func (x *GetDraftHistoryResponse) Reset() { *x = GetDraftHistoryResponse{} - mi := &file_openshell_proto_msgTypes[201] + mi := &file_openshell_proto_msgTypes[202] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -15379,7 +15549,7 @@ func (x *GetDraftHistoryResponse) String() string { func (*GetDraftHistoryResponse) ProtoMessage() {} func (x *GetDraftHistoryResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[201] + mi := &file_openshell_proto_msgTypes[202] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15392,7 +15562,7 @@ func (x *GetDraftHistoryResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use GetDraftHistoryResponse.ProtoReflect.Descriptor instead. func (*GetDraftHistoryResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{201} + return file_openshell_proto_rawDescGZIP(), []int{202} } func (x *GetDraftHistoryResponse) GetEntries() []*DraftHistoryEntry { @@ -15417,7 +15587,7 @@ type CreateWorkspaceRequest struct { func (x *CreateWorkspaceRequest) Reset() { *x = CreateWorkspaceRequest{} - mi := &file_openshell_proto_msgTypes[202] + mi := &file_openshell_proto_msgTypes[203] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -15429,7 +15599,7 @@ func (x *CreateWorkspaceRequest) String() string { func (*CreateWorkspaceRequest) ProtoMessage() {} func (x *CreateWorkspaceRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[202] + mi := &file_openshell_proto_msgTypes[203] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15442,7 +15612,7 @@ func (x *CreateWorkspaceRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use CreateWorkspaceRequest.ProtoReflect.Descriptor instead. func (*CreateWorkspaceRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{202} + return file_openshell_proto_rawDescGZIP(), []int{203} } func (x *CreateWorkspaceRequest) GetName() string { @@ -15476,7 +15646,7 @@ type CreateWorkspaceResponse struct { func (x *CreateWorkspaceResponse) Reset() { *x = CreateWorkspaceResponse{} - mi := &file_openshell_proto_msgTypes[203] + mi := &file_openshell_proto_msgTypes[204] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -15488,7 +15658,7 @@ func (x *CreateWorkspaceResponse) String() string { func (*CreateWorkspaceResponse) ProtoMessage() {} func (x *CreateWorkspaceResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[203] + mi := &file_openshell_proto_msgTypes[204] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15501,7 +15671,7 @@ func (x *CreateWorkspaceResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use CreateWorkspaceResponse.ProtoReflect.Descriptor instead. func (*CreateWorkspaceResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{203} + return file_openshell_proto_rawDescGZIP(), []int{204} } func (x *CreateWorkspaceResponse) GetWorkspace() *datamodelv1.Workspace { @@ -15522,7 +15692,7 @@ type GetWorkspaceRequest struct { func (x *GetWorkspaceRequest) Reset() { *x = GetWorkspaceRequest{} - mi := &file_openshell_proto_msgTypes[204] + mi := &file_openshell_proto_msgTypes[205] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -15534,7 +15704,7 @@ func (x *GetWorkspaceRequest) String() string { func (*GetWorkspaceRequest) ProtoMessage() {} func (x *GetWorkspaceRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[204] + mi := &file_openshell_proto_msgTypes[205] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15547,7 +15717,7 @@ func (x *GetWorkspaceRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetWorkspaceRequest.ProtoReflect.Descriptor instead. func (*GetWorkspaceRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{204} + return file_openshell_proto_rawDescGZIP(), []int{205} } func (x *GetWorkspaceRequest) GetName() string { @@ -15567,7 +15737,7 @@ type GetWorkspaceResponse struct { func (x *GetWorkspaceResponse) Reset() { *x = GetWorkspaceResponse{} - mi := &file_openshell_proto_msgTypes[205] + mi := &file_openshell_proto_msgTypes[206] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -15579,7 +15749,7 @@ func (x *GetWorkspaceResponse) String() string { func (*GetWorkspaceResponse) ProtoMessage() {} func (x *GetWorkspaceResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[205] + mi := &file_openshell_proto_msgTypes[206] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15592,7 +15762,7 @@ func (x *GetWorkspaceResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use GetWorkspaceResponse.ProtoReflect.Descriptor instead. func (*GetWorkspaceResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{205} + return file_openshell_proto_rawDescGZIP(), []int{206} } func (x *GetWorkspaceResponse) GetWorkspace() *datamodelv1.Workspace { @@ -15619,7 +15789,7 @@ type ListWorkspacesRequest struct { func (x *ListWorkspacesRequest) Reset() { *x = ListWorkspacesRequest{} - mi := &file_openshell_proto_msgTypes[206] + mi := &file_openshell_proto_msgTypes[207] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -15631,7 +15801,7 @@ func (x *ListWorkspacesRequest) String() string { func (*ListWorkspacesRequest) ProtoMessage() {} func (x *ListWorkspacesRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[206] + mi := &file_openshell_proto_msgTypes[207] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15644,7 +15814,7 @@ func (x *ListWorkspacesRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListWorkspacesRequest.ProtoReflect.Descriptor instead. func (*ListWorkspacesRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{206} + return file_openshell_proto_rawDescGZIP(), []int{207} } func (x *ListWorkspacesRequest) GetPageSize() int32 { @@ -15680,7 +15850,7 @@ type ListWorkspacesResponse struct { func (x *ListWorkspacesResponse) Reset() { *x = ListWorkspacesResponse{} - mi := &file_openshell_proto_msgTypes[207] + mi := &file_openshell_proto_msgTypes[208] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -15692,7 +15862,7 @@ func (x *ListWorkspacesResponse) String() string { func (*ListWorkspacesResponse) ProtoMessage() {} func (x *ListWorkspacesResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[207] + mi := &file_openshell_proto_msgTypes[208] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15705,7 +15875,7 @@ func (x *ListWorkspacesResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListWorkspacesResponse.ProtoReflect.Descriptor instead. func (*ListWorkspacesResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{207} + return file_openshell_proto_rawDescGZIP(), []int{208} } func (x *ListWorkspacesResponse) GetWorkspaces() []*datamodelv1.Workspace { @@ -15736,7 +15906,7 @@ type DeleteWorkspaceRequest struct { func (x *DeleteWorkspaceRequest) Reset() { *x = DeleteWorkspaceRequest{} - mi := &file_openshell_proto_msgTypes[208] + mi := &file_openshell_proto_msgTypes[209] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -15748,7 +15918,7 @@ func (x *DeleteWorkspaceRequest) String() string { func (*DeleteWorkspaceRequest) ProtoMessage() {} func (x *DeleteWorkspaceRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[208] + mi := &file_openshell_proto_msgTypes[209] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15761,7 +15931,7 @@ func (x *DeleteWorkspaceRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteWorkspaceRequest.ProtoReflect.Descriptor instead. func (*DeleteWorkspaceRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{208} + return file_openshell_proto_rawDescGZIP(), []int{209} } func (x *DeleteWorkspaceRequest) GetName() string { @@ -15795,7 +15965,7 @@ type DeleteWorkspaceResponse struct { func (x *DeleteWorkspaceResponse) Reset() { *x = DeleteWorkspaceResponse{} - mi := &file_openshell_proto_msgTypes[209] + mi := &file_openshell_proto_msgTypes[210] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -15807,7 +15977,7 @@ func (x *DeleteWorkspaceResponse) String() string { func (*DeleteWorkspaceResponse) ProtoMessage() {} func (x *DeleteWorkspaceResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[209] + mi := &file_openshell_proto_msgTypes[210] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15820,7 +15990,7 @@ func (x *DeleteWorkspaceResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteWorkspaceResponse.ProtoReflect.Descriptor instead. func (*DeleteWorkspaceResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{209} + return file_openshell_proto_rawDescGZIP(), []int{210} } func (x *DeleteWorkspaceResponse) GetOutcome() DeletionOutcome { @@ -15844,7 +16014,7 @@ type WorkspaceMember struct { func (x *WorkspaceMember) Reset() { *x = WorkspaceMember{} - mi := &file_openshell_proto_msgTypes[210] + mi := &file_openshell_proto_msgTypes[211] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -15856,7 +16026,7 @@ func (x *WorkspaceMember) String() string { func (*WorkspaceMember) ProtoMessage() {} func (x *WorkspaceMember) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[210] + mi := &file_openshell_proto_msgTypes[211] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15869,7 +16039,7 @@ func (x *WorkspaceMember) ProtoReflect() protoreflect.Message { // Deprecated: Use WorkspaceMember.ProtoReflect.Descriptor instead. func (*WorkspaceMember) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{210} + return file_openshell_proto_rawDescGZIP(), []int{211} } func (x *WorkspaceMember) GetMetadata() *datamodelv1.ObjectMeta { @@ -15910,7 +16080,7 @@ type AddWorkspaceMemberRequest struct { func (x *AddWorkspaceMemberRequest) Reset() { *x = AddWorkspaceMemberRequest{} - mi := &file_openshell_proto_msgTypes[211] + mi := &file_openshell_proto_msgTypes[212] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -15922,7 +16092,7 @@ func (x *AddWorkspaceMemberRequest) String() string { func (*AddWorkspaceMemberRequest) ProtoMessage() {} func (x *AddWorkspaceMemberRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[211] + mi := &file_openshell_proto_msgTypes[212] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15935,7 +16105,7 @@ func (x *AddWorkspaceMemberRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use AddWorkspaceMemberRequest.ProtoReflect.Descriptor instead. func (*AddWorkspaceMemberRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{211} + return file_openshell_proto_rawDescGZIP(), []int{212} } func (x *AddWorkspaceMemberRequest) GetWorkspace() string { @@ -15976,7 +16146,7 @@ type AddWorkspaceMemberResponse struct { func (x *AddWorkspaceMemberResponse) Reset() { *x = AddWorkspaceMemberResponse{} - mi := &file_openshell_proto_msgTypes[212] + mi := &file_openshell_proto_msgTypes[213] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -15988,7 +16158,7 @@ func (x *AddWorkspaceMemberResponse) String() string { func (*AddWorkspaceMemberResponse) ProtoMessage() {} func (x *AddWorkspaceMemberResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[212] + mi := &file_openshell_proto_msgTypes[213] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16001,7 +16171,7 @@ func (x *AddWorkspaceMemberResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use AddWorkspaceMemberResponse.ProtoReflect.Descriptor instead. func (*AddWorkspaceMemberResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{212} + return file_openshell_proto_rawDescGZIP(), []int{213} } func (x *AddWorkspaceMemberResponse) GetMember() *WorkspaceMember { @@ -16027,7 +16197,7 @@ type RemoveWorkspaceMemberRequest struct { func (x *RemoveWorkspaceMemberRequest) Reset() { *x = RemoveWorkspaceMemberRequest{} - mi := &file_openshell_proto_msgTypes[213] + mi := &file_openshell_proto_msgTypes[214] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -16039,7 +16209,7 @@ func (x *RemoveWorkspaceMemberRequest) String() string { func (*RemoveWorkspaceMemberRequest) ProtoMessage() {} func (x *RemoveWorkspaceMemberRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[213] + mi := &file_openshell_proto_msgTypes[214] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16052,7 +16222,7 @@ func (x *RemoveWorkspaceMemberRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use RemoveWorkspaceMemberRequest.ProtoReflect.Descriptor instead. func (*RemoveWorkspaceMemberRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{213} + return file_openshell_proto_rawDescGZIP(), []int{214} } func (x *RemoveWorkspaceMemberRequest) GetWorkspace() string { @@ -16093,7 +16263,7 @@ type RemoveWorkspaceMemberResponse struct { func (x *RemoveWorkspaceMemberResponse) Reset() { *x = RemoveWorkspaceMemberResponse{} - mi := &file_openshell_proto_msgTypes[214] + mi := &file_openshell_proto_msgTypes[215] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -16105,7 +16275,7 @@ func (x *RemoveWorkspaceMemberResponse) String() string { func (*RemoveWorkspaceMemberResponse) ProtoMessage() {} func (x *RemoveWorkspaceMemberResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[214] + mi := &file_openshell_proto_msgTypes[215] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16118,7 +16288,7 @@ func (x *RemoveWorkspaceMemberResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use RemoveWorkspaceMemberResponse.ProtoReflect.Descriptor instead. func (*RemoveWorkspaceMemberResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{214} + return file_openshell_proto_rawDescGZIP(), []int{215} } func (x *RemoveWorkspaceMemberResponse) GetOutcome() DeletionOutcome { @@ -16145,7 +16315,7 @@ type ListWorkspaceMembersRequest struct { func (x *ListWorkspaceMembersRequest) Reset() { *x = ListWorkspaceMembersRequest{} - mi := &file_openshell_proto_msgTypes[215] + mi := &file_openshell_proto_msgTypes[216] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -16157,7 +16327,7 @@ func (x *ListWorkspaceMembersRequest) String() string { func (*ListWorkspaceMembersRequest) ProtoMessage() {} func (x *ListWorkspaceMembersRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[215] + mi := &file_openshell_proto_msgTypes[216] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16170,7 +16340,7 @@ func (x *ListWorkspaceMembersRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListWorkspaceMembersRequest.ProtoReflect.Descriptor instead. func (*ListWorkspaceMembersRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{215} + return file_openshell_proto_rawDescGZIP(), []int{216} } func (x *ListWorkspaceMembersRequest) GetWorkspace() string { @@ -16206,7 +16376,7 @@ type ListWorkspaceMembersResponse struct { func (x *ListWorkspaceMembersResponse) Reset() { *x = ListWorkspaceMembersResponse{} - mi := &file_openshell_proto_msgTypes[216] + mi := &file_openshell_proto_msgTypes[217] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -16218,7 +16388,7 @@ func (x *ListWorkspaceMembersResponse) String() string { func (*ListWorkspaceMembersResponse) ProtoMessage() {} func (x *ListWorkspaceMembersResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[216] + mi := &file_openshell_proto_msgTypes[217] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16231,7 +16401,7 @@ func (x *ListWorkspaceMembersResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListWorkspaceMembersResponse.ProtoReflect.Descriptor instead. func (*ListWorkspaceMembersResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{216} + return file_openshell_proto_rawDescGZIP(), []int{217} } func (x *ListWorkspaceMembersResponse) GetMembers() []*WorkspaceMember { @@ -16266,7 +16436,7 @@ type ExtensionServiceCredential struct { func (x *ExtensionServiceCredential) Reset() { *x = ExtensionServiceCredential{} - mi := &file_openshell_proto_msgTypes[217] + mi := &file_openshell_proto_msgTypes[218] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -16278,7 +16448,7 @@ func (x *ExtensionServiceCredential) String() string { func (*ExtensionServiceCredential) ProtoMessage() {} func (x *ExtensionServiceCredential) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[217] + mi := &file_openshell_proto_msgTypes[218] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16291,7 +16461,7 @@ func (x *ExtensionServiceCredential) ProtoReflect() protoreflect.Message { // Deprecated: Use ExtensionServiceCredential.ProtoReflect.Descriptor instead. func (*ExtensionServiceCredential) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{217} + return file_openshell_proto_rawDescGZIP(), []int{218} } func (x *ExtensionServiceCredential) GetServiceName() string { @@ -16328,7 +16498,7 @@ type EndpointObservation struct { func (x *EndpointObservation) Reset() { *x = EndpointObservation{} - mi := &file_openshell_proto_msgTypes[218] + mi := &file_openshell_proto_msgTypes[219] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -16340,7 +16510,7 @@ func (x *EndpointObservation) String() string { func (*EndpointObservation) ProtoMessage() {} func (x *EndpointObservation) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[218] + mi := &file_openshell_proto_msgTypes[219] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16353,7 +16523,7 @@ func (x *EndpointObservation) ProtoReflect() protoreflect.Message { // Deprecated: Use EndpointObservation.ProtoReflect.Descriptor instead. func (*EndpointObservation) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{218} + return file_openshell_proto_rawDescGZIP(), []int{219} } func (x *EndpointObservation) GetEndpointId() string { @@ -16396,7 +16566,7 @@ type ReportEndpointStatusRequest struct { func (x *ReportEndpointStatusRequest) Reset() { *x = ReportEndpointStatusRequest{} - mi := &file_openshell_proto_msgTypes[219] + mi := &file_openshell_proto_msgTypes[220] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -16408,7 +16578,7 @@ func (x *ReportEndpointStatusRequest) String() string { func (*ReportEndpointStatusRequest) ProtoMessage() {} func (x *ReportEndpointStatusRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[219] + mi := &file_openshell_proto_msgTypes[220] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16421,7 +16591,7 @@ func (x *ReportEndpointStatusRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ReportEndpointStatusRequest.ProtoReflect.Descriptor instead. func (*ReportEndpointStatusRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{219} + return file_openshell_proto_rawDescGZIP(), []int{220} } func (x *ReportEndpointStatusRequest) GetSandboxId() string { @@ -16482,7 +16652,7 @@ type ReportEndpointStatusResponse struct { func (x *ReportEndpointStatusResponse) Reset() { *x = ReportEndpointStatusResponse{} - mi := &file_openshell_proto_msgTypes[220] + mi := &file_openshell_proto_msgTypes[221] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -16494,7 +16664,7 @@ func (x *ReportEndpointStatusResponse) String() string { func (*ReportEndpointStatusResponse) ProtoMessage() {} func (x *ReportEndpointStatusResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[220] + mi := &file_openshell_proto_msgTypes[221] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16507,7 +16677,7 @@ func (x *ReportEndpointStatusResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ReportEndpointStatusResponse.ProtoReflect.Descriptor instead. func (*ReportEndpointStatusResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{220} + return file_openshell_proto_rawDescGZIP(), []int{221} } // A configured endpoint and its last accepted network result in one record. @@ -16536,7 +16706,7 @@ type EndpointStatus struct { func (x *EndpointStatus) Reset() { *x = EndpointStatus{} - mi := &file_openshell_proto_msgTypes[221] + mi := &file_openshell_proto_msgTypes[222] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -16548,7 +16718,7 @@ func (x *EndpointStatus) String() string { func (*EndpointStatus) ProtoMessage() {} func (x *EndpointStatus) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[221] + mi := &file_openshell_proto_msgTypes[222] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16561,7 +16731,7 @@ func (x *EndpointStatus) ProtoReflect() protoreflect.Message { // Deprecated: Use EndpointStatus.ProtoReflect.Descriptor instead. func (*EndpointStatus) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{221} + return file_openshell_proto_rawDescGZIP(), []int{222} } func (x *EndpointStatus) GetEndpointId() string { @@ -16637,11 +16807,23 @@ const file_openshell_proto_rawDesc = "" + "\x05roles\x18\x03 \x03(\tR\x05roles\x12\x16\n" + "\x06scopes\x18\x04 \x03(\tR\x06scopes\x12+\n" + "\x11identity_provider\x18\x05 \x01(\tR\x10identityProvider\"\x17\n" + - "\x15GetGatewayInfoRequest\"\xc0\x01\n" + + "\x15GetGatewayInfoRequest\"\x87\x02\n" + "\x16GetGatewayInfoResponse\x123\n" + "\x06status\x18\x01 \x01(\x0e2\x1b.openshell.v1.ServiceStatusR\x06status\x12'\n" + "\x0fgateway_version\x18\x02 \x01(\tR\x0egatewayVersion\x12H\n" + - "\x0fcompute_drivers\x18\x03 \x03(\v2\x1f.openshell.v1.ComputeDriverInfoR\x0ecomputeDrivers\"t\n" + + "\x0fcompute_drivers\x18\x03 \x03(\v2\x1f.openshell.v1.ComputeDriverInfoR\x0ecomputeDrivers\x12E\n" + + "\n" + + "extensions\x18\x04 \x03(\v2%.openshell.v1.NegotiatedExtensionInfoR\n" + + "extensions\"\x95\x03\n" + + "\x17NegotiatedExtensionInfo\x12/\n" + + "\x04kind\x18\x01 \x01(\x0e2\x1b.openshell.v1.ExtensionKindR\x04kind\x12'\n" + + "\x0fconfigured_name\x18\x02 \x01(\tR\x0econfiguredName\x12/\n" + + "\x13implementation_name\x18\x03 \x01(\tR\x12implementationName\x125\n" + + "\x16implementation_version\x18\x04 \x01(\tR\x15implementationVersion\x12%\n" + + "\x0eprotocol_major\x18\x05 \x01(\rR\rprotocolMajor\x12%\n" + + "\x0eprotocol_minor\x18\x06 \x01(\rR\rprotocolMinor\x125\n" + + "\x16supported_capabilities\x18\a \x03(\tR\x15supportedCapabilities\x123\n" + + "\x15required_capabilities\x18\b \x03(\tR\x14requiredCapabilities\"t\n" + "\x11ComputeDriverInfo\x12\x12\n" + "\x04name\x18\x01 \x01(\tR\x04name\x12K\n" + "\fcapabilities\x18\x02 \x01(\v2'.openshell.v1.ComputeDriverCapabilitiesR\fcapabilities\"\xbc\x01\n" + @@ -17845,7 +18027,13 @@ const file_openshell_proto_rawDesc = "" + "\x04path\x18\x04 \x01(\tR\x04path\x12=\n" + "\vlast_result\x18\x05 \x01(\x0e2\x1c.openshell.v1.EndpointResultR\n" + "lastResult\x12H\n" + - "\x12last_reported_time\x18j \x01(\v2\x1a.google.protobuf.TimestampR\x10lastReportedTimeJ\x04\b\x06\x10\aR\x10last_reported_at*\xa6\x02\n" + + "\x12last_reported_time\x18j \x01(\v2\x1a.google.protobuf.TimestampR\x10lastReportedTimeJ\x04\b\x06\x10\aR\x10last_reported_at*\xca\x01\n" + + "\rExtensionKind\x12\x1e\n" + + "\x1aEXTENSION_KIND_UNSPECIFIED\x10\x00\x12!\n" + + "\x1dEXTENSION_KIND_COMPUTE_DRIVER\x10\x01\x12$\n" + + " EXTENSION_KIND_CREDENTIAL_DRIVER\x10\x02\x12&\n" + + "\"EXTENSION_KIND_GATEWAY_INTERCEPTOR\x10\x03\x12(\n" + + "$EXTENSION_KIND_SUPERVISOR_MIDDLEWARE\x10\x04*\xa6\x02\n" + "\fSandboxPhase\x12\x1d\n" + "\x19SANDBOX_PHASE_UNSPECIFIED\x10\x00\x12\x1e\n" + "\x1aSANDBOX_PHASE_PROVISIONING\x10\x01\x12\x17\n" + @@ -18139,731 +18327,735 @@ func file_openshell_proto_rawDescGZIP() []byte { return file_openshell_proto_rawDescData } -var file_openshell_proto_enumTypes = make([]protoimpl.EnumInfo, 16) -var file_openshell_proto_msgTypes = make([]protoimpl.MessageInfo, 243) +var file_openshell_proto_enumTypes = make([]protoimpl.EnumInfo, 17) +var file_openshell_proto_msgTypes = make([]protoimpl.MessageInfo, 244) var file_openshell_proto_goTypes = []any{ - (SandboxPhase)(0), // 0: openshell.v1.SandboxPhase - (ProviderMutationKind)(0), // 1: openshell.v1.ProviderMutationKind - (ProviderReadinessState)(0), // 2: openshell.v1.ProviderReadinessState - (ProviderReadinessReason)(0), // 3: openshell.v1.ProviderReadinessReason - (ConfigComponent)(0), // 4: openshell.v1.ConfigComponent - (ConfigApplyOutcome)(0), // 5: openshell.v1.ConfigApplyOutcome - (ConfigUpdateOperationState)(0), // 6: openshell.v1.ConfigUpdateOperationState - (ProviderCredentialTokenGrantType)(0), // 7: openshell.v1.ProviderCredentialTokenGrantType - (ProviderCredentialRefreshStrategy)(0), // 8: openshell.v1.ProviderCredentialRefreshStrategy - (ProviderProfileCategory)(0), // 9: openshell.v1.ProviderProfileCategory - (PolicyStatus)(0), // 10: openshell.v1.PolicyStatus - (ServiceStatus)(0), // 11: openshell.v1.ServiceStatus - (WorkspaceRole)(0), // 12: openshell.v1.WorkspaceRole - (ProviderCredentialRefreshRecoveryAction)(0), // 13: openshell.v1.ProviderCredentialRefreshRecoveryAction - (DeletionOutcome)(0), // 14: openshell.v1.DeletionOutcome - (EndpointResult)(0), // 15: openshell.v1.EndpointResult - (*IssueSandboxTokenRequest)(nil), // 16: openshell.v1.IssueSandboxTokenRequest - (*IssueSandboxTokenResponse)(nil), // 17: openshell.v1.IssueSandboxTokenResponse - (*RefreshSandboxTokenRequest)(nil), // 18: openshell.v1.RefreshSandboxTokenRequest - (*RefreshSandboxTokenResponse)(nil), // 19: openshell.v1.RefreshSandboxTokenResponse - (*HealthRequest)(nil), // 20: openshell.v1.HealthRequest - (*HealthResponse)(nil), // 21: openshell.v1.HealthResponse - (*GetCurrentUserRequest)(nil), // 22: openshell.v1.GetCurrentUserRequest - (*GetCurrentUserResponse)(nil), // 23: openshell.v1.GetCurrentUserResponse - (*GetGatewayInfoRequest)(nil), // 24: openshell.v1.GetGatewayInfoRequest - (*GetGatewayInfoResponse)(nil), // 25: openshell.v1.GetGatewayInfoResponse - (*ComputeDriverInfo)(nil), // 26: openshell.v1.ComputeDriverInfo - (*ComputeDriverCapabilities)(nil), // 27: openshell.v1.ComputeDriverCapabilities - (*ResourceCapabilities)(nil), // 28: openshell.v1.ResourceCapabilities - (*CpuResourceCapabilities)(nil), // 29: openshell.v1.CpuResourceCapabilities - (*MemoryResourceCapabilities)(nil), // 30: openshell.v1.MemoryResourceCapabilities - (*GpuResourceCapabilities)(nil), // 31: openshell.v1.GpuResourceCapabilities - (*Sandbox)(nil), // 32: openshell.v1.Sandbox - (*SandboxSpec)(nil), // 33: openshell.v1.SandboxSpec - (*ResourceRequirements)(nil), // 34: openshell.v1.ResourceRequirements - (*GpuResourceRequirements)(nil), // 35: openshell.v1.GpuResourceRequirements - (*SandboxTemplate)(nil), // 36: openshell.v1.SandboxTemplate - (*SandboxWorkloadTemplate)(nil), // 37: openshell.v1.SandboxWorkloadTemplate - (*SandboxWorkloadTemplateSpec)(nil), // 38: openshell.v1.SandboxWorkloadTemplateSpec - (*SandboxWorkloadConfig)(nil), // 39: openshell.v1.SandboxWorkloadConfig - (*SandboxResources)(nil), // 40: openshell.v1.SandboxResources - (*SandboxServiceLevel)(nil), // 41: openshell.v1.SandboxServiceLevel - (*SandboxStartup)(nil), // 42: openshell.v1.SandboxStartup - (*SandboxWorkloadTemplateProvenance)(nil), // 43: openshell.v1.SandboxWorkloadTemplateProvenance - (*SandboxStatus)(nil), // 44: openshell.v1.SandboxStatus - (*SandboxCondition)(nil), // 45: openshell.v1.SandboxCondition - (*PlatformEvent)(nil), // 46: openshell.v1.PlatformEvent - (*CreateSandboxRequest)(nil), // 47: openshell.v1.CreateSandboxRequest - (*CreateSandboxTemplateRequest)(nil), // 48: openshell.v1.CreateSandboxTemplateRequest - (*GetSandboxTemplateRequest)(nil), // 49: openshell.v1.GetSandboxTemplateRequest - (*ListSandboxTemplatesRequest)(nil), // 50: openshell.v1.ListSandboxTemplatesRequest - (*DeleteSandboxTemplateRequest)(nil), // 51: openshell.v1.DeleteSandboxTemplateRequest - (*SandboxTemplateResponse)(nil), // 52: openshell.v1.SandboxTemplateResponse - (*ListSandboxTemplatesResponse)(nil), // 53: openshell.v1.ListSandboxTemplatesResponse - (*DeleteSandboxTemplateResponse)(nil), // 54: openshell.v1.DeleteSandboxTemplateResponse - (*BeginRootfsTarStagingRequest)(nil), // 55: openshell.v1.BeginRootfsTarStagingRequest - (*BeginRootfsTarStagingResponse)(nil), // 56: openshell.v1.BeginRootfsTarStagingResponse - (*GetSandboxRequest)(nil), // 57: openshell.v1.GetSandboxRequest - (*ListSandboxesRequest)(nil), // 58: openshell.v1.ListSandboxesRequest - (*ListSandboxProvidersRequest)(nil), // 59: openshell.v1.ListSandboxProvidersRequest - (*AttachSandboxProviderRequest)(nil), // 60: openshell.v1.AttachSandboxProviderRequest - (*DetachSandboxProviderRequest)(nil), // 61: openshell.v1.DetachSandboxProviderRequest - (*DeleteSandboxRequest)(nil), // 62: openshell.v1.DeleteSandboxRequest - (*StopSandboxRequest)(nil), // 63: openshell.v1.StopSandboxRequest - (*StartSandboxRequest)(nil), // 64: openshell.v1.StartSandboxRequest - (*SandboxResponse)(nil), // 65: openshell.v1.SandboxResponse - (*ListSandboxesResponse)(nil), // 66: openshell.v1.ListSandboxesResponse - (*ListSandboxProvidersResponse)(nil), // 67: openshell.v1.ListSandboxProvidersResponse - (*AttachSandboxProviderResponse)(nil), // 68: openshell.v1.AttachSandboxProviderResponse - (*DetachSandboxProviderResponse)(nil), // 69: openshell.v1.DetachSandboxProviderResponse - (*ProviderDesiredIdentity)(nil), // 70: openshell.v1.ProviderDesiredIdentity - (*ConfigSnapshotRevision)(nil), // 71: openshell.v1.ConfigSnapshotRevision - (*SandboxConfigRevision)(nil), // 72: openshell.v1.SandboxConfigRevision - (*ConfigUpdateOperation)(nil), // 73: openshell.v1.ConfigUpdateOperation - (*ProviderMutationReceipt)(nil), // 74: openshell.v1.ProviderMutationReceipt - (*ProviderReadinessObservation)(nil), // 75: openshell.v1.ProviderReadinessObservation - (*ProviderReadinessStatus)(nil), // 76: openshell.v1.ProviderReadinessStatus - (*GetSandboxProviderStatusRequest)(nil), // 77: openshell.v1.GetSandboxProviderStatusRequest - (*GetSandboxProviderStatusResponse)(nil), // 78: openshell.v1.GetSandboxProviderStatusResponse - (*ReportProviderReadinessRequest)(nil), // 79: openshell.v1.ReportProviderReadinessRequest - (*ReportProviderReadinessResponse)(nil), // 80: openshell.v1.ReportProviderReadinessResponse - (*DeleteSandboxResponse)(nil), // 81: openshell.v1.DeleteSandboxResponse - (*CreateSshSessionRequest)(nil), // 82: openshell.v1.CreateSshSessionRequest - (*CreateSshSessionResponse)(nil), // 83: openshell.v1.CreateSshSessionResponse - (*ExposeServiceRequest)(nil), // 84: openshell.v1.ExposeServiceRequest - (*GetServiceRequest)(nil), // 85: openshell.v1.GetServiceRequest - (*ListServicesRequest)(nil), // 86: openshell.v1.ListServicesRequest - (*ListServicesResponse)(nil), // 87: openshell.v1.ListServicesResponse - (*DeleteServiceRequest)(nil), // 88: openshell.v1.DeleteServiceRequest - (*DeleteServiceResponse)(nil), // 89: openshell.v1.DeleteServiceResponse - (*ServiceEndpoint)(nil), // 90: openshell.v1.ServiceEndpoint - (*ServiceEndpointResponse)(nil), // 91: openshell.v1.ServiceEndpointResponse - (*RevokeSshSessionRequest)(nil), // 92: openshell.v1.RevokeSshSessionRequest - (*RevokeSshSessionResponse)(nil), // 93: openshell.v1.RevokeSshSessionResponse - (*ExecSandboxRequest)(nil), // 94: openshell.v1.ExecSandboxRequest - (*ExecSandboxStdout)(nil), // 95: openshell.v1.ExecSandboxStdout - (*ExecSandboxStderr)(nil), // 96: openshell.v1.ExecSandboxStderr - (*ExecSandboxExit)(nil), // 97: openshell.v1.ExecSandboxExit - (*ExecSandboxEvent)(nil), // 98: openshell.v1.ExecSandboxEvent - (*TcpForwardInit)(nil), // 99: openshell.v1.TcpForwardInit - (*TcpForwardFrame)(nil), // 100: openshell.v1.TcpForwardFrame - (*ExecSandboxInput)(nil), // 101: openshell.v1.ExecSandboxInput - (*ExecSandboxWindowResize)(nil), // 102: openshell.v1.ExecSandboxWindowResize - (*SshSession)(nil), // 103: openshell.v1.SshSession - (*WatchSandboxRequest)(nil), // 104: openshell.v1.WatchSandboxRequest - (*SandboxStreamEvent)(nil), // 105: openshell.v1.SandboxStreamEvent - (*SandboxLogLine)(nil), // 106: openshell.v1.SandboxLogLine - (*SandboxStreamWarning)(nil), // 107: openshell.v1.SandboxStreamWarning - (*CreateProviderRequest)(nil), // 108: openshell.v1.CreateProviderRequest - (*GetProviderRequest)(nil), // 109: openshell.v1.GetProviderRequest - (*ListProvidersRequest)(nil), // 110: openshell.v1.ListProvidersRequest - (*UpdateProviderRequest)(nil), // 111: openshell.v1.UpdateProviderRequest - (*DeleteProviderRequest)(nil), // 112: openshell.v1.DeleteProviderRequest - (*ProviderResponse)(nil), // 113: openshell.v1.ProviderResponse - (*ListProvidersResponse)(nil), // 114: openshell.v1.ListProvidersResponse - (*ListProviderProfilesRequest)(nil), // 115: openshell.v1.ListProviderProfilesRequest - (*GetProviderProfileRequest)(nil), // 116: openshell.v1.GetProviderProfileRequest - (*ProviderProfileImportItem)(nil), // 117: openshell.v1.ProviderProfileImportItem - (*ProviderProfileDiagnostic)(nil), // 118: openshell.v1.ProviderProfileDiagnostic - (*ProviderCredentialTokenGrantAudienceOverride)(nil), // 119: openshell.v1.ProviderCredentialTokenGrantAudienceOverride - (*ProviderCredentialTokenGrantSubjectToken)(nil), // 120: openshell.v1.ProviderCredentialTokenGrantSubjectToken - (*ProviderCredentialTokenGrant)(nil), // 121: openshell.v1.ProviderCredentialTokenGrant - (*ProviderProfileCredential)(nil), // 122: openshell.v1.ProviderProfileCredential - (*ProviderCredentialRefreshMaterial)(nil), // 123: openshell.v1.ProviderCredentialRefreshMaterial - (*ProviderCredentialRefreshOutput)(nil), // 124: openshell.v1.ProviderCredentialRefreshOutput - (*ProviderCredentialRefresh)(nil), // 125: openshell.v1.ProviderCredentialRefresh - (*ProviderCredentialRefreshStatus)(nil), // 126: openshell.v1.ProviderCredentialRefreshStatus - (*ProviderProfileDiscovery)(nil), // 127: openshell.v1.ProviderProfileDiscovery - (*GetProviderRefreshStatusRequest)(nil), // 128: openshell.v1.GetProviderRefreshStatusRequest - (*GetProviderRefreshStatusResponse)(nil), // 129: openshell.v1.GetProviderRefreshStatusResponse - (*ConfigureProviderRefreshRequest)(nil), // 130: openshell.v1.ConfigureProviderRefreshRequest - (*ConfigureProviderRefreshResponse)(nil), // 131: openshell.v1.ConfigureProviderRefreshResponse - (*RotateProviderCredentialRequest)(nil), // 132: openshell.v1.RotateProviderCredentialRequest - (*RotateProviderCredentialResponse)(nil), // 133: openshell.v1.RotateProviderCredentialResponse - (*DeleteProviderRefreshRequest)(nil), // 134: openshell.v1.DeleteProviderRefreshRequest - (*DeleteProviderRefreshResponse)(nil), // 135: openshell.v1.DeleteProviderRefreshResponse - (*ProviderProfile)(nil), // 136: openshell.v1.ProviderProfile - (*ProviderProfileResponse)(nil), // 137: openshell.v1.ProviderProfileResponse - (*ListProviderProfilesResponse)(nil), // 138: openshell.v1.ListProviderProfilesResponse - (*ImportProviderProfilesRequest)(nil), // 139: openshell.v1.ImportProviderProfilesRequest - (*ImportProviderProfilesResponse)(nil), // 140: openshell.v1.ImportProviderProfilesResponse - (*UpdateProviderProfilesRequest)(nil), // 141: openshell.v1.UpdateProviderProfilesRequest - (*UpdateProviderProfilesResponse)(nil), // 142: openshell.v1.UpdateProviderProfilesResponse - (*LintProviderProfilesRequest)(nil), // 143: openshell.v1.LintProviderProfilesRequest - (*LintProviderProfilesResponse)(nil), // 144: openshell.v1.LintProviderProfilesResponse - (*DeleteProviderResponse)(nil), // 145: openshell.v1.DeleteProviderResponse - (*DeleteProviderProfileRequest)(nil), // 146: openshell.v1.DeleteProviderProfileRequest - (*DeleteProviderProfileResponse)(nil), // 147: openshell.v1.DeleteProviderProfileResponse - (*GetSandboxProviderEnvironmentRequest)(nil), // 148: openshell.v1.GetSandboxProviderEnvironmentRequest - (*StaticCredentialEndpointBinding)(nil), // 149: openshell.v1.StaticCredentialEndpointBinding - (*StaticCredentialBinding)(nil), // 150: openshell.v1.StaticCredentialBinding - (*GetSandboxProviderEnvironmentResponse)(nil), // 151: openshell.v1.GetSandboxProviderEnvironmentResponse - (*ExchangeProviderSubjectTokenRequest)(nil), // 152: openshell.v1.ExchangeProviderSubjectTokenRequest - (*ExchangeProviderSubjectTokenResponse)(nil), // 153: openshell.v1.ExchangeProviderSubjectTokenResponse - (*UpdateConfigRequest)(nil), // 154: openshell.v1.UpdateConfigRequest - (*PolicyMergeOperation)(nil), // 155: openshell.v1.PolicyMergeOperation - (*AddNetworkRule)(nil), // 156: openshell.v1.AddNetworkRule - (*RemoveNetworkEndpoint)(nil), // 157: openshell.v1.RemoveNetworkEndpoint - (*RemoveNetworkRule)(nil), // 158: openshell.v1.RemoveNetworkRule - (*AddDenyRules)(nil), // 159: openshell.v1.AddDenyRules - (*AddAllowRules)(nil), // 160: openshell.v1.AddAllowRules - (*RemoveNetworkBinary)(nil), // 161: openshell.v1.RemoveNetworkBinary - (*UpdateConfigResponse)(nil), // 162: openshell.v1.UpdateConfigResponse - (*GetSandboxPolicyStatusRequest)(nil), // 163: openshell.v1.GetSandboxPolicyStatusRequest - (*GetSandboxPolicyStatusResponse)(nil), // 164: openshell.v1.GetSandboxPolicyStatusResponse - (*ListSandboxPoliciesRequest)(nil), // 165: openshell.v1.ListSandboxPoliciesRequest - (*ListSandboxPoliciesResponse)(nil), // 166: openshell.v1.ListSandboxPoliciesResponse - (*ReportPolicyStatusRequest)(nil), // 167: openshell.v1.ReportPolicyStatusRequest - (*ReportPolicyStatusResponse)(nil), // 168: openshell.v1.ReportPolicyStatusResponse - (*SandboxPolicyRevision)(nil), // 169: openshell.v1.SandboxPolicyRevision - (*GetSandboxLogsRequest)(nil), // 170: openshell.v1.GetSandboxLogsRequest - (*PushSandboxLogsRequest)(nil), // 171: openshell.v1.PushSandboxLogsRequest - (*PushSandboxLogsResponse)(nil), // 172: openshell.v1.PushSandboxLogsResponse - (*GetSandboxLogsResponse)(nil), // 173: openshell.v1.GetSandboxLogsResponse - (*SupervisorMessage)(nil), // 174: openshell.v1.SupervisorMessage - (*GatewayMessage)(nil), // 175: openshell.v1.GatewayMessage - (*SupervisorHello)(nil), // 176: openshell.v1.SupervisorHello - (*SessionAccepted)(nil), // 177: openshell.v1.SessionAccepted - (*SessionRejected)(nil), // 178: openshell.v1.SessionRejected - (*SupervisorHeartbeat)(nil), // 179: openshell.v1.SupervisorHeartbeat - (*GatewayHeartbeat)(nil), // 180: openshell.v1.GatewayHeartbeat - (*ReportMainProcessExitRequest)(nil), // 181: openshell.v1.ReportMainProcessExitRequest - (*ReportMainProcessExitResponse)(nil), // 182: openshell.v1.ReportMainProcessExitResponse - (*FinalizeMainProcessExitRequest)(nil), // 183: openshell.v1.FinalizeMainProcessExitRequest - (*FinalizeMainProcessExitResponse)(nil), // 184: openshell.v1.FinalizeMainProcessExitResponse - (*RelayOpen)(nil), // 185: openshell.v1.RelayOpen - (*SshRelayTarget)(nil), // 186: openshell.v1.SshRelayTarget - (*TcpRelayTarget)(nil), // 187: openshell.v1.TcpRelayTarget - (*RelayInit)(nil), // 188: openshell.v1.RelayInit - (*RelayFrame)(nil), // 189: openshell.v1.RelayFrame - (*RelayOpenResult)(nil), // 190: openshell.v1.RelayOpenResult - (*RelayClose)(nil), // 191: openshell.v1.RelayClose - (*L7RequestSample)(nil), // 192: openshell.v1.L7RequestSample - (*DenialSummary)(nil), // 193: openshell.v1.DenialSummary - (*DenialGroupCount)(nil), // 194: openshell.v1.DenialGroupCount - (*NetworkActivitySummary)(nil), // 195: openshell.v1.NetworkActivitySummary - (*PolicyChunk)(nil), // 196: openshell.v1.PolicyChunk - (*DraftPolicyUpdate)(nil), // 197: openshell.v1.DraftPolicyUpdate - (*SubmitPolicyAnalysisRequest)(nil), // 198: openshell.v1.SubmitPolicyAnalysisRequest - (*SubmitPolicyAnalysisResponse)(nil), // 199: openshell.v1.SubmitPolicyAnalysisResponse - (*GetDraftPolicyRequest)(nil), // 200: openshell.v1.GetDraftPolicyRequest - (*GetDraftPolicyResponse)(nil), // 201: openshell.v1.GetDraftPolicyResponse - (*ApproveDraftChunkRequest)(nil), // 202: openshell.v1.ApproveDraftChunkRequest - (*ApproveDraftChunkResponse)(nil), // 203: openshell.v1.ApproveDraftChunkResponse - (*RejectDraftChunkRequest)(nil), // 204: openshell.v1.RejectDraftChunkRequest - (*RejectDraftChunkResponse)(nil), // 205: openshell.v1.RejectDraftChunkResponse - (*DraftChunkApproval)(nil), // 206: openshell.v1.DraftChunkApproval - (*ApproveAllDraftChunksRequest)(nil), // 207: openshell.v1.ApproveAllDraftChunksRequest - (*ApproveAllDraftChunksResponse)(nil), // 208: openshell.v1.ApproveAllDraftChunksResponse - (*EditDraftChunkRequest)(nil), // 209: openshell.v1.EditDraftChunkRequest - (*EditDraftChunkResponse)(nil), // 210: openshell.v1.EditDraftChunkResponse - (*UndoDraftChunkRequest)(nil), // 211: openshell.v1.UndoDraftChunkRequest - (*UndoDraftChunkResponse)(nil), // 212: openshell.v1.UndoDraftChunkResponse - (*ClearDraftChunksRequest)(nil), // 213: openshell.v1.ClearDraftChunksRequest - (*ClearDraftChunksResponse)(nil), // 214: openshell.v1.ClearDraftChunksResponse - (*GetDraftHistoryRequest)(nil), // 215: openshell.v1.GetDraftHistoryRequest - (*DraftHistoryEntry)(nil), // 216: openshell.v1.DraftHistoryEntry - (*GetDraftHistoryResponse)(nil), // 217: openshell.v1.GetDraftHistoryResponse - (*CreateWorkspaceRequest)(nil), // 218: openshell.v1.CreateWorkspaceRequest - (*CreateWorkspaceResponse)(nil), // 219: openshell.v1.CreateWorkspaceResponse - (*GetWorkspaceRequest)(nil), // 220: openshell.v1.GetWorkspaceRequest - (*GetWorkspaceResponse)(nil), // 221: openshell.v1.GetWorkspaceResponse - (*ListWorkspacesRequest)(nil), // 222: openshell.v1.ListWorkspacesRequest - (*ListWorkspacesResponse)(nil), // 223: openshell.v1.ListWorkspacesResponse - (*DeleteWorkspaceRequest)(nil), // 224: openshell.v1.DeleteWorkspaceRequest - (*DeleteWorkspaceResponse)(nil), // 225: openshell.v1.DeleteWorkspaceResponse - (*WorkspaceMember)(nil), // 226: openshell.v1.WorkspaceMember - (*AddWorkspaceMemberRequest)(nil), // 227: openshell.v1.AddWorkspaceMemberRequest - (*AddWorkspaceMemberResponse)(nil), // 228: openshell.v1.AddWorkspaceMemberResponse - (*RemoveWorkspaceMemberRequest)(nil), // 229: openshell.v1.RemoveWorkspaceMemberRequest - (*RemoveWorkspaceMemberResponse)(nil), // 230: openshell.v1.RemoveWorkspaceMemberResponse - (*ListWorkspaceMembersRequest)(nil), // 231: openshell.v1.ListWorkspaceMembersRequest - (*ListWorkspaceMembersResponse)(nil), // 232: openshell.v1.ListWorkspaceMembersResponse - (*ExtensionServiceCredential)(nil), // 233: openshell.v1.ExtensionServiceCredential - (*EndpointObservation)(nil), // 234: openshell.v1.EndpointObservation - (*ReportEndpointStatusRequest)(nil), // 235: openshell.v1.ReportEndpointStatusRequest - (*ReportEndpointStatusResponse)(nil), // 236: openshell.v1.ReportEndpointStatusResponse - (*EndpointStatus)(nil), // 237: openshell.v1.EndpointStatus - nil, // 238: openshell.v1.SandboxSpec.EnvironmentEntry - nil, // 239: openshell.v1.SandboxTemplate.LabelsEntry - nil, // 240: openshell.v1.SandboxTemplate.AnnotationsEntry - nil, // 241: openshell.v1.SandboxTemplate.EnvironmentEntry - nil, // 242: openshell.v1.SandboxWorkloadConfig.EnvironmentEntry - nil, // 243: openshell.v1.PlatformEvent.MetadataEntry - nil, // 244: openshell.v1.CreateSandboxRequest.LabelsEntry - nil, // 245: openshell.v1.CreateSandboxRequest.AnnotationsEntry - nil, // 246: openshell.v1.ExecSandboxRequest.EnvironmentEntry - nil, // 247: openshell.v1.SandboxLogLine.FieldsEntry - nil, // 248: openshell.v1.UpdateProviderRequest.CredentialExpirationTimesEntry - nil, // 249: openshell.v1.ConfigureProviderRefreshRequest.MaterialEntry - nil, // 250: openshell.v1.ProviderProfile.AnnotationsEntry - nil, // 251: openshell.v1.GetSandboxProviderEnvironmentResponse.EnvironmentEntry - nil, // 252: openshell.v1.GetSandboxProviderEnvironmentResponse.CredentialExpirationTimesEntry - nil, // 253: openshell.v1.GetSandboxProviderEnvironmentResponse.DynamicCredentialsEntry - nil, // 254: openshell.v1.GetSandboxProviderEnvironmentResponse.StaticCredentialBindingsEntry - nil, // 255: openshell.v1.UpdateConfigRequest.AnnotationsEntry - nil, // 256: openshell.v1.UpdateConfigResponse.AnnotationsEntry - nil, // 257: openshell.v1.SandboxPolicyRevision.ProvenanceEntry - nil, // 258: openshell.v1.CreateWorkspaceRequest.LabelsEntry - (*timestamppb.Timestamp)(nil), // 259: google.protobuf.Timestamp - (*datamodelv1.ObjectMeta)(nil), // 260: openshell.datamodel.v1.ObjectMeta - (*sandboxv1.SandboxPolicy)(nil), // 261: openshell.sandbox.v1.SandboxPolicy - (*structpb.Struct)(nil), // 262: google.protobuf.Struct - (*durationpb.Duration)(nil), // 263: google.protobuf.Duration - (*datamodelv1.WorkspaceSelector)(nil), // 264: openshell.datamodel.v1.WorkspaceSelector - (*datamodelv1.Provider)(nil), // 265: openshell.datamodel.v1.Provider - (sandboxv1.PolicySource)(0), // 266: openshell.sandbox.v1.PolicySource - (*sandboxv1.NetworkEndpoint)(nil), // 267: openshell.sandbox.v1.NetworkEndpoint - (*sandboxv1.NetworkBinary)(nil), // 268: openshell.sandbox.v1.NetworkBinary - (*sandboxv1.SettingValue)(nil), // 269: openshell.sandbox.v1.SettingValue - (*sandboxv1.NetworkPolicyRule)(nil), // 270: openshell.sandbox.v1.NetworkPolicyRule - (*sandboxv1.L7DenyRule)(nil), // 271: openshell.sandbox.v1.L7DenyRule - (*sandboxv1.L7Rule)(nil), // 272: openshell.sandbox.v1.L7Rule - (*datamodelv1.Workspace)(nil), // 273: openshell.datamodel.v1.Workspace - (*sandboxv1.GetSandboxConfigRequest)(nil), // 274: openshell.sandbox.v1.GetSandboxConfigRequest - (*sandboxv1.GetGatewayConfigRequest)(nil), // 275: openshell.sandbox.v1.GetGatewayConfigRequest - (*sandboxv1.GetSandboxConfigResponse)(nil), // 276: openshell.sandbox.v1.GetSandboxConfigResponse - (*sandboxv1.GetGatewayConfigResponse)(nil), // 277: openshell.sandbox.v1.GetGatewayConfigResponse + (ExtensionKind)(0), // 0: openshell.v1.ExtensionKind + (SandboxPhase)(0), // 1: openshell.v1.SandboxPhase + (ProviderMutationKind)(0), // 2: openshell.v1.ProviderMutationKind + (ProviderReadinessState)(0), // 3: openshell.v1.ProviderReadinessState + (ProviderReadinessReason)(0), // 4: openshell.v1.ProviderReadinessReason + (ConfigComponent)(0), // 5: openshell.v1.ConfigComponent + (ConfigApplyOutcome)(0), // 6: openshell.v1.ConfigApplyOutcome + (ConfigUpdateOperationState)(0), // 7: openshell.v1.ConfigUpdateOperationState + (ProviderCredentialTokenGrantType)(0), // 8: openshell.v1.ProviderCredentialTokenGrantType + (ProviderCredentialRefreshStrategy)(0), // 9: openshell.v1.ProviderCredentialRefreshStrategy + (ProviderProfileCategory)(0), // 10: openshell.v1.ProviderProfileCategory + (PolicyStatus)(0), // 11: openshell.v1.PolicyStatus + (ServiceStatus)(0), // 12: openshell.v1.ServiceStatus + (WorkspaceRole)(0), // 13: openshell.v1.WorkspaceRole + (ProviderCredentialRefreshRecoveryAction)(0), // 14: openshell.v1.ProviderCredentialRefreshRecoveryAction + (DeletionOutcome)(0), // 15: openshell.v1.DeletionOutcome + (EndpointResult)(0), // 16: openshell.v1.EndpointResult + (*IssueSandboxTokenRequest)(nil), // 17: openshell.v1.IssueSandboxTokenRequest + (*IssueSandboxTokenResponse)(nil), // 18: openshell.v1.IssueSandboxTokenResponse + (*RefreshSandboxTokenRequest)(nil), // 19: openshell.v1.RefreshSandboxTokenRequest + (*RefreshSandboxTokenResponse)(nil), // 20: openshell.v1.RefreshSandboxTokenResponse + (*HealthRequest)(nil), // 21: openshell.v1.HealthRequest + (*HealthResponse)(nil), // 22: openshell.v1.HealthResponse + (*GetCurrentUserRequest)(nil), // 23: openshell.v1.GetCurrentUserRequest + (*GetCurrentUserResponse)(nil), // 24: openshell.v1.GetCurrentUserResponse + (*GetGatewayInfoRequest)(nil), // 25: openshell.v1.GetGatewayInfoRequest + (*GetGatewayInfoResponse)(nil), // 26: openshell.v1.GetGatewayInfoResponse + (*NegotiatedExtensionInfo)(nil), // 27: openshell.v1.NegotiatedExtensionInfo + (*ComputeDriverInfo)(nil), // 28: openshell.v1.ComputeDriverInfo + (*ComputeDriverCapabilities)(nil), // 29: openshell.v1.ComputeDriverCapabilities + (*ResourceCapabilities)(nil), // 30: openshell.v1.ResourceCapabilities + (*CpuResourceCapabilities)(nil), // 31: openshell.v1.CpuResourceCapabilities + (*MemoryResourceCapabilities)(nil), // 32: openshell.v1.MemoryResourceCapabilities + (*GpuResourceCapabilities)(nil), // 33: openshell.v1.GpuResourceCapabilities + (*Sandbox)(nil), // 34: openshell.v1.Sandbox + (*SandboxSpec)(nil), // 35: openshell.v1.SandboxSpec + (*ResourceRequirements)(nil), // 36: openshell.v1.ResourceRequirements + (*GpuResourceRequirements)(nil), // 37: openshell.v1.GpuResourceRequirements + (*SandboxTemplate)(nil), // 38: openshell.v1.SandboxTemplate + (*SandboxWorkloadTemplate)(nil), // 39: openshell.v1.SandboxWorkloadTemplate + (*SandboxWorkloadTemplateSpec)(nil), // 40: openshell.v1.SandboxWorkloadTemplateSpec + (*SandboxWorkloadConfig)(nil), // 41: openshell.v1.SandboxWorkloadConfig + (*SandboxResources)(nil), // 42: openshell.v1.SandboxResources + (*SandboxServiceLevel)(nil), // 43: openshell.v1.SandboxServiceLevel + (*SandboxStartup)(nil), // 44: openshell.v1.SandboxStartup + (*SandboxWorkloadTemplateProvenance)(nil), // 45: openshell.v1.SandboxWorkloadTemplateProvenance + (*SandboxStatus)(nil), // 46: openshell.v1.SandboxStatus + (*SandboxCondition)(nil), // 47: openshell.v1.SandboxCondition + (*PlatformEvent)(nil), // 48: openshell.v1.PlatformEvent + (*CreateSandboxRequest)(nil), // 49: openshell.v1.CreateSandboxRequest + (*CreateSandboxTemplateRequest)(nil), // 50: openshell.v1.CreateSandboxTemplateRequest + (*GetSandboxTemplateRequest)(nil), // 51: openshell.v1.GetSandboxTemplateRequest + (*ListSandboxTemplatesRequest)(nil), // 52: openshell.v1.ListSandboxTemplatesRequest + (*DeleteSandboxTemplateRequest)(nil), // 53: openshell.v1.DeleteSandboxTemplateRequest + (*SandboxTemplateResponse)(nil), // 54: openshell.v1.SandboxTemplateResponse + (*ListSandboxTemplatesResponse)(nil), // 55: openshell.v1.ListSandboxTemplatesResponse + (*DeleteSandboxTemplateResponse)(nil), // 56: openshell.v1.DeleteSandboxTemplateResponse + (*BeginRootfsTarStagingRequest)(nil), // 57: openshell.v1.BeginRootfsTarStagingRequest + (*BeginRootfsTarStagingResponse)(nil), // 58: openshell.v1.BeginRootfsTarStagingResponse + (*GetSandboxRequest)(nil), // 59: openshell.v1.GetSandboxRequest + (*ListSandboxesRequest)(nil), // 60: openshell.v1.ListSandboxesRequest + (*ListSandboxProvidersRequest)(nil), // 61: openshell.v1.ListSandboxProvidersRequest + (*AttachSandboxProviderRequest)(nil), // 62: openshell.v1.AttachSandboxProviderRequest + (*DetachSandboxProviderRequest)(nil), // 63: openshell.v1.DetachSandboxProviderRequest + (*DeleteSandboxRequest)(nil), // 64: openshell.v1.DeleteSandboxRequest + (*StopSandboxRequest)(nil), // 65: openshell.v1.StopSandboxRequest + (*StartSandboxRequest)(nil), // 66: openshell.v1.StartSandboxRequest + (*SandboxResponse)(nil), // 67: openshell.v1.SandboxResponse + (*ListSandboxesResponse)(nil), // 68: openshell.v1.ListSandboxesResponse + (*ListSandboxProvidersResponse)(nil), // 69: openshell.v1.ListSandboxProvidersResponse + (*AttachSandboxProviderResponse)(nil), // 70: openshell.v1.AttachSandboxProviderResponse + (*DetachSandboxProviderResponse)(nil), // 71: openshell.v1.DetachSandboxProviderResponse + (*ProviderDesiredIdentity)(nil), // 72: openshell.v1.ProviderDesiredIdentity + (*ConfigSnapshotRevision)(nil), // 73: openshell.v1.ConfigSnapshotRevision + (*SandboxConfigRevision)(nil), // 74: openshell.v1.SandboxConfigRevision + (*ConfigUpdateOperation)(nil), // 75: openshell.v1.ConfigUpdateOperation + (*ProviderMutationReceipt)(nil), // 76: openshell.v1.ProviderMutationReceipt + (*ProviderReadinessObservation)(nil), // 77: openshell.v1.ProviderReadinessObservation + (*ProviderReadinessStatus)(nil), // 78: openshell.v1.ProviderReadinessStatus + (*GetSandboxProviderStatusRequest)(nil), // 79: openshell.v1.GetSandboxProviderStatusRequest + (*GetSandboxProviderStatusResponse)(nil), // 80: openshell.v1.GetSandboxProviderStatusResponse + (*ReportProviderReadinessRequest)(nil), // 81: openshell.v1.ReportProviderReadinessRequest + (*ReportProviderReadinessResponse)(nil), // 82: openshell.v1.ReportProviderReadinessResponse + (*DeleteSandboxResponse)(nil), // 83: openshell.v1.DeleteSandboxResponse + (*CreateSshSessionRequest)(nil), // 84: openshell.v1.CreateSshSessionRequest + (*CreateSshSessionResponse)(nil), // 85: openshell.v1.CreateSshSessionResponse + (*ExposeServiceRequest)(nil), // 86: openshell.v1.ExposeServiceRequest + (*GetServiceRequest)(nil), // 87: openshell.v1.GetServiceRequest + (*ListServicesRequest)(nil), // 88: openshell.v1.ListServicesRequest + (*ListServicesResponse)(nil), // 89: openshell.v1.ListServicesResponse + (*DeleteServiceRequest)(nil), // 90: openshell.v1.DeleteServiceRequest + (*DeleteServiceResponse)(nil), // 91: openshell.v1.DeleteServiceResponse + (*ServiceEndpoint)(nil), // 92: openshell.v1.ServiceEndpoint + (*ServiceEndpointResponse)(nil), // 93: openshell.v1.ServiceEndpointResponse + (*RevokeSshSessionRequest)(nil), // 94: openshell.v1.RevokeSshSessionRequest + (*RevokeSshSessionResponse)(nil), // 95: openshell.v1.RevokeSshSessionResponse + (*ExecSandboxRequest)(nil), // 96: openshell.v1.ExecSandboxRequest + (*ExecSandboxStdout)(nil), // 97: openshell.v1.ExecSandboxStdout + (*ExecSandboxStderr)(nil), // 98: openshell.v1.ExecSandboxStderr + (*ExecSandboxExit)(nil), // 99: openshell.v1.ExecSandboxExit + (*ExecSandboxEvent)(nil), // 100: openshell.v1.ExecSandboxEvent + (*TcpForwardInit)(nil), // 101: openshell.v1.TcpForwardInit + (*TcpForwardFrame)(nil), // 102: openshell.v1.TcpForwardFrame + (*ExecSandboxInput)(nil), // 103: openshell.v1.ExecSandboxInput + (*ExecSandboxWindowResize)(nil), // 104: openshell.v1.ExecSandboxWindowResize + (*SshSession)(nil), // 105: openshell.v1.SshSession + (*WatchSandboxRequest)(nil), // 106: openshell.v1.WatchSandboxRequest + (*SandboxStreamEvent)(nil), // 107: openshell.v1.SandboxStreamEvent + (*SandboxLogLine)(nil), // 108: openshell.v1.SandboxLogLine + (*SandboxStreamWarning)(nil), // 109: openshell.v1.SandboxStreamWarning + (*CreateProviderRequest)(nil), // 110: openshell.v1.CreateProviderRequest + (*GetProviderRequest)(nil), // 111: openshell.v1.GetProviderRequest + (*ListProvidersRequest)(nil), // 112: openshell.v1.ListProvidersRequest + (*UpdateProviderRequest)(nil), // 113: openshell.v1.UpdateProviderRequest + (*DeleteProviderRequest)(nil), // 114: openshell.v1.DeleteProviderRequest + (*ProviderResponse)(nil), // 115: openshell.v1.ProviderResponse + (*ListProvidersResponse)(nil), // 116: openshell.v1.ListProvidersResponse + (*ListProviderProfilesRequest)(nil), // 117: openshell.v1.ListProviderProfilesRequest + (*GetProviderProfileRequest)(nil), // 118: openshell.v1.GetProviderProfileRequest + (*ProviderProfileImportItem)(nil), // 119: openshell.v1.ProviderProfileImportItem + (*ProviderProfileDiagnostic)(nil), // 120: openshell.v1.ProviderProfileDiagnostic + (*ProviderCredentialTokenGrantAudienceOverride)(nil), // 121: openshell.v1.ProviderCredentialTokenGrantAudienceOverride + (*ProviderCredentialTokenGrantSubjectToken)(nil), // 122: openshell.v1.ProviderCredentialTokenGrantSubjectToken + (*ProviderCredentialTokenGrant)(nil), // 123: openshell.v1.ProviderCredentialTokenGrant + (*ProviderProfileCredential)(nil), // 124: openshell.v1.ProviderProfileCredential + (*ProviderCredentialRefreshMaterial)(nil), // 125: openshell.v1.ProviderCredentialRefreshMaterial + (*ProviderCredentialRefreshOutput)(nil), // 126: openshell.v1.ProviderCredentialRefreshOutput + (*ProviderCredentialRefresh)(nil), // 127: openshell.v1.ProviderCredentialRefresh + (*ProviderCredentialRefreshStatus)(nil), // 128: openshell.v1.ProviderCredentialRefreshStatus + (*ProviderProfileDiscovery)(nil), // 129: openshell.v1.ProviderProfileDiscovery + (*GetProviderRefreshStatusRequest)(nil), // 130: openshell.v1.GetProviderRefreshStatusRequest + (*GetProviderRefreshStatusResponse)(nil), // 131: openshell.v1.GetProviderRefreshStatusResponse + (*ConfigureProviderRefreshRequest)(nil), // 132: openshell.v1.ConfigureProviderRefreshRequest + (*ConfigureProviderRefreshResponse)(nil), // 133: openshell.v1.ConfigureProviderRefreshResponse + (*RotateProviderCredentialRequest)(nil), // 134: openshell.v1.RotateProviderCredentialRequest + (*RotateProviderCredentialResponse)(nil), // 135: openshell.v1.RotateProviderCredentialResponse + (*DeleteProviderRefreshRequest)(nil), // 136: openshell.v1.DeleteProviderRefreshRequest + (*DeleteProviderRefreshResponse)(nil), // 137: openshell.v1.DeleteProviderRefreshResponse + (*ProviderProfile)(nil), // 138: openshell.v1.ProviderProfile + (*ProviderProfileResponse)(nil), // 139: openshell.v1.ProviderProfileResponse + (*ListProviderProfilesResponse)(nil), // 140: openshell.v1.ListProviderProfilesResponse + (*ImportProviderProfilesRequest)(nil), // 141: openshell.v1.ImportProviderProfilesRequest + (*ImportProviderProfilesResponse)(nil), // 142: openshell.v1.ImportProviderProfilesResponse + (*UpdateProviderProfilesRequest)(nil), // 143: openshell.v1.UpdateProviderProfilesRequest + (*UpdateProviderProfilesResponse)(nil), // 144: openshell.v1.UpdateProviderProfilesResponse + (*LintProviderProfilesRequest)(nil), // 145: openshell.v1.LintProviderProfilesRequest + (*LintProviderProfilesResponse)(nil), // 146: openshell.v1.LintProviderProfilesResponse + (*DeleteProviderResponse)(nil), // 147: openshell.v1.DeleteProviderResponse + (*DeleteProviderProfileRequest)(nil), // 148: openshell.v1.DeleteProviderProfileRequest + (*DeleteProviderProfileResponse)(nil), // 149: openshell.v1.DeleteProviderProfileResponse + (*GetSandboxProviderEnvironmentRequest)(nil), // 150: openshell.v1.GetSandboxProviderEnvironmentRequest + (*StaticCredentialEndpointBinding)(nil), // 151: openshell.v1.StaticCredentialEndpointBinding + (*StaticCredentialBinding)(nil), // 152: openshell.v1.StaticCredentialBinding + (*GetSandboxProviderEnvironmentResponse)(nil), // 153: openshell.v1.GetSandboxProviderEnvironmentResponse + (*ExchangeProviderSubjectTokenRequest)(nil), // 154: openshell.v1.ExchangeProviderSubjectTokenRequest + (*ExchangeProviderSubjectTokenResponse)(nil), // 155: openshell.v1.ExchangeProviderSubjectTokenResponse + (*UpdateConfigRequest)(nil), // 156: openshell.v1.UpdateConfigRequest + (*PolicyMergeOperation)(nil), // 157: openshell.v1.PolicyMergeOperation + (*AddNetworkRule)(nil), // 158: openshell.v1.AddNetworkRule + (*RemoveNetworkEndpoint)(nil), // 159: openshell.v1.RemoveNetworkEndpoint + (*RemoveNetworkRule)(nil), // 160: openshell.v1.RemoveNetworkRule + (*AddDenyRules)(nil), // 161: openshell.v1.AddDenyRules + (*AddAllowRules)(nil), // 162: openshell.v1.AddAllowRules + (*RemoveNetworkBinary)(nil), // 163: openshell.v1.RemoveNetworkBinary + (*UpdateConfigResponse)(nil), // 164: openshell.v1.UpdateConfigResponse + (*GetSandboxPolicyStatusRequest)(nil), // 165: openshell.v1.GetSandboxPolicyStatusRequest + (*GetSandboxPolicyStatusResponse)(nil), // 166: openshell.v1.GetSandboxPolicyStatusResponse + (*ListSandboxPoliciesRequest)(nil), // 167: openshell.v1.ListSandboxPoliciesRequest + (*ListSandboxPoliciesResponse)(nil), // 168: openshell.v1.ListSandboxPoliciesResponse + (*ReportPolicyStatusRequest)(nil), // 169: openshell.v1.ReportPolicyStatusRequest + (*ReportPolicyStatusResponse)(nil), // 170: openshell.v1.ReportPolicyStatusResponse + (*SandboxPolicyRevision)(nil), // 171: openshell.v1.SandboxPolicyRevision + (*GetSandboxLogsRequest)(nil), // 172: openshell.v1.GetSandboxLogsRequest + (*PushSandboxLogsRequest)(nil), // 173: openshell.v1.PushSandboxLogsRequest + (*PushSandboxLogsResponse)(nil), // 174: openshell.v1.PushSandboxLogsResponse + (*GetSandboxLogsResponse)(nil), // 175: openshell.v1.GetSandboxLogsResponse + (*SupervisorMessage)(nil), // 176: openshell.v1.SupervisorMessage + (*GatewayMessage)(nil), // 177: openshell.v1.GatewayMessage + (*SupervisorHello)(nil), // 178: openshell.v1.SupervisorHello + (*SessionAccepted)(nil), // 179: openshell.v1.SessionAccepted + (*SessionRejected)(nil), // 180: openshell.v1.SessionRejected + (*SupervisorHeartbeat)(nil), // 181: openshell.v1.SupervisorHeartbeat + (*GatewayHeartbeat)(nil), // 182: openshell.v1.GatewayHeartbeat + (*ReportMainProcessExitRequest)(nil), // 183: openshell.v1.ReportMainProcessExitRequest + (*ReportMainProcessExitResponse)(nil), // 184: openshell.v1.ReportMainProcessExitResponse + (*FinalizeMainProcessExitRequest)(nil), // 185: openshell.v1.FinalizeMainProcessExitRequest + (*FinalizeMainProcessExitResponse)(nil), // 186: openshell.v1.FinalizeMainProcessExitResponse + (*RelayOpen)(nil), // 187: openshell.v1.RelayOpen + (*SshRelayTarget)(nil), // 188: openshell.v1.SshRelayTarget + (*TcpRelayTarget)(nil), // 189: openshell.v1.TcpRelayTarget + (*RelayInit)(nil), // 190: openshell.v1.RelayInit + (*RelayFrame)(nil), // 191: openshell.v1.RelayFrame + (*RelayOpenResult)(nil), // 192: openshell.v1.RelayOpenResult + (*RelayClose)(nil), // 193: openshell.v1.RelayClose + (*L7RequestSample)(nil), // 194: openshell.v1.L7RequestSample + (*DenialSummary)(nil), // 195: openshell.v1.DenialSummary + (*DenialGroupCount)(nil), // 196: openshell.v1.DenialGroupCount + (*NetworkActivitySummary)(nil), // 197: openshell.v1.NetworkActivitySummary + (*PolicyChunk)(nil), // 198: openshell.v1.PolicyChunk + (*DraftPolicyUpdate)(nil), // 199: openshell.v1.DraftPolicyUpdate + (*SubmitPolicyAnalysisRequest)(nil), // 200: openshell.v1.SubmitPolicyAnalysisRequest + (*SubmitPolicyAnalysisResponse)(nil), // 201: openshell.v1.SubmitPolicyAnalysisResponse + (*GetDraftPolicyRequest)(nil), // 202: openshell.v1.GetDraftPolicyRequest + (*GetDraftPolicyResponse)(nil), // 203: openshell.v1.GetDraftPolicyResponse + (*ApproveDraftChunkRequest)(nil), // 204: openshell.v1.ApproveDraftChunkRequest + (*ApproveDraftChunkResponse)(nil), // 205: openshell.v1.ApproveDraftChunkResponse + (*RejectDraftChunkRequest)(nil), // 206: openshell.v1.RejectDraftChunkRequest + (*RejectDraftChunkResponse)(nil), // 207: openshell.v1.RejectDraftChunkResponse + (*DraftChunkApproval)(nil), // 208: openshell.v1.DraftChunkApproval + (*ApproveAllDraftChunksRequest)(nil), // 209: openshell.v1.ApproveAllDraftChunksRequest + (*ApproveAllDraftChunksResponse)(nil), // 210: openshell.v1.ApproveAllDraftChunksResponse + (*EditDraftChunkRequest)(nil), // 211: openshell.v1.EditDraftChunkRequest + (*EditDraftChunkResponse)(nil), // 212: openshell.v1.EditDraftChunkResponse + (*UndoDraftChunkRequest)(nil), // 213: openshell.v1.UndoDraftChunkRequest + (*UndoDraftChunkResponse)(nil), // 214: openshell.v1.UndoDraftChunkResponse + (*ClearDraftChunksRequest)(nil), // 215: openshell.v1.ClearDraftChunksRequest + (*ClearDraftChunksResponse)(nil), // 216: openshell.v1.ClearDraftChunksResponse + (*GetDraftHistoryRequest)(nil), // 217: openshell.v1.GetDraftHistoryRequest + (*DraftHistoryEntry)(nil), // 218: openshell.v1.DraftHistoryEntry + (*GetDraftHistoryResponse)(nil), // 219: openshell.v1.GetDraftHistoryResponse + (*CreateWorkspaceRequest)(nil), // 220: openshell.v1.CreateWorkspaceRequest + (*CreateWorkspaceResponse)(nil), // 221: openshell.v1.CreateWorkspaceResponse + (*GetWorkspaceRequest)(nil), // 222: openshell.v1.GetWorkspaceRequest + (*GetWorkspaceResponse)(nil), // 223: openshell.v1.GetWorkspaceResponse + (*ListWorkspacesRequest)(nil), // 224: openshell.v1.ListWorkspacesRequest + (*ListWorkspacesResponse)(nil), // 225: openshell.v1.ListWorkspacesResponse + (*DeleteWorkspaceRequest)(nil), // 226: openshell.v1.DeleteWorkspaceRequest + (*DeleteWorkspaceResponse)(nil), // 227: openshell.v1.DeleteWorkspaceResponse + (*WorkspaceMember)(nil), // 228: openshell.v1.WorkspaceMember + (*AddWorkspaceMemberRequest)(nil), // 229: openshell.v1.AddWorkspaceMemberRequest + (*AddWorkspaceMemberResponse)(nil), // 230: openshell.v1.AddWorkspaceMemberResponse + (*RemoveWorkspaceMemberRequest)(nil), // 231: openshell.v1.RemoveWorkspaceMemberRequest + (*RemoveWorkspaceMemberResponse)(nil), // 232: openshell.v1.RemoveWorkspaceMemberResponse + (*ListWorkspaceMembersRequest)(nil), // 233: openshell.v1.ListWorkspaceMembersRequest + (*ListWorkspaceMembersResponse)(nil), // 234: openshell.v1.ListWorkspaceMembersResponse + (*ExtensionServiceCredential)(nil), // 235: openshell.v1.ExtensionServiceCredential + (*EndpointObservation)(nil), // 236: openshell.v1.EndpointObservation + (*ReportEndpointStatusRequest)(nil), // 237: openshell.v1.ReportEndpointStatusRequest + (*ReportEndpointStatusResponse)(nil), // 238: openshell.v1.ReportEndpointStatusResponse + (*EndpointStatus)(nil), // 239: openshell.v1.EndpointStatus + nil, // 240: openshell.v1.SandboxSpec.EnvironmentEntry + nil, // 241: openshell.v1.SandboxTemplate.LabelsEntry + nil, // 242: openshell.v1.SandboxTemplate.AnnotationsEntry + nil, // 243: openshell.v1.SandboxTemplate.EnvironmentEntry + nil, // 244: openshell.v1.SandboxWorkloadConfig.EnvironmentEntry + nil, // 245: openshell.v1.PlatformEvent.MetadataEntry + nil, // 246: openshell.v1.CreateSandboxRequest.LabelsEntry + nil, // 247: openshell.v1.CreateSandboxRequest.AnnotationsEntry + nil, // 248: openshell.v1.ExecSandboxRequest.EnvironmentEntry + nil, // 249: openshell.v1.SandboxLogLine.FieldsEntry + nil, // 250: openshell.v1.UpdateProviderRequest.CredentialExpirationTimesEntry + nil, // 251: openshell.v1.ConfigureProviderRefreshRequest.MaterialEntry + nil, // 252: openshell.v1.ProviderProfile.AnnotationsEntry + nil, // 253: openshell.v1.GetSandboxProviderEnvironmentResponse.EnvironmentEntry + nil, // 254: openshell.v1.GetSandboxProviderEnvironmentResponse.CredentialExpirationTimesEntry + nil, // 255: openshell.v1.GetSandboxProviderEnvironmentResponse.DynamicCredentialsEntry + nil, // 256: openshell.v1.GetSandboxProviderEnvironmentResponse.StaticCredentialBindingsEntry + nil, // 257: openshell.v1.UpdateConfigRequest.AnnotationsEntry + nil, // 258: openshell.v1.UpdateConfigResponse.AnnotationsEntry + nil, // 259: openshell.v1.SandboxPolicyRevision.ProvenanceEntry + nil, // 260: openshell.v1.CreateWorkspaceRequest.LabelsEntry + (*timestamppb.Timestamp)(nil), // 261: google.protobuf.Timestamp + (*datamodelv1.ObjectMeta)(nil), // 262: openshell.datamodel.v1.ObjectMeta + (*sandboxv1.SandboxPolicy)(nil), // 263: openshell.sandbox.v1.SandboxPolicy + (*structpb.Struct)(nil), // 264: google.protobuf.Struct + (*durationpb.Duration)(nil), // 265: google.protobuf.Duration + (*datamodelv1.WorkspaceSelector)(nil), // 266: openshell.datamodel.v1.WorkspaceSelector + (*datamodelv1.Provider)(nil), // 267: openshell.datamodel.v1.Provider + (sandboxv1.PolicySource)(0), // 268: openshell.sandbox.v1.PolicySource + (*sandboxv1.NetworkEndpoint)(nil), // 269: openshell.sandbox.v1.NetworkEndpoint + (*sandboxv1.NetworkBinary)(nil), // 270: openshell.sandbox.v1.NetworkBinary + (*sandboxv1.SettingValue)(nil), // 271: openshell.sandbox.v1.SettingValue + (*sandboxv1.NetworkPolicyRule)(nil), // 272: openshell.sandbox.v1.NetworkPolicyRule + (*sandboxv1.L7DenyRule)(nil), // 273: openshell.sandbox.v1.L7DenyRule + (*sandboxv1.L7Rule)(nil), // 274: openshell.sandbox.v1.L7Rule + (*datamodelv1.Workspace)(nil), // 275: openshell.datamodel.v1.Workspace + (*sandboxv1.GetSandboxConfigRequest)(nil), // 276: openshell.sandbox.v1.GetSandboxConfigRequest + (*sandboxv1.GetGatewayConfigRequest)(nil), // 277: openshell.sandbox.v1.GetGatewayConfigRequest + (*sandboxv1.GetSandboxConfigResponse)(nil), // 278: openshell.sandbox.v1.GetSandboxConfigResponse + (*sandboxv1.GetGatewayConfigResponse)(nil), // 279: openshell.sandbox.v1.GetGatewayConfigResponse } var file_openshell_proto_depIdxs = []int32{ - 259, // 0: openshell.v1.IssueSandboxTokenResponse.expiration_time:type_name -> google.protobuf.Timestamp - 259, // 1: openshell.v1.RefreshSandboxTokenResponse.expiration_time:type_name -> google.protobuf.Timestamp - 233, // 2: openshell.v1.RefreshSandboxTokenResponse.extension_credentials:type_name -> openshell.v1.ExtensionServiceCredential - 259, // 3: openshell.v1.RefreshSandboxTokenResponse.sandbox_expiration_time:type_name -> google.protobuf.Timestamp - 11, // 4: openshell.v1.HealthResponse.status:type_name -> openshell.v1.ServiceStatus - 11, // 5: openshell.v1.GetGatewayInfoResponse.status:type_name -> openshell.v1.ServiceStatus - 26, // 6: openshell.v1.GetGatewayInfoResponse.compute_drivers:type_name -> openshell.v1.ComputeDriverInfo - 27, // 7: openshell.v1.ComputeDriverInfo.capabilities:type_name -> openshell.v1.ComputeDriverCapabilities - 28, // 8: openshell.v1.ComputeDriverCapabilities.resource_capabilities:type_name -> openshell.v1.ResourceCapabilities - 29, // 9: openshell.v1.ResourceCapabilities.cpu:type_name -> openshell.v1.CpuResourceCapabilities - 30, // 10: openshell.v1.ResourceCapabilities.memory:type_name -> openshell.v1.MemoryResourceCapabilities - 31, // 11: openshell.v1.ResourceCapabilities.gpu:type_name -> openshell.v1.GpuResourceCapabilities - 260, // 12: openshell.v1.Sandbox.metadata:type_name -> openshell.datamodel.v1.ObjectMeta - 33, // 13: openshell.v1.Sandbox.spec:type_name -> openshell.v1.SandboxSpec - 44, // 14: openshell.v1.Sandbox.status:type_name -> openshell.v1.SandboxStatus - 43, // 15: openshell.v1.Sandbox.created_from_workload_template:type_name -> openshell.v1.SandboxWorkloadTemplateProvenance - 238, // 16: openshell.v1.SandboxSpec.environment:type_name -> openshell.v1.SandboxSpec.EnvironmentEntry - 36, // 17: openshell.v1.SandboxSpec.template:type_name -> openshell.v1.SandboxTemplate - 261, // 18: openshell.v1.SandboxSpec.policy:type_name -> openshell.sandbox.v1.SandboxPolicy - 34, // 19: openshell.v1.SandboxSpec.resource_requirements:type_name -> openshell.v1.ResourceRequirements - 35, // 20: openshell.v1.ResourceRequirements.gpu:type_name -> openshell.v1.GpuResourceRequirements - 239, // 21: openshell.v1.SandboxTemplate.labels:type_name -> openshell.v1.SandboxTemplate.LabelsEntry - 240, // 22: openshell.v1.SandboxTemplate.annotations:type_name -> openshell.v1.SandboxTemplate.AnnotationsEntry - 241, // 23: openshell.v1.SandboxTemplate.environment:type_name -> openshell.v1.SandboxTemplate.EnvironmentEntry - 262, // 24: openshell.v1.SandboxTemplate.resources:type_name -> google.protobuf.Struct - 262, // 25: openshell.v1.SandboxTemplate.driver_config:type_name -> google.protobuf.Struct - 260, // 26: openshell.v1.SandboxWorkloadTemplate.metadata:type_name -> openshell.datamodel.v1.ObjectMeta - 38, // 27: openshell.v1.SandboxWorkloadTemplate.spec:type_name -> openshell.v1.SandboxWorkloadTemplateSpec - 39, // 28: openshell.v1.SandboxWorkloadTemplateSpec.workload:type_name -> openshell.v1.SandboxWorkloadConfig - 262, // 29: openshell.v1.SandboxWorkloadTemplateSpec.driver_config:type_name -> google.protobuf.Struct - 41, // 30: openshell.v1.SandboxWorkloadTemplateSpec.desired_service_level:type_name -> openshell.v1.SandboxServiceLevel - 242, // 31: openshell.v1.SandboxWorkloadConfig.environment:type_name -> openshell.v1.SandboxWorkloadConfig.EnvironmentEntry - 40, // 32: openshell.v1.SandboxWorkloadConfig.resources:type_name -> openshell.v1.SandboxResources - 35, // 33: openshell.v1.SandboxResources.gpu:type_name -> openshell.v1.GpuResourceRequirements - 42, // 34: openshell.v1.SandboxServiceLevel.startup:type_name -> openshell.v1.SandboxStartup - 263, // 35: openshell.v1.SandboxStartup.ready_within:type_name -> google.protobuf.Duration - 45, // 36: openshell.v1.SandboxStatus.conditions:type_name -> openshell.v1.SandboxCondition - 0, // 37: openshell.v1.SandboxStatus.phase:type_name -> openshell.v1.SandboxPhase - 237, // 38: openshell.v1.SandboxStatus.endpoint_statuses:type_name -> openshell.v1.EndpointStatus - 259, // 39: openshell.v1.SandboxCondition.transition_time:type_name -> google.protobuf.Timestamp - 259, // 40: openshell.v1.PlatformEvent.event_time:type_name -> google.protobuf.Timestamp - 243, // 41: openshell.v1.PlatformEvent.metadata:type_name -> openshell.v1.PlatformEvent.MetadataEntry - 33, // 42: openshell.v1.CreateSandboxRequest.spec:type_name -> openshell.v1.SandboxSpec - 244, // 43: openshell.v1.CreateSandboxRequest.labels:type_name -> openshell.v1.CreateSandboxRequest.LabelsEntry - 245, // 44: openshell.v1.CreateSandboxRequest.annotations:type_name -> openshell.v1.CreateSandboxRequest.AnnotationsEntry - 264, // 45: openshell.v1.CreateSandboxRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 37, // 46: openshell.v1.CreateSandboxTemplateRequest.template:type_name -> openshell.v1.SandboxWorkloadTemplate - 264, // 47: openshell.v1.CreateSandboxTemplateRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 264, // 48: openshell.v1.GetSandboxTemplateRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 264, // 49: openshell.v1.ListSandboxTemplatesRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 264, // 50: openshell.v1.DeleteSandboxTemplateRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 37, // 51: openshell.v1.SandboxTemplateResponse.template:type_name -> openshell.v1.SandboxWorkloadTemplate - 37, // 52: openshell.v1.ListSandboxTemplatesResponse.templates:type_name -> openshell.v1.SandboxWorkloadTemplate - 14, // 53: openshell.v1.DeleteSandboxTemplateResponse.outcome:type_name -> openshell.v1.DeletionOutcome - 264, // 54: openshell.v1.BeginRootfsTarStagingRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 259, // 55: openshell.v1.BeginRootfsTarStagingResponse.expiration_time:type_name -> google.protobuf.Timestamp - 264, // 56: openshell.v1.GetSandboxRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 264, // 57: openshell.v1.ListSandboxesRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 264, // 58: openshell.v1.ListSandboxProvidersRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 264, // 59: openshell.v1.AttachSandboxProviderRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 264, // 60: openshell.v1.DetachSandboxProviderRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 264, // 61: openshell.v1.DeleteSandboxRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 264, // 62: openshell.v1.StopSandboxRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 264, // 63: openshell.v1.StartSandboxRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 32, // 64: openshell.v1.SandboxResponse.sandbox:type_name -> openshell.v1.Sandbox - 32, // 65: openshell.v1.ListSandboxesResponse.sandboxes:type_name -> openshell.v1.Sandbox - 265, // 66: openshell.v1.ListSandboxProvidersResponse.providers:type_name -> openshell.datamodel.v1.Provider - 32, // 67: openshell.v1.AttachSandboxProviderResponse.sandbox:type_name -> openshell.v1.Sandbox - 74, // 68: openshell.v1.AttachSandboxProviderResponse.receipt:type_name -> openshell.v1.ProviderMutationReceipt - 32, // 69: openshell.v1.DetachSandboxProviderResponse.sandbox:type_name -> openshell.v1.Sandbox - 74, // 70: openshell.v1.DetachSandboxProviderResponse.receipt:type_name -> openshell.v1.ProviderMutationReceipt - 72, // 71: openshell.v1.ConfigSnapshotRevision.sandbox_config:type_name -> openshell.v1.SandboxConfigRevision - 70, // 72: openshell.v1.ConfigSnapshotRevision.provider_target:type_name -> openshell.v1.ProviderDesiredIdentity - 266, // 73: openshell.v1.SandboxConfigRevision.policy_source:type_name -> openshell.sandbox.v1.PolicySource - 4, // 74: openshell.v1.ConfigUpdateOperation.component:type_name -> openshell.v1.ConfigComponent - 71, // 75: openshell.v1.ConfigUpdateOperation.target_revision:type_name -> openshell.v1.ConfigSnapshotRevision - 6, // 76: openshell.v1.ConfigUpdateOperation.state:type_name -> openshell.v1.ConfigUpdateOperationState - 5, // 77: openshell.v1.ConfigUpdateOperation.outcome:type_name -> openshell.v1.ConfigApplyOutcome - 259, // 78: openshell.v1.ConfigUpdateOperation.created_time:type_name -> google.protobuf.Timestamp - 259, // 79: openshell.v1.ConfigUpdateOperation.updated_time:type_name -> google.protobuf.Timestamp - 259, // 80: openshell.v1.ConfigUpdateOperation.completed_time:type_name -> google.protobuf.Timestamp - 1, // 81: openshell.v1.ProviderMutationReceipt.kind:type_name -> openshell.v1.ProviderMutationKind - 70, // 82: openshell.v1.ProviderMutationReceipt.desired:type_name -> openshell.v1.ProviderDesiredIdentity - 259, // 83: openshell.v1.ProviderMutationReceipt.persisted_time:type_name -> google.protobuf.Timestamp - 3, // 84: openshell.v1.ProviderReadinessObservation.reason:type_name -> openshell.v1.ProviderReadinessReason - 74, // 85: openshell.v1.ProviderReadinessStatus.receipt:type_name -> openshell.v1.ProviderMutationReceipt - 2, // 86: openshell.v1.ProviderReadinessStatus.state:type_name -> openshell.v1.ProviderReadinessState - 3, // 87: openshell.v1.ProviderReadinessStatus.reason:type_name -> openshell.v1.ProviderReadinessReason - 75, // 88: openshell.v1.ProviderReadinessStatus.observed:type_name -> openshell.v1.ProviderReadinessObservation - 259, // 89: openshell.v1.ProviderReadinessStatus.observed_time:type_name -> google.protobuf.Timestamp - 259, // 90: openshell.v1.ProviderReadinessStatus.evaluated_time:type_name -> google.protobuf.Timestamp - 73, // 91: openshell.v1.ProviderReadinessStatus.operation:type_name -> openshell.v1.ConfigUpdateOperation - 264, // 92: openshell.v1.GetSandboxProviderStatusRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 76, // 93: openshell.v1.GetSandboxProviderStatusResponse.status:type_name -> openshell.v1.ProviderReadinessStatus - 75, // 94: openshell.v1.ReportProviderReadinessRequest.observation:type_name -> openshell.v1.ProviderReadinessObservation - 263, // 95: openshell.v1.ReportProviderReadinessResponse.report_interval:type_name -> google.protobuf.Duration - 263, // 96: openshell.v1.ReportProviderReadinessResponse.observation_ttl:type_name -> google.protobuf.Duration - 14, // 97: openshell.v1.DeleteSandboxResponse.outcome:type_name -> openshell.v1.DeletionOutcome - 259, // 98: openshell.v1.CreateSshSessionResponse.expiration_time:type_name -> google.protobuf.Timestamp - 264, // 99: openshell.v1.ExposeServiceRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 264, // 100: openshell.v1.GetServiceRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 264, // 101: openshell.v1.ListServicesRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 91, // 102: openshell.v1.ListServicesResponse.services:type_name -> openshell.v1.ServiceEndpointResponse - 264, // 103: openshell.v1.DeleteServiceRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 14, // 104: openshell.v1.DeleteServiceResponse.outcome:type_name -> openshell.v1.DeletionOutcome - 260, // 105: openshell.v1.ServiceEndpoint.metadata:type_name -> openshell.datamodel.v1.ObjectMeta - 90, // 106: openshell.v1.ServiceEndpointResponse.endpoint:type_name -> openshell.v1.ServiceEndpoint - 14, // 107: openshell.v1.RevokeSshSessionResponse.outcome:type_name -> openshell.v1.DeletionOutcome - 246, // 108: openshell.v1.ExecSandboxRequest.environment:type_name -> openshell.v1.ExecSandboxRequest.EnvironmentEntry - 263, // 109: openshell.v1.ExecSandboxRequest.execution_timeout:type_name -> google.protobuf.Duration - 95, // 110: openshell.v1.ExecSandboxEvent.stdout:type_name -> openshell.v1.ExecSandboxStdout - 96, // 111: openshell.v1.ExecSandboxEvent.stderr:type_name -> openshell.v1.ExecSandboxStderr - 97, // 112: openshell.v1.ExecSandboxEvent.exit:type_name -> openshell.v1.ExecSandboxExit - 186, // 113: openshell.v1.TcpForwardInit.ssh:type_name -> openshell.v1.SshRelayTarget - 187, // 114: openshell.v1.TcpForwardInit.tcp:type_name -> openshell.v1.TcpRelayTarget - 99, // 115: openshell.v1.TcpForwardFrame.init:type_name -> openshell.v1.TcpForwardInit - 94, // 116: openshell.v1.ExecSandboxInput.start:type_name -> openshell.v1.ExecSandboxRequest - 102, // 117: openshell.v1.ExecSandboxInput.resize:type_name -> openshell.v1.ExecSandboxWindowResize - 260, // 118: openshell.v1.SshSession.metadata:type_name -> openshell.datamodel.v1.ObjectMeta - 259, // 119: openshell.v1.SshSession.expiration_time:type_name -> google.protobuf.Timestamp - 259, // 120: openshell.v1.WatchSandboxRequest.since_time:type_name -> google.protobuf.Timestamp - 32, // 121: openshell.v1.SandboxStreamEvent.sandbox:type_name -> openshell.v1.Sandbox - 106, // 122: openshell.v1.SandboxStreamEvent.log:type_name -> openshell.v1.SandboxLogLine - 46, // 123: openshell.v1.SandboxStreamEvent.event:type_name -> openshell.v1.PlatformEvent - 107, // 124: openshell.v1.SandboxStreamEvent.warning:type_name -> openshell.v1.SandboxStreamWarning - 197, // 125: openshell.v1.SandboxStreamEvent.draft_policy_update:type_name -> openshell.v1.DraftPolicyUpdate - 259, // 126: openshell.v1.SandboxLogLine.event_time:type_name -> google.protobuf.Timestamp - 247, // 127: openshell.v1.SandboxLogLine.fields:type_name -> openshell.v1.SandboxLogLine.FieldsEntry - 265, // 128: openshell.v1.CreateProviderRequest.provider:type_name -> openshell.datamodel.v1.Provider - 264, // 129: openshell.v1.CreateProviderRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 264, // 130: openshell.v1.GetProviderRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 264, // 131: openshell.v1.ListProvidersRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 265, // 132: openshell.v1.UpdateProviderRequest.provider:type_name -> openshell.datamodel.v1.Provider - 248, // 133: openshell.v1.UpdateProviderRequest.credential_expiration_times:type_name -> openshell.v1.UpdateProviderRequest.CredentialExpirationTimesEntry - 264, // 134: openshell.v1.UpdateProviderRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 264, // 135: openshell.v1.DeleteProviderRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 265, // 136: openshell.v1.ProviderResponse.provider:type_name -> openshell.datamodel.v1.Provider - 74, // 137: openshell.v1.ProviderResponse.target_receipts:type_name -> openshell.v1.ProviderMutationReceipt - 265, // 138: openshell.v1.ListProvidersResponse.providers:type_name -> openshell.datamodel.v1.Provider - 136, // 139: openshell.v1.ProviderProfileImportItem.profile:type_name -> openshell.v1.ProviderProfile - 263, // 140: openshell.v1.ProviderCredentialTokenGrant.cache_ttl:type_name -> google.protobuf.Duration - 119, // 141: openshell.v1.ProviderCredentialTokenGrant.audience_overrides:type_name -> openshell.v1.ProviderCredentialTokenGrantAudienceOverride - 7, // 142: openshell.v1.ProviderCredentialTokenGrant.grant_type:type_name -> openshell.v1.ProviderCredentialTokenGrantType - 120, // 143: openshell.v1.ProviderCredentialTokenGrant.subject_token:type_name -> openshell.v1.ProviderCredentialTokenGrantSubjectToken - 125, // 144: openshell.v1.ProviderProfileCredential.refresh:type_name -> openshell.v1.ProviderCredentialRefresh - 121, // 145: openshell.v1.ProviderProfileCredential.token_grant:type_name -> openshell.v1.ProviderCredentialTokenGrant - 8, // 146: openshell.v1.ProviderCredentialRefresh.strategy:type_name -> openshell.v1.ProviderCredentialRefreshStrategy - 263, // 147: openshell.v1.ProviderCredentialRefresh.refresh_before:type_name -> google.protobuf.Duration - 263, // 148: openshell.v1.ProviderCredentialRefresh.max_lifetime:type_name -> google.protobuf.Duration - 123, // 149: openshell.v1.ProviderCredentialRefresh.material:type_name -> openshell.v1.ProviderCredentialRefreshMaterial - 124, // 150: openshell.v1.ProviderCredentialRefresh.additional_outputs:type_name -> openshell.v1.ProviderCredentialRefreshOutput - 8, // 151: openshell.v1.ProviderCredentialRefreshStatus.strategy:type_name -> openshell.v1.ProviderCredentialRefreshStrategy - 259, // 152: openshell.v1.ProviderCredentialRefreshStatus.expiration_time:type_name -> google.protobuf.Timestamp - 259, // 153: openshell.v1.ProviderCredentialRefreshStatus.next_refresh_time:type_name -> google.protobuf.Timestamp - 259, // 154: openshell.v1.ProviderCredentialRefreshStatus.last_refresh_time:type_name -> google.protobuf.Timestamp - 13, // 155: openshell.v1.ProviderCredentialRefreshStatus.recovery_action:type_name -> openshell.v1.ProviderCredentialRefreshRecoveryAction - 259, // 156: openshell.v1.ProviderCredentialRefreshStatus.last_error_time:type_name -> google.protobuf.Timestamp - 264, // 157: openshell.v1.GetProviderRefreshStatusRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 126, // 158: openshell.v1.GetProviderRefreshStatusResponse.credentials:type_name -> openshell.v1.ProviderCredentialRefreshStatus - 8, // 159: openshell.v1.ConfigureProviderRefreshRequest.strategy:type_name -> openshell.v1.ProviderCredentialRefreshStrategy - 249, // 160: openshell.v1.ConfigureProviderRefreshRequest.material:type_name -> openshell.v1.ConfigureProviderRefreshRequest.MaterialEntry - 259, // 161: openshell.v1.ConfigureProviderRefreshRequest.expiration_time:type_name -> google.protobuf.Timestamp - 264, // 162: openshell.v1.ConfigureProviderRefreshRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 126, // 163: openshell.v1.ConfigureProviderRefreshResponse.status:type_name -> openshell.v1.ProviderCredentialRefreshStatus - 264, // 164: openshell.v1.RotateProviderCredentialRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 126, // 165: openshell.v1.RotateProviderCredentialResponse.status:type_name -> openshell.v1.ProviderCredentialRefreshStatus - 264, // 166: openshell.v1.DeleteProviderRefreshRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 14, // 167: openshell.v1.DeleteProviderRefreshResponse.outcome:type_name -> openshell.v1.DeletionOutcome - 9, // 168: openshell.v1.ProviderProfile.category:type_name -> openshell.v1.ProviderProfileCategory - 122, // 169: openshell.v1.ProviderProfile.credentials:type_name -> openshell.v1.ProviderProfileCredential - 267, // 170: openshell.v1.ProviderProfile.endpoints:type_name -> openshell.sandbox.v1.NetworkEndpoint - 268, // 171: openshell.v1.ProviderProfile.binaries:type_name -> openshell.sandbox.v1.NetworkBinary - 127, // 172: openshell.v1.ProviderProfile.discovery:type_name -> openshell.v1.ProviderProfileDiscovery - 250, // 173: openshell.v1.ProviderProfile.annotations:type_name -> openshell.v1.ProviderProfile.AnnotationsEntry - 136, // 174: openshell.v1.ProviderProfileResponse.profile:type_name -> openshell.v1.ProviderProfile - 136, // 175: openshell.v1.ListProviderProfilesResponse.profiles:type_name -> openshell.v1.ProviderProfile - 117, // 176: openshell.v1.ImportProviderProfilesRequest.profiles:type_name -> openshell.v1.ProviderProfileImportItem - 118, // 177: openshell.v1.ImportProviderProfilesResponse.diagnostics:type_name -> openshell.v1.ProviderProfileDiagnostic - 136, // 178: openshell.v1.ImportProviderProfilesResponse.profiles:type_name -> openshell.v1.ProviderProfile - 117, // 179: openshell.v1.UpdateProviderProfilesRequest.profile:type_name -> openshell.v1.ProviderProfileImportItem - 118, // 180: openshell.v1.UpdateProviderProfilesResponse.diagnostics:type_name -> openshell.v1.ProviderProfileDiagnostic - 136, // 181: openshell.v1.UpdateProviderProfilesResponse.profile:type_name -> openshell.v1.ProviderProfile - 117, // 182: openshell.v1.LintProviderProfilesRequest.profiles:type_name -> openshell.v1.ProviderProfileImportItem - 118, // 183: openshell.v1.LintProviderProfilesResponse.diagnostics:type_name -> openshell.v1.ProviderProfileDiagnostic - 14, // 184: openshell.v1.DeleteProviderResponse.outcome:type_name -> openshell.v1.DeletionOutcome - 14, // 185: openshell.v1.DeleteProviderProfileResponse.outcome:type_name -> openshell.v1.DeletionOutcome - 149, // 186: openshell.v1.StaticCredentialBinding.endpoints:type_name -> openshell.v1.StaticCredentialEndpointBinding - 251, // 187: openshell.v1.GetSandboxProviderEnvironmentResponse.environment:type_name -> openshell.v1.GetSandboxProviderEnvironmentResponse.EnvironmentEntry - 252, // 188: openshell.v1.GetSandboxProviderEnvironmentResponse.credential_expiration_times:type_name -> openshell.v1.GetSandboxProviderEnvironmentResponse.CredentialExpirationTimesEntry - 253, // 189: openshell.v1.GetSandboxProviderEnvironmentResponse.dynamic_credentials:type_name -> openshell.v1.GetSandboxProviderEnvironmentResponse.DynamicCredentialsEntry - 254, // 190: openshell.v1.GetSandboxProviderEnvironmentResponse.static_credential_bindings:type_name -> openshell.v1.GetSandboxProviderEnvironmentResponse.StaticCredentialBindingsEntry - 3, // 191: openshell.v1.GetSandboxProviderEnvironmentResponse.readiness_reason:type_name -> openshell.v1.ProviderReadinessReason - 263, // 192: openshell.v1.ExchangeProviderSubjectTokenResponse.expires_after:type_name -> google.protobuf.Duration - 261, // 193: openshell.v1.UpdateConfigRequest.policy:type_name -> openshell.sandbox.v1.SandboxPolicy - 269, // 194: openshell.v1.UpdateConfigRequest.setting_value:type_name -> openshell.sandbox.v1.SettingValue - 155, // 195: openshell.v1.UpdateConfigRequest.merge_operations:type_name -> openshell.v1.PolicyMergeOperation - 255, // 196: openshell.v1.UpdateConfigRequest.annotations:type_name -> openshell.v1.UpdateConfigRequest.AnnotationsEntry - 264, // 197: openshell.v1.UpdateConfigRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 156, // 198: openshell.v1.PolicyMergeOperation.add_rule:type_name -> openshell.v1.AddNetworkRule - 157, // 199: openshell.v1.PolicyMergeOperation.remove_endpoint:type_name -> openshell.v1.RemoveNetworkEndpoint - 158, // 200: openshell.v1.PolicyMergeOperation.remove_rule:type_name -> openshell.v1.RemoveNetworkRule - 159, // 201: openshell.v1.PolicyMergeOperation.add_deny_rules:type_name -> openshell.v1.AddDenyRules - 160, // 202: openshell.v1.PolicyMergeOperation.add_allow_rules:type_name -> openshell.v1.AddAllowRules - 161, // 203: openshell.v1.PolicyMergeOperation.remove_binary:type_name -> openshell.v1.RemoveNetworkBinary - 270, // 204: openshell.v1.AddNetworkRule.rule:type_name -> openshell.sandbox.v1.NetworkPolicyRule - 271, // 205: openshell.v1.AddDenyRules.deny_rules:type_name -> openshell.sandbox.v1.L7DenyRule - 272, // 206: openshell.v1.AddAllowRules.rules:type_name -> openshell.sandbox.v1.L7Rule - 256, // 207: openshell.v1.UpdateConfigResponse.annotations:type_name -> openshell.v1.UpdateConfigResponse.AnnotationsEntry - 264, // 208: openshell.v1.GetSandboxPolicyStatusRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 169, // 209: openshell.v1.GetSandboxPolicyStatusResponse.revision:type_name -> openshell.v1.SandboxPolicyRevision - 264, // 210: openshell.v1.ListSandboxPoliciesRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 169, // 211: openshell.v1.ListSandboxPoliciesResponse.revisions:type_name -> openshell.v1.SandboxPolicyRevision - 10, // 212: openshell.v1.ReportPolicyStatusRequest.status:type_name -> openshell.v1.PolicyStatus - 10, // 213: openshell.v1.SandboxPolicyRevision.status:type_name -> openshell.v1.PolicyStatus - 259, // 214: openshell.v1.SandboxPolicyRevision.created_time:type_name -> google.protobuf.Timestamp - 259, // 215: openshell.v1.SandboxPolicyRevision.loaded_time:type_name -> google.protobuf.Timestamp - 261, // 216: openshell.v1.SandboxPolicyRevision.policy:type_name -> openshell.sandbox.v1.SandboxPolicy - 257, // 217: openshell.v1.SandboxPolicyRevision.provenance:type_name -> openshell.v1.SandboxPolicyRevision.ProvenanceEntry - 259, // 218: openshell.v1.GetSandboxLogsRequest.since_time:type_name -> google.protobuf.Timestamp - 264, // 219: openshell.v1.GetSandboxLogsRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 106, // 220: openshell.v1.PushSandboxLogsRequest.logs:type_name -> openshell.v1.SandboxLogLine - 106, // 221: openshell.v1.GetSandboxLogsResponse.logs:type_name -> openshell.v1.SandboxLogLine - 176, // 222: openshell.v1.SupervisorMessage.hello:type_name -> openshell.v1.SupervisorHello - 179, // 223: openshell.v1.SupervisorMessage.heartbeat:type_name -> openshell.v1.SupervisorHeartbeat - 190, // 224: openshell.v1.SupervisorMessage.relay_open_result:type_name -> openshell.v1.RelayOpenResult - 191, // 225: openshell.v1.SupervisorMessage.relay_close:type_name -> openshell.v1.RelayClose - 177, // 226: openshell.v1.GatewayMessage.session_accepted:type_name -> openshell.v1.SessionAccepted - 178, // 227: openshell.v1.GatewayMessage.session_rejected:type_name -> openshell.v1.SessionRejected - 180, // 228: openshell.v1.GatewayMessage.heartbeat:type_name -> openshell.v1.GatewayHeartbeat - 185, // 229: openshell.v1.GatewayMessage.relay_open:type_name -> openshell.v1.RelayOpen - 191, // 230: openshell.v1.GatewayMessage.relay_close:type_name -> openshell.v1.RelayClose - 263, // 231: openshell.v1.SessionAccepted.heartbeat_interval:type_name -> google.protobuf.Duration - 186, // 232: openshell.v1.RelayOpen.ssh:type_name -> openshell.v1.SshRelayTarget - 187, // 233: openshell.v1.RelayOpen.tcp:type_name -> openshell.v1.TcpRelayTarget - 188, // 234: openshell.v1.RelayFrame.init:type_name -> openshell.v1.RelayInit - 259, // 235: openshell.v1.DenialSummary.first_seen_time:type_name -> google.protobuf.Timestamp - 259, // 236: openshell.v1.DenialSummary.last_seen_time:type_name -> google.protobuf.Timestamp - 192, // 237: openshell.v1.DenialSummary.l7_request_samples:type_name -> openshell.v1.L7RequestSample - 194, // 238: openshell.v1.NetworkActivitySummary.denials_by_group:type_name -> openshell.v1.DenialGroupCount - 270, // 239: openshell.v1.PolicyChunk.proposed_rule:type_name -> openshell.sandbox.v1.NetworkPolicyRule - 259, // 240: openshell.v1.PolicyChunk.created_time:type_name -> google.protobuf.Timestamp - 259, // 241: openshell.v1.PolicyChunk.decided_time:type_name -> google.protobuf.Timestamp - 259, // 242: openshell.v1.PolicyChunk.first_seen_time:type_name -> google.protobuf.Timestamp - 259, // 243: openshell.v1.PolicyChunk.last_seen_time:type_name -> google.protobuf.Timestamp - 261, // 244: openshell.v1.PolicyChunk.current_effective_policy:type_name -> openshell.sandbox.v1.SandboxPolicy - 261, // 245: openshell.v1.PolicyChunk.candidate_effective_policy:type_name -> openshell.sandbox.v1.SandboxPolicy - 193, // 246: openshell.v1.SubmitPolicyAnalysisRequest.summaries:type_name -> openshell.v1.DenialSummary - 196, // 247: openshell.v1.SubmitPolicyAnalysisRequest.proposed_chunks:type_name -> openshell.v1.PolicyChunk - 195, // 248: openshell.v1.SubmitPolicyAnalysisRequest.network_activity_summaries:type_name -> openshell.v1.NetworkActivitySummary - 264, // 249: openshell.v1.GetDraftPolicyRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 196, // 250: openshell.v1.GetDraftPolicyResponse.chunks:type_name -> openshell.v1.PolicyChunk - 259, // 251: openshell.v1.GetDraftPolicyResponse.last_analyzed_time:type_name -> google.protobuf.Timestamp - 264, // 252: openshell.v1.ApproveDraftChunkRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 264, // 253: openshell.v1.RejectDraftChunkRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 206, // 254: openshell.v1.ApproveAllDraftChunksRequest.approvals:type_name -> openshell.v1.DraftChunkApproval - 264, // 255: openshell.v1.ApproveAllDraftChunksRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 270, // 256: openshell.v1.EditDraftChunkRequest.proposed_rule:type_name -> openshell.sandbox.v1.NetworkPolicyRule - 264, // 257: openshell.v1.EditDraftChunkRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 264, // 258: openshell.v1.UndoDraftChunkRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 264, // 259: openshell.v1.ClearDraftChunksRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 264, // 260: openshell.v1.GetDraftHistoryRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector - 259, // 261: openshell.v1.DraftHistoryEntry.event_time:type_name -> google.protobuf.Timestamp - 216, // 262: openshell.v1.GetDraftHistoryResponse.entries:type_name -> openshell.v1.DraftHistoryEntry - 258, // 263: openshell.v1.CreateWorkspaceRequest.labels:type_name -> openshell.v1.CreateWorkspaceRequest.LabelsEntry - 273, // 264: openshell.v1.CreateWorkspaceResponse.workspace:type_name -> openshell.datamodel.v1.Workspace - 273, // 265: openshell.v1.GetWorkspaceResponse.workspace:type_name -> openshell.datamodel.v1.Workspace - 273, // 266: openshell.v1.ListWorkspacesResponse.workspaces:type_name -> openshell.datamodel.v1.Workspace - 14, // 267: openshell.v1.DeleteWorkspaceResponse.outcome:type_name -> openshell.v1.DeletionOutcome - 260, // 268: openshell.v1.WorkspaceMember.metadata:type_name -> openshell.datamodel.v1.ObjectMeta - 12, // 269: openshell.v1.WorkspaceMember.role:type_name -> openshell.v1.WorkspaceRole - 12, // 270: openshell.v1.AddWorkspaceMemberRequest.role:type_name -> openshell.v1.WorkspaceRole - 226, // 271: openshell.v1.AddWorkspaceMemberResponse.member:type_name -> openshell.v1.WorkspaceMember - 14, // 272: openshell.v1.RemoveWorkspaceMemberResponse.outcome:type_name -> openshell.v1.DeletionOutcome - 226, // 273: openshell.v1.ListWorkspaceMembersResponse.members:type_name -> openshell.v1.WorkspaceMember - 259, // 274: openshell.v1.ExtensionServiceCredential.expiration_time:type_name -> google.protobuf.Timestamp - 15, // 275: openshell.v1.EndpointObservation.result:type_name -> openshell.v1.EndpointResult - 234, // 276: openshell.v1.ReportEndpointStatusRequest.observations:type_name -> openshell.v1.EndpointObservation - 15, // 277: openshell.v1.EndpointStatus.last_result:type_name -> openshell.v1.EndpointResult - 259, // 278: openshell.v1.EndpointStatus.last_reported_time:type_name -> google.protobuf.Timestamp - 259, // 279: openshell.v1.UpdateProviderRequest.CredentialExpirationTimesEntry.value:type_name -> google.protobuf.Timestamp - 259, // 280: openshell.v1.GetSandboxProviderEnvironmentResponse.CredentialExpirationTimesEntry.value:type_name -> google.protobuf.Timestamp - 122, // 281: openshell.v1.GetSandboxProviderEnvironmentResponse.DynamicCredentialsEntry.value:type_name -> openshell.v1.ProviderProfileCredential - 150, // 282: openshell.v1.GetSandboxProviderEnvironmentResponse.StaticCredentialBindingsEntry.value:type_name -> openshell.v1.StaticCredentialBinding - 20, // 283: openshell.v1.OpenShell.Health:input_type -> openshell.v1.HealthRequest - 22, // 284: openshell.v1.OpenShell.GetCurrentUser:input_type -> openshell.v1.GetCurrentUserRequest - 24, // 285: openshell.v1.OpenShell.GetGatewayInfo:input_type -> openshell.v1.GetGatewayInfoRequest - 47, // 286: openshell.v1.OpenShell.CreateSandbox:input_type -> openshell.v1.CreateSandboxRequest - 55, // 287: openshell.v1.OpenShell.BeginRootfsTarStaging:input_type -> openshell.v1.BeginRootfsTarStagingRequest - 57, // 288: openshell.v1.OpenShell.GetSandbox:input_type -> openshell.v1.GetSandboxRequest - 58, // 289: openshell.v1.OpenShell.ListSandboxes:input_type -> openshell.v1.ListSandboxesRequest - 48, // 290: openshell.v1.OpenShell.CreateSandboxTemplate:input_type -> openshell.v1.CreateSandboxTemplateRequest - 49, // 291: openshell.v1.OpenShell.GetSandboxTemplate:input_type -> openshell.v1.GetSandboxTemplateRequest - 50, // 292: openshell.v1.OpenShell.ListSandboxTemplates:input_type -> openshell.v1.ListSandboxTemplatesRequest - 51, // 293: openshell.v1.OpenShell.DeleteSandboxTemplate:input_type -> openshell.v1.DeleteSandboxTemplateRequest - 59, // 294: openshell.v1.OpenShell.ListSandboxProviders:input_type -> openshell.v1.ListSandboxProvidersRequest - 60, // 295: openshell.v1.OpenShell.AttachSandboxProvider:input_type -> openshell.v1.AttachSandboxProviderRequest - 61, // 296: openshell.v1.OpenShell.DetachSandboxProvider:input_type -> openshell.v1.DetachSandboxProviderRequest - 77, // 297: openshell.v1.OpenShell.GetSandboxProviderStatus:input_type -> openshell.v1.GetSandboxProviderStatusRequest - 62, // 298: openshell.v1.OpenShell.DeleteSandbox:input_type -> openshell.v1.DeleteSandboxRequest - 63, // 299: openshell.v1.OpenShell.StopSandbox:input_type -> openshell.v1.StopSandboxRequest - 64, // 300: openshell.v1.OpenShell.StartSandbox:input_type -> openshell.v1.StartSandboxRequest - 82, // 301: openshell.v1.OpenShell.CreateSshSession:input_type -> openshell.v1.CreateSshSessionRequest - 84, // 302: openshell.v1.OpenShell.ExposeService:input_type -> openshell.v1.ExposeServiceRequest - 85, // 303: openshell.v1.OpenShell.GetService:input_type -> openshell.v1.GetServiceRequest - 86, // 304: openshell.v1.OpenShell.ListServices:input_type -> openshell.v1.ListServicesRequest - 88, // 305: openshell.v1.OpenShell.DeleteService:input_type -> openshell.v1.DeleteServiceRequest - 92, // 306: openshell.v1.OpenShell.RevokeSshSession:input_type -> openshell.v1.RevokeSshSessionRequest - 94, // 307: openshell.v1.OpenShell.ExecSandbox:input_type -> openshell.v1.ExecSandboxRequest - 100, // 308: openshell.v1.OpenShell.ForwardTcp:input_type -> openshell.v1.TcpForwardFrame - 101, // 309: openshell.v1.OpenShell.ExecSandboxInteractive:input_type -> openshell.v1.ExecSandboxInput - 108, // 310: openshell.v1.OpenShell.CreateProvider:input_type -> openshell.v1.CreateProviderRequest - 109, // 311: openshell.v1.OpenShell.GetProvider:input_type -> openshell.v1.GetProviderRequest - 110, // 312: openshell.v1.OpenShell.ListProviders:input_type -> openshell.v1.ListProvidersRequest - 115, // 313: openshell.v1.OpenShell.ListProviderProfiles:input_type -> openshell.v1.ListProviderProfilesRequest - 116, // 314: openshell.v1.OpenShell.GetProviderProfile:input_type -> openshell.v1.GetProviderProfileRequest - 139, // 315: openshell.v1.OpenShell.ImportProviderProfiles:input_type -> openshell.v1.ImportProviderProfilesRequest - 141, // 316: openshell.v1.OpenShell.UpdateProviderProfiles:input_type -> openshell.v1.UpdateProviderProfilesRequest - 143, // 317: openshell.v1.OpenShell.LintProviderProfiles:input_type -> openshell.v1.LintProviderProfilesRequest - 111, // 318: openshell.v1.OpenShell.UpdateProvider:input_type -> openshell.v1.UpdateProviderRequest - 128, // 319: openshell.v1.OpenShell.GetProviderRefreshStatus:input_type -> openshell.v1.GetProviderRefreshStatusRequest - 130, // 320: openshell.v1.OpenShell.ConfigureProviderRefresh:input_type -> openshell.v1.ConfigureProviderRefreshRequest - 132, // 321: openshell.v1.OpenShell.RotateProviderCredential:input_type -> openshell.v1.RotateProviderCredentialRequest - 134, // 322: openshell.v1.OpenShell.DeleteProviderRefresh:input_type -> openshell.v1.DeleteProviderRefreshRequest - 112, // 323: openshell.v1.OpenShell.DeleteProvider:input_type -> openshell.v1.DeleteProviderRequest - 146, // 324: openshell.v1.OpenShell.DeleteProviderProfile:input_type -> openshell.v1.DeleteProviderProfileRequest - 274, // 325: openshell.v1.OpenShell.GetSandboxConfig:input_type -> openshell.sandbox.v1.GetSandboxConfigRequest - 275, // 326: openshell.v1.OpenShell.GetGatewayConfig:input_type -> openshell.sandbox.v1.GetGatewayConfigRequest - 154, // 327: openshell.v1.OpenShell.UpdateConfig:input_type -> openshell.v1.UpdateConfigRequest - 163, // 328: openshell.v1.OpenShell.GetSandboxPolicyStatus:input_type -> openshell.v1.GetSandboxPolicyStatusRequest - 165, // 329: openshell.v1.OpenShell.ListSandboxPolicies:input_type -> openshell.v1.ListSandboxPoliciesRequest - 167, // 330: openshell.v1.OpenShell.ReportPolicyStatus:input_type -> openshell.v1.ReportPolicyStatusRequest - 235, // 331: openshell.v1.OpenShell.ReportEndpointStatus:input_type -> openshell.v1.ReportEndpointStatusRequest - 79, // 332: openshell.v1.OpenShell.ReportProviderReadiness:input_type -> openshell.v1.ReportProviderReadinessRequest - 148, // 333: openshell.v1.OpenShell.GetSandboxProviderEnvironment:input_type -> openshell.v1.GetSandboxProviderEnvironmentRequest - 152, // 334: openshell.v1.OpenShell.ExchangeProviderSubjectToken:input_type -> openshell.v1.ExchangeProviderSubjectTokenRequest - 170, // 335: openshell.v1.OpenShell.GetSandboxLogs:input_type -> openshell.v1.GetSandboxLogsRequest - 171, // 336: openshell.v1.OpenShell.PushSandboxLogs:input_type -> openshell.v1.PushSandboxLogsRequest - 174, // 337: openshell.v1.OpenShell.ConnectSupervisor:input_type -> openshell.v1.SupervisorMessage - 181, // 338: openshell.v1.OpenShell.ReportMainProcessExit:input_type -> openshell.v1.ReportMainProcessExitRequest - 183, // 339: openshell.v1.OpenShell.FinalizeMainProcessExit:input_type -> openshell.v1.FinalizeMainProcessExitRequest - 189, // 340: openshell.v1.OpenShell.RelayStream:input_type -> openshell.v1.RelayFrame - 104, // 341: openshell.v1.OpenShell.WatchSandbox:input_type -> openshell.v1.WatchSandboxRequest - 198, // 342: openshell.v1.OpenShell.SubmitPolicyAnalysis:input_type -> openshell.v1.SubmitPolicyAnalysisRequest - 200, // 343: openshell.v1.OpenShell.GetDraftPolicy:input_type -> openshell.v1.GetDraftPolicyRequest - 202, // 344: openshell.v1.OpenShell.ApproveDraftChunk:input_type -> openshell.v1.ApproveDraftChunkRequest - 204, // 345: openshell.v1.OpenShell.RejectDraftChunk:input_type -> openshell.v1.RejectDraftChunkRequest - 207, // 346: openshell.v1.OpenShell.ApproveAllDraftChunks:input_type -> openshell.v1.ApproveAllDraftChunksRequest - 209, // 347: openshell.v1.OpenShell.EditDraftChunk:input_type -> openshell.v1.EditDraftChunkRequest - 211, // 348: openshell.v1.OpenShell.UndoDraftChunk:input_type -> openshell.v1.UndoDraftChunkRequest - 213, // 349: openshell.v1.OpenShell.ClearDraftChunks:input_type -> openshell.v1.ClearDraftChunksRequest - 215, // 350: openshell.v1.OpenShell.GetDraftHistory:input_type -> openshell.v1.GetDraftHistoryRequest - 16, // 351: openshell.v1.OpenShell.IssueSandboxToken:input_type -> openshell.v1.IssueSandboxTokenRequest - 18, // 352: openshell.v1.OpenShell.RefreshSandboxToken:input_type -> openshell.v1.RefreshSandboxTokenRequest - 218, // 353: openshell.v1.OpenShell.CreateWorkspace:input_type -> openshell.v1.CreateWorkspaceRequest - 220, // 354: openshell.v1.OpenShell.GetWorkspace:input_type -> openshell.v1.GetWorkspaceRequest - 222, // 355: openshell.v1.OpenShell.ListWorkspaces:input_type -> openshell.v1.ListWorkspacesRequest - 224, // 356: openshell.v1.OpenShell.DeleteWorkspace:input_type -> openshell.v1.DeleteWorkspaceRequest - 227, // 357: openshell.v1.OpenShell.AddWorkspaceMember:input_type -> openshell.v1.AddWorkspaceMemberRequest - 229, // 358: openshell.v1.OpenShell.RemoveWorkspaceMember:input_type -> openshell.v1.RemoveWorkspaceMemberRequest - 231, // 359: openshell.v1.OpenShell.ListWorkspaceMembers:input_type -> openshell.v1.ListWorkspaceMembersRequest - 21, // 360: openshell.v1.OpenShell.Health:output_type -> openshell.v1.HealthResponse - 23, // 361: openshell.v1.OpenShell.GetCurrentUser:output_type -> openshell.v1.GetCurrentUserResponse - 25, // 362: openshell.v1.OpenShell.GetGatewayInfo:output_type -> openshell.v1.GetGatewayInfoResponse - 65, // 363: openshell.v1.OpenShell.CreateSandbox:output_type -> openshell.v1.SandboxResponse - 56, // 364: openshell.v1.OpenShell.BeginRootfsTarStaging:output_type -> openshell.v1.BeginRootfsTarStagingResponse - 65, // 365: openshell.v1.OpenShell.GetSandbox:output_type -> openshell.v1.SandboxResponse - 66, // 366: openshell.v1.OpenShell.ListSandboxes:output_type -> openshell.v1.ListSandboxesResponse - 52, // 367: openshell.v1.OpenShell.CreateSandboxTemplate:output_type -> openshell.v1.SandboxTemplateResponse - 52, // 368: openshell.v1.OpenShell.GetSandboxTemplate:output_type -> openshell.v1.SandboxTemplateResponse - 53, // 369: openshell.v1.OpenShell.ListSandboxTemplates:output_type -> openshell.v1.ListSandboxTemplatesResponse - 54, // 370: openshell.v1.OpenShell.DeleteSandboxTemplate:output_type -> openshell.v1.DeleteSandboxTemplateResponse - 67, // 371: openshell.v1.OpenShell.ListSandboxProviders:output_type -> openshell.v1.ListSandboxProvidersResponse - 68, // 372: openshell.v1.OpenShell.AttachSandboxProvider:output_type -> openshell.v1.AttachSandboxProviderResponse - 69, // 373: openshell.v1.OpenShell.DetachSandboxProvider:output_type -> openshell.v1.DetachSandboxProviderResponse - 78, // 374: openshell.v1.OpenShell.GetSandboxProviderStatus:output_type -> openshell.v1.GetSandboxProviderStatusResponse - 81, // 375: openshell.v1.OpenShell.DeleteSandbox:output_type -> openshell.v1.DeleteSandboxResponse - 65, // 376: openshell.v1.OpenShell.StopSandbox:output_type -> openshell.v1.SandboxResponse - 65, // 377: openshell.v1.OpenShell.StartSandbox:output_type -> openshell.v1.SandboxResponse - 83, // 378: openshell.v1.OpenShell.CreateSshSession:output_type -> openshell.v1.CreateSshSessionResponse - 91, // 379: openshell.v1.OpenShell.ExposeService:output_type -> openshell.v1.ServiceEndpointResponse - 91, // 380: openshell.v1.OpenShell.GetService:output_type -> openshell.v1.ServiceEndpointResponse - 87, // 381: openshell.v1.OpenShell.ListServices:output_type -> openshell.v1.ListServicesResponse - 89, // 382: openshell.v1.OpenShell.DeleteService:output_type -> openshell.v1.DeleteServiceResponse - 93, // 383: openshell.v1.OpenShell.RevokeSshSession:output_type -> openshell.v1.RevokeSshSessionResponse - 98, // 384: openshell.v1.OpenShell.ExecSandbox:output_type -> openshell.v1.ExecSandboxEvent - 100, // 385: openshell.v1.OpenShell.ForwardTcp:output_type -> openshell.v1.TcpForwardFrame - 98, // 386: openshell.v1.OpenShell.ExecSandboxInteractive:output_type -> openshell.v1.ExecSandboxEvent - 113, // 387: openshell.v1.OpenShell.CreateProvider:output_type -> openshell.v1.ProviderResponse - 113, // 388: openshell.v1.OpenShell.GetProvider:output_type -> openshell.v1.ProviderResponse - 114, // 389: openshell.v1.OpenShell.ListProviders:output_type -> openshell.v1.ListProvidersResponse - 138, // 390: openshell.v1.OpenShell.ListProviderProfiles:output_type -> openshell.v1.ListProviderProfilesResponse - 137, // 391: openshell.v1.OpenShell.GetProviderProfile:output_type -> openshell.v1.ProviderProfileResponse - 140, // 392: openshell.v1.OpenShell.ImportProviderProfiles:output_type -> openshell.v1.ImportProviderProfilesResponse - 142, // 393: openshell.v1.OpenShell.UpdateProviderProfiles:output_type -> openshell.v1.UpdateProviderProfilesResponse - 144, // 394: openshell.v1.OpenShell.LintProviderProfiles:output_type -> openshell.v1.LintProviderProfilesResponse - 113, // 395: openshell.v1.OpenShell.UpdateProvider:output_type -> openshell.v1.ProviderResponse - 129, // 396: openshell.v1.OpenShell.GetProviderRefreshStatus:output_type -> openshell.v1.GetProviderRefreshStatusResponse - 131, // 397: openshell.v1.OpenShell.ConfigureProviderRefresh:output_type -> openshell.v1.ConfigureProviderRefreshResponse - 133, // 398: openshell.v1.OpenShell.RotateProviderCredential:output_type -> openshell.v1.RotateProviderCredentialResponse - 135, // 399: openshell.v1.OpenShell.DeleteProviderRefresh:output_type -> openshell.v1.DeleteProviderRefreshResponse - 145, // 400: openshell.v1.OpenShell.DeleteProvider:output_type -> openshell.v1.DeleteProviderResponse - 147, // 401: openshell.v1.OpenShell.DeleteProviderProfile:output_type -> openshell.v1.DeleteProviderProfileResponse - 276, // 402: openshell.v1.OpenShell.GetSandboxConfig:output_type -> openshell.sandbox.v1.GetSandboxConfigResponse - 277, // 403: openshell.v1.OpenShell.GetGatewayConfig:output_type -> openshell.sandbox.v1.GetGatewayConfigResponse - 162, // 404: openshell.v1.OpenShell.UpdateConfig:output_type -> openshell.v1.UpdateConfigResponse - 164, // 405: openshell.v1.OpenShell.GetSandboxPolicyStatus:output_type -> openshell.v1.GetSandboxPolicyStatusResponse - 166, // 406: openshell.v1.OpenShell.ListSandboxPolicies:output_type -> openshell.v1.ListSandboxPoliciesResponse - 168, // 407: openshell.v1.OpenShell.ReportPolicyStatus:output_type -> openshell.v1.ReportPolicyStatusResponse - 236, // 408: openshell.v1.OpenShell.ReportEndpointStatus:output_type -> openshell.v1.ReportEndpointStatusResponse - 80, // 409: openshell.v1.OpenShell.ReportProviderReadiness:output_type -> openshell.v1.ReportProviderReadinessResponse - 151, // 410: openshell.v1.OpenShell.GetSandboxProviderEnvironment:output_type -> openshell.v1.GetSandboxProviderEnvironmentResponse - 153, // 411: openshell.v1.OpenShell.ExchangeProviderSubjectToken:output_type -> openshell.v1.ExchangeProviderSubjectTokenResponse - 173, // 412: openshell.v1.OpenShell.GetSandboxLogs:output_type -> openshell.v1.GetSandboxLogsResponse - 172, // 413: openshell.v1.OpenShell.PushSandboxLogs:output_type -> openshell.v1.PushSandboxLogsResponse - 175, // 414: openshell.v1.OpenShell.ConnectSupervisor:output_type -> openshell.v1.GatewayMessage - 182, // 415: openshell.v1.OpenShell.ReportMainProcessExit:output_type -> openshell.v1.ReportMainProcessExitResponse - 184, // 416: openshell.v1.OpenShell.FinalizeMainProcessExit:output_type -> openshell.v1.FinalizeMainProcessExitResponse - 189, // 417: openshell.v1.OpenShell.RelayStream:output_type -> openshell.v1.RelayFrame - 105, // 418: openshell.v1.OpenShell.WatchSandbox:output_type -> openshell.v1.SandboxStreamEvent - 199, // 419: openshell.v1.OpenShell.SubmitPolicyAnalysis:output_type -> openshell.v1.SubmitPolicyAnalysisResponse - 201, // 420: openshell.v1.OpenShell.GetDraftPolicy:output_type -> openshell.v1.GetDraftPolicyResponse - 203, // 421: openshell.v1.OpenShell.ApproveDraftChunk:output_type -> openshell.v1.ApproveDraftChunkResponse - 205, // 422: openshell.v1.OpenShell.RejectDraftChunk:output_type -> openshell.v1.RejectDraftChunkResponse - 208, // 423: openshell.v1.OpenShell.ApproveAllDraftChunks:output_type -> openshell.v1.ApproveAllDraftChunksResponse - 210, // 424: openshell.v1.OpenShell.EditDraftChunk:output_type -> openshell.v1.EditDraftChunkResponse - 212, // 425: openshell.v1.OpenShell.UndoDraftChunk:output_type -> openshell.v1.UndoDraftChunkResponse - 214, // 426: openshell.v1.OpenShell.ClearDraftChunks:output_type -> openshell.v1.ClearDraftChunksResponse - 217, // 427: openshell.v1.OpenShell.GetDraftHistory:output_type -> openshell.v1.GetDraftHistoryResponse - 17, // 428: openshell.v1.OpenShell.IssueSandboxToken:output_type -> openshell.v1.IssueSandboxTokenResponse - 19, // 429: openshell.v1.OpenShell.RefreshSandboxToken:output_type -> openshell.v1.RefreshSandboxTokenResponse - 219, // 430: openshell.v1.OpenShell.CreateWorkspace:output_type -> openshell.v1.CreateWorkspaceResponse - 221, // 431: openshell.v1.OpenShell.GetWorkspace:output_type -> openshell.v1.GetWorkspaceResponse - 223, // 432: openshell.v1.OpenShell.ListWorkspaces:output_type -> openshell.v1.ListWorkspacesResponse - 225, // 433: openshell.v1.OpenShell.DeleteWorkspace:output_type -> openshell.v1.DeleteWorkspaceResponse - 228, // 434: openshell.v1.OpenShell.AddWorkspaceMember:output_type -> openshell.v1.AddWorkspaceMemberResponse - 230, // 435: openshell.v1.OpenShell.RemoveWorkspaceMember:output_type -> openshell.v1.RemoveWorkspaceMemberResponse - 232, // 436: openshell.v1.OpenShell.ListWorkspaceMembers:output_type -> openshell.v1.ListWorkspaceMembersResponse - 360, // [360:437] is the sub-list for method output_type - 283, // [283:360] is the sub-list for method input_type - 283, // [283:283] is the sub-list for extension type_name - 283, // [283:283] is the sub-list for extension extendee - 0, // [0:283] is the sub-list for field type_name + 261, // 0: openshell.v1.IssueSandboxTokenResponse.expiration_time:type_name -> google.protobuf.Timestamp + 261, // 1: openshell.v1.RefreshSandboxTokenResponse.expiration_time:type_name -> google.protobuf.Timestamp + 235, // 2: openshell.v1.RefreshSandboxTokenResponse.extension_credentials:type_name -> openshell.v1.ExtensionServiceCredential + 261, // 3: openshell.v1.RefreshSandboxTokenResponse.sandbox_expiration_time:type_name -> google.protobuf.Timestamp + 12, // 4: openshell.v1.HealthResponse.status:type_name -> openshell.v1.ServiceStatus + 12, // 5: openshell.v1.GetGatewayInfoResponse.status:type_name -> openshell.v1.ServiceStatus + 28, // 6: openshell.v1.GetGatewayInfoResponse.compute_drivers:type_name -> openshell.v1.ComputeDriverInfo + 27, // 7: openshell.v1.GetGatewayInfoResponse.extensions:type_name -> openshell.v1.NegotiatedExtensionInfo + 0, // 8: openshell.v1.NegotiatedExtensionInfo.kind:type_name -> openshell.v1.ExtensionKind + 29, // 9: openshell.v1.ComputeDriverInfo.capabilities:type_name -> openshell.v1.ComputeDriverCapabilities + 30, // 10: openshell.v1.ComputeDriverCapabilities.resource_capabilities:type_name -> openshell.v1.ResourceCapabilities + 31, // 11: openshell.v1.ResourceCapabilities.cpu:type_name -> openshell.v1.CpuResourceCapabilities + 32, // 12: openshell.v1.ResourceCapabilities.memory:type_name -> openshell.v1.MemoryResourceCapabilities + 33, // 13: openshell.v1.ResourceCapabilities.gpu:type_name -> openshell.v1.GpuResourceCapabilities + 262, // 14: openshell.v1.Sandbox.metadata:type_name -> openshell.datamodel.v1.ObjectMeta + 35, // 15: openshell.v1.Sandbox.spec:type_name -> openshell.v1.SandboxSpec + 46, // 16: openshell.v1.Sandbox.status:type_name -> openshell.v1.SandboxStatus + 45, // 17: openshell.v1.Sandbox.created_from_workload_template:type_name -> openshell.v1.SandboxWorkloadTemplateProvenance + 240, // 18: openshell.v1.SandboxSpec.environment:type_name -> openshell.v1.SandboxSpec.EnvironmentEntry + 38, // 19: openshell.v1.SandboxSpec.template:type_name -> openshell.v1.SandboxTemplate + 263, // 20: openshell.v1.SandboxSpec.policy:type_name -> openshell.sandbox.v1.SandboxPolicy + 36, // 21: openshell.v1.SandboxSpec.resource_requirements:type_name -> openshell.v1.ResourceRequirements + 37, // 22: openshell.v1.ResourceRequirements.gpu:type_name -> openshell.v1.GpuResourceRequirements + 241, // 23: openshell.v1.SandboxTemplate.labels:type_name -> openshell.v1.SandboxTemplate.LabelsEntry + 242, // 24: openshell.v1.SandboxTemplate.annotations:type_name -> openshell.v1.SandboxTemplate.AnnotationsEntry + 243, // 25: openshell.v1.SandboxTemplate.environment:type_name -> openshell.v1.SandboxTemplate.EnvironmentEntry + 264, // 26: openshell.v1.SandboxTemplate.resources:type_name -> google.protobuf.Struct + 264, // 27: openshell.v1.SandboxTemplate.driver_config:type_name -> google.protobuf.Struct + 262, // 28: openshell.v1.SandboxWorkloadTemplate.metadata:type_name -> openshell.datamodel.v1.ObjectMeta + 40, // 29: openshell.v1.SandboxWorkloadTemplate.spec:type_name -> openshell.v1.SandboxWorkloadTemplateSpec + 41, // 30: openshell.v1.SandboxWorkloadTemplateSpec.workload:type_name -> openshell.v1.SandboxWorkloadConfig + 264, // 31: openshell.v1.SandboxWorkloadTemplateSpec.driver_config:type_name -> google.protobuf.Struct + 43, // 32: openshell.v1.SandboxWorkloadTemplateSpec.desired_service_level:type_name -> openshell.v1.SandboxServiceLevel + 244, // 33: openshell.v1.SandboxWorkloadConfig.environment:type_name -> openshell.v1.SandboxWorkloadConfig.EnvironmentEntry + 42, // 34: openshell.v1.SandboxWorkloadConfig.resources:type_name -> openshell.v1.SandboxResources + 37, // 35: openshell.v1.SandboxResources.gpu:type_name -> openshell.v1.GpuResourceRequirements + 44, // 36: openshell.v1.SandboxServiceLevel.startup:type_name -> openshell.v1.SandboxStartup + 265, // 37: openshell.v1.SandboxStartup.ready_within:type_name -> google.protobuf.Duration + 47, // 38: openshell.v1.SandboxStatus.conditions:type_name -> openshell.v1.SandboxCondition + 1, // 39: openshell.v1.SandboxStatus.phase:type_name -> openshell.v1.SandboxPhase + 239, // 40: openshell.v1.SandboxStatus.endpoint_statuses:type_name -> openshell.v1.EndpointStatus + 261, // 41: openshell.v1.SandboxCondition.transition_time:type_name -> google.protobuf.Timestamp + 261, // 42: openshell.v1.PlatformEvent.event_time:type_name -> google.protobuf.Timestamp + 245, // 43: openshell.v1.PlatformEvent.metadata:type_name -> openshell.v1.PlatformEvent.MetadataEntry + 35, // 44: openshell.v1.CreateSandboxRequest.spec:type_name -> openshell.v1.SandboxSpec + 246, // 45: openshell.v1.CreateSandboxRequest.labels:type_name -> openshell.v1.CreateSandboxRequest.LabelsEntry + 247, // 46: openshell.v1.CreateSandboxRequest.annotations:type_name -> openshell.v1.CreateSandboxRequest.AnnotationsEntry + 266, // 47: openshell.v1.CreateSandboxRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 39, // 48: openshell.v1.CreateSandboxTemplateRequest.template:type_name -> openshell.v1.SandboxWorkloadTemplate + 266, // 49: openshell.v1.CreateSandboxTemplateRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 266, // 50: openshell.v1.GetSandboxTemplateRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 266, // 51: openshell.v1.ListSandboxTemplatesRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 266, // 52: openshell.v1.DeleteSandboxTemplateRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 39, // 53: openshell.v1.SandboxTemplateResponse.template:type_name -> openshell.v1.SandboxWorkloadTemplate + 39, // 54: openshell.v1.ListSandboxTemplatesResponse.templates:type_name -> openshell.v1.SandboxWorkloadTemplate + 15, // 55: openshell.v1.DeleteSandboxTemplateResponse.outcome:type_name -> openshell.v1.DeletionOutcome + 266, // 56: openshell.v1.BeginRootfsTarStagingRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 261, // 57: openshell.v1.BeginRootfsTarStagingResponse.expiration_time:type_name -> google.protobuf.Timestamp + 266, // 58: openshell.v1.GetSandboxRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 266, // 59: openshell.v1.ListSandboxesRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 266, // 60: openshell.v1.ListSandboxProvidersRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 266, // 61: openshell.v1.AttachSandboxProviderRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 266, // 62: openshell.v1.DetachSandboxProviderRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 266, // 63: openshell.v1.DeleteSandboxRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 266, // 64: openshell.v1.StopSandboxRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 266, // 65: openshell.v1.StartSandboxRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 34, // 66: openshell.v1.SandboxResponse.sandbox:type_name -> openshell.v1.Sandbox + 34, // 67: openshell.v1.ListSandboxesResponse.sandboxes:type_name -> openshell.v1.Sandbox + 267, // 68: openshell.v1.ListSandboxProvidersResponse.providers:type_name -> openshell.datamodel.v1.Provider + 34, // 69: openshell.v1.AttachSandboxProviderResponse.sandbox:type_name -> openshell.v1.Sandbox + 76, // 70: openshell.v1.AttachSandboxProviderResponse.receipt:type_name -> openshell.v1.ProviderMutationReceipt + 34, // 71: openshell.v1.DetachSandboxProviderResponse.sandbox:type_name -> openshell.v1.Sandbox + 76, // 72: openshell.v1.DetachSandboxProviderResponse.receipt:type_name -> openshell.v1.ProviderMutationReceipt + 74, // 73: openshell.v1.ConfigSnapshotRevision.sandbox_config:type_name -> openshell.v1.SandboxConfigRevision + 72, // 74: openshell.v1.ConfigSnapshotRevision.provider_target:type_name -> openshell.v1.ProviderDesiredIdentity + 268, // 75: openshell.v1.SandboxConfigRevision.policy_source:type_name -> openshell.sandbox.v1.PolicySource + 5, // 76: openshell.v1.ConfigUpdateOperation.component:type_name -> openshell.v1.ConfigComponent + 73, // 77: openshell.v1.ConfigUpdateOperation.target_revision:type_name -> openshell.v1.ConfigSnapshotRevision + 7, // 78: openshell.v1.ConfigUpdateOperation.state:type_name -> openshell.v1.ConfigUpdateOperationState + 6, // 79: openshell.v1.ConfigUpdateOperation.outcome:type_name -> openshell.v1.ConfigApplyOutcome + 261, // 80: openshell.v1.ConfigUpdateOperation.created_time:type_name -> google.protobuf.Timestamp + 261, // 81: openshell.v1.ConfigUpdateOperation.updated_time:type_name -> google.protobuf.Timestamp + 261, // 82: openshell.v1.ConfigUpdateOperation.completed_time:type_name -> google.protobuf.Timestamp + 2, // 83: openshell.v1.ProviderMutationReceipt.kind:type_name -> openshell.v1.ProviderMutationKind + 72, // 84: openshell.v1.ProviderMutationReceipt.desired:type_name -> openshell.v1.ProviderDesiredIdentity + 261, // 85: openshell.v1.ProviderMutationReceipt.persisted_time:type_name -> google.protobuf.Timestamp + 4, // 86: openshell.v1.ProviderReadinessObservation.reason:type_name -> openshell.v1.ProviderReadinessReason + 76, // 87: openshell.v1.ProviderReadinessStatus.receipt:type_name -> openshell.v1.ProviderMutationReceipt + 3, // 88: openshell.v1.ProviderReadinessStatus.state:type_name -> openshell.v1.ProviderReadinessState + 4, // 89: openshell.v1.ProviderReadinessStatus.reason:type_name -> openshell.v1.ProviderReadinessReason + 77, // 90: openshell.v1.ProviderReadinessStatus.observed:type_name -> openshell.v1.ProviderReadinessObservation + 261, // 91: openshell.v1.ProviderReadinessStatus.observed_time:type_name -> google.protobuf.Timestamp + 261, // 92: openshell.v1.ProviderReadinessStatus.evaluated_time:type_name -> google.protobuf.Timestamp + 75, // 93: openshell.v1.ProviderReadinessStatus.operation:type_name -> openshell.v1.ConfigUpdateOperation + 266, // 94: openshell.v1.GetSandboxProviderStatusRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 78, // 95: openshell.v1.GetSandboxProviderStatusResponse.status:type_name -> openshell.v1.ProviderReadinessStatus + 77, // 96: openshell.v1.ReportProviderReadinessRequest.observation:type_name -> openshell.v1.ProviderReadinessObservation + 265, // 97: openshell.v1.ReportProviderReadinessResponse.report_interval:type_name -> google.protobuf.Duration + 265, // 98: openshell.v1.ReportProviderReadinessResponse.observation_ttl:type_name -> google.protobuf.Duration + 15, // 99: openshell.v1.DeleteSandboxResponse.outcome:type_name -> openshell.v1.DeletionOutcome + 261, // 100: openshell.v1.CreateSshSessionResponse.expiration_time:type_name -> google.protobuf.Timestamp + 266, // 101: openshell.v1.ExposeServiceRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 266, // 102: openshell.v1.GetServiceRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 266, // 103: openshell.v1.ListServicesRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 93, // 104: openshell.v1.ListServicesResponse.services:type_name -> openshell.v1.ServiceEndpointResponse + 266, // 105: openshell.v1.DeleteServiceRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 15, // 106: openshell.v1.DeleteServiceResponse.outcome:type_name -> openshell.v1.DeletionOutcome + 262, // 107: openshell.v1.ServiceEndpoint.metadata:type_name -> openshell.datamodel.v1.ObjectMeta + 92, // 108: openshell.v1.ServiceEndpointResponse.endpoint:type_name -> openshell.v1.ServiceEndpoint + 15, // 109: openshell.v1.RevokeSshSessionResponse.outcome:type_name -> openshell.v1.DeletionOutcome + 248, // 110: openshell.v1.ExecSandboxRequest.environment:type_name -> openshell.v1.ExecSandboxRequest.EnvironmentEntry + 265, // 111: openshell.v1.ExecSandboxRequest.execution_timeout:type_name -> google.protobuf.Duration + 97, // 112: openshell.v1.ExecSandboxEvent.stdout:type_name -> openshell.v1.ExecSandboxStdout + 98, // 113: openshell.v1.ExecSandboxEvent.stderr:type_name -> openshell.v1.ExecSandboxStderr + 99, // 114: openshell.v1.ExecSandboxEvent.exit:type_name -> openshell.v1.ExecSandboxExit + 188, // 115: openshell.v1.TcpForwardInit.ssh:type_name -> openshell.v1.SshRelayTarget + 189, // 116: openshell.v1.TcpForwardInit.tcp:type_name -> openshell.v1.TcpRelayTarget + 101, // 117: openshell.v1.TcpForwardFrame.init:type_name -> openshell.v1.TcpForwardInit + 96, // 118: openshell.v1.ExecSandboxInput.start:type_name -> openshell.v1.ExecSandboxRequest + 104, // 119: openshell.v1.ExecSandboxInput.resize:type_name -> openshell.v1.ExecSandboxWindowResize + 262, // 120: openshell.v1.SshSession.metadata:type_name -> openshell.datamodel.v1.ObjectMeta + 261, // 121: openshell.v1.SshSession.expiration_time:type_name -> google.protobuf.Timestamp + 261, // 122: openshell.v1.WatchSandboxRequest.since_time:type_name -> google.protobuf.Timestamp + 34, // 123: openshell.v1.SandboxStreamEvent.sandbox:type_name -> openshell.v1.Sandbox + 108, // 124: openshell.v1.SandboxStreamEvent.log:type_name -> openshell.v1.SandboxLogLine + 48, // 125: openshell.v1.SandboxStreamEvent.event:type_name -> openshell.v1.PlatformEvent + 109, // 126: openshell.v1.SandboxStreamEvent.warning:type_name -> openshell.v1.SandboxStreamWarning + 199, // 127: openshell.v1.SandboxStreamEvent.draft_policy_update:type_name -> openshell.v1.DraftPolicyUpdate + 261, // 128: openshell.v1.SandboxLogLine.event_time:type_name -> google.protobuf.Timestamp + 249, // 129: openshell.v1.SandboxLogLine.fields:type_name -> openshell.v1.SandboxLogLine.FieldsEntry + 267, // 130: openshell.v1.CreateProviderRequest.provider:type_name -> openshell.datamodel.v1.Provider + 266, // 131: openshell.v1.CreateProviderRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 266, // 132: openshell.v1.GetProviderRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 266, // 133: openshell.v1.ListProvidersRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 267, // 134: openshell.v1.UpdateProviderRequest.provider:type_name -> openshell.datamodel.v1.Provider + 250, // 135: openshell.v1.UpdateProviderRequest.credential_expiration_times:type_name -> openshell.v1.UpdateProviderRequest.CredentialExpirationTimesEntry + 266, // 136: openshell.v1.UpdateProviderRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 266, // 137: openshell.v1.DeleteProviderRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 267, // 138: openshell.v1.ProviderResponse.provider:type_name -> openshell.datamodel.v1.Provider + 76, // 139: openshell.v1.ProviderResponse.target_receipts:type_name -> openshell.v1.ProviderMutationReceipt + 267, // 140: openshell.v1.ListProvidersResponse.providers:type_name -> openshell.datamodel.v1.Provider + 138, // 141: openshell.v1.ProviderProfileImportItem.profile:type_name -> openshell.v1.ProviderProfile + 265, // 142: openshell.v1.ProviderCredentialTokenGrant.cache_ttl:type_name -> google.protobuf.Duration + 121, // 143: openshell.v1.ProviderCredentialTokenGrant.audience_overrides:type_name -> openshell.v1.ProviderCredentialTokenGrantAudienceOverride + 8, // 144: openshell.v1.ProviderCredentialTokenGrant.grant_type:type_name -> openshell.v1.ProviderCredentialTokenGrantType + 122, // 145: openshell.v1.ProviderCredentialTokenGrant.subject_token:type_name -> openshell.v1.ProviderCredentialTokenGrantSubjectToken + 127, // 146: openshell.v1.ProviderProfileCredential.refresh:type_name -> openshell.v1.ProviderCredentialRefresh + 123, // 147: openshell.v1.ProviderProfileCredential.token_grant:type_name -> openshell.v1.ProviderCredentialTokenGrant + 9, // 148: openshell.v1.ProviderCredentialRefresh.strategy:type_name -> openshell.v1.ProviderCredentialRefreshStrategy + 265, // 149: openshell.v1.ProviderCredentialRefresh.refresh_before:type_name -> google.protobuf.Duration + 265, // 150: openshell.v1.ProviderCredentialRefresh.max_lifetime:type_name -> google.protobuf.Duration + 125, // 151: openshell.v1.ProviderCredentialRefresh.material:type_name -> openshell.v1.ProviderCredentialRefreshMaterial + 126, // 152: openshell.v1.ProviderCredentialRefresh.additional_outputs:type_name -> openshell.v1.ProviderCredentialRefreshOutput + 9, // 153: openshell.v1.ProviderCredentialRefreshStatus.strategy:type_name -> openshell.v1.ProviderCredentialRefreshStrategy + 261, // 154: openshell.v1.ProviderCredentialRefreshStatus.expiration_time:type_name -> google.protobuf.Timestamp + 261, // 155: openshell.v1.ProviderCredentialRefreshStatus.next_refresh_time:type_name -> google.protobuf.Timestamp + 261, // 156: openshell.v1.ProviderCredentialRefreshStatus.last_refresh_time:type_name -> google.protobuf.Timestamp + 14, // 157: openshell.v1.ProviderCredentialRefreshStatus.recovery_action:type_name -> openshell.v1.ProviderCredentialRefreshRecoveryAction + 261, // 158: openshell.v1.ProviderCredentialRefreshStatus.last_error_time:type_name -> google.protobuf.Timestamp + 266, // 159: openshell.v1.GetProviderRefreshStatusRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 128, // 160: openshell.v1.GetProviderRefreshStatusResponse.credentials:type_name -> openshell.v1.ProviderCredentialRefreshStatus + 9, // 161: openshell.v1.ConfigureProviderRefreshRequest.strategy:type_name -> openshell.v1.ProviderCredentialRefreshStrategy + 251, // 162: openshell.v1.ConfigureProviderRefreshRequest.material:type_name -> openshell.v1.ConfigureProviderRefreshRequest.MaterialEntry + 261, // 163: openshell.v1.ConfigureProviderRefreshRequest.expiration_time:type_name -> google.protobuf.Timestamp + 266, // 164: openshell.v1.ConfigureProviderRefreshRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 128, // 165: openshell.v1.ConfigureProviderRefreshResponse.status:type_name -> openshell.v1.ProviderCredentialRefreshStatus + 266, // 166: openshell.v1.RotateProviderCredentialRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 128, // 167: openshell.v1.RotateProviderCredentialResponse.status:type_name -> openshell.v1.ProviderCredentialRefreshStatus + 266, // 168: openshell.v1.DeleteProviderRefreshRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 15, // 169: openshell.v1.DeleteProviderRefreshResponse.outcome:type_name -> openshell.v1.DeletionOutcome + 10, // 170: openshell.v1.ProviderProfile.category:type_name -> openshell.v1.ProviderProfileCategory + 124, // 171: openshell.v1.ProviderProfile.credentials:type_name -> openshell.v1.ProviderProfileCredential + 269, // 172: openshell.v1.ProviderProfile.endpoints:type_name -> openshell.sandbox.v1.NetworkEndpoint + 270, // 173: openshell.v1.ProviderProfile.binaries:type_name -> openshell.sandbox.v1.NetworkBinary + 129, // 174: openshell.v1.ProviderProfile.discovery:type_name -> openshell.v1.ProviderProfileDiscovery + 252, // 175: openshell.v1.ProviderProfile.annotations:type_name -> openshell.v1.ProviderProfile.AnnotationsEntry + 138, // 176: openshell.v1.ProviderProfileResponse.profile:type_name -> openshell.v1.ProviderProfile + 138, // 177: openshell.v1.ListProviderProfilesResponse.profiles:type_name -> openshell.v1.ProviderProfile + 119, // 178: openshell.v1.ImportProviderProfilesRequest.profiles:type_name -> openshell.v1.ProviderProfileImportItem + 120, // 179: openshell.v1.ImportProviderProfilesResponse.diagnostics:type_name -> openshell.v1.ProviderProfileDiagnostic + 138, // 180: openshell.v1.ImportProviderProfilesResponse.profiles:type_name -> openshell.v1.ProviderProfile + 119, // 181: openshell.v1.UpdateProviderProfilesRequest.profile:type_name -> openshell.v1.ProviderProfileImportItem + 120, // 182: openshell.v1.UpdateProviderProfilesResponse.diagnostics:type_name -> openshell.v1.ProviderProfileDiagnostic + 138, // 183: openshell.v1.UpdateProviderProfilesResponse.profile:type_name -> openshell.v1.ProviderProfile + 119, // 184: openshell.v1.LintProviderProfilesRequest.profiles:type_name -> openshell.v1.ProviderProfileImportItem + 120, // 185: openshell.v1.LintProviderProfilesResponse.diagnostics:type_name -> openshell.v1.ProviderProfileDiagnostic + 15, // 186: openshell.v1.DeleteProviderResponse.outcome:type_name -> openshell.v1.DeletionOutcome + 15, // 187: openshell.v1.DeleteProviderProfileResponse.outcome:type_name -> openshell.v1.DeletionOutcome + 151, // 188: openshell.v1.StaticCredentialBinding.endpoints:type_name -> openshell.v1.StaticCredentialEndpointBinding + 253, // 189: openshell.v1.GetSandboxProviderEnvironmentResponse.environment:type_name -> openshell.v1.GetSandboxProviderEnvironmentResponse.EnvironmentEntry + 254, // 190: openshell.v1.GetSandboxProviderEnvironmentResponse.credential_expiration_times:type_name -> openshell.v1.GetSandboxProviderEnvironmentResponse.CredentialExpirationTimesEntry + 255, // 191: openshell.v1.GetSandboxProviderEnvironmentResponse.dynamic_credentials:type_name -> openshell.v1.GetSandboxProviderEnvironmentResponse.DynamicCredentialsEntry + 256, // 192: openshell.v1.GetSandboxProviderEnvironmentResponse.static_credential_bindings:type_name -> openshell.v1.GetSandboxProviderEnvironmentResponse.StaticCredentialBindingsEntry + 4, // 193: openshell.v1.GetSandboxProviderEnvironmentResponse.readiness_reason:type_name -> openshell.v1.ProviderReadinessReason + 265, // 194: openshell.v1.ExchangeProviderSubjectTokenResponse.expires_after:type_name -> google.protobuf.Duration + 263, // 195: openshell.v1.UpdateConfigRequest.policy:type_name -> openshell.sandbox.v1.SandboxPolicy + 271, // 196: openshell.v1.UpdateConfigRequest.setting_value:type_name -> openshell.sandbox.v1.SettingValue + 157, // 197: openshell.v1.UpdateConfigRequest.merge_operations:type_name -> openshell.v1.PolicyMergeOperation + 257, // 198: openshell.v1.UpdateConfigRequest.annotations:type_name -> openshell.v1.UpdateConfigRequest.AnnotationsEntry + 266, // 199: openshell.v1.UpdateConfigRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 158, // 200: openshell.v1.PolicyMergeOperation.add_rule:type_name -> openshell.v1.AddNetworkRule + 159, // 201: openshell.v1.PolicyMergeOperation.remove_endpoint:type_name -> openshell.v1.RemoveNetworkEndpoint + 160, // 202: openshell.v1.PolicyMergeOperation.remove_rule:type_name -> openshell.v1.RemoveNetworkRule + 161, // 203: openshell.v1.PolicyMergeOperation.add_deny_rules:type_name -> openshell.v1.AddDenyRules + 162, // 204: openshell.v1.PolicyMergeOperation.add_allow_rules:type_name -> openshell.v1.AddAllowRules + 163, // 205: openshell.v1.PolicyMergeOperation.remove_binary:type_name -> openshell.v1.RemoveNetworkBinary + 272, // 206: openshell.v1.AddNetworkRule.rule:type_name -> openshell.sandbox.v1.NetworkPolicyRule + 273, // 207: openshell.v1.AddDenyRules.deny_rules:type_name -> openshell.sandbox.v1.L7DenyRule + 274, // 208: openshell.v1.AddAllowRules.rules:type_name -> openshell.sandbox.v1.L7Rule + 258, // 209: openshell.v1.UpdateConfigResponse.annotations:type_name -> openshell.v1.UpdateConfigResponse.AnnotationsEntry + 266, // 210: openshell.v1.GetSandboxPolicyStatusRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 171, // 211: openshell.v1.GetSandboxPolicyStatusResponse.revision:type_name -> openshell.v1.SandboxPolicyRevision + 266, // 212: openshell.v1.ListSandboxPoliciesRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 171, // 213: openshell.v1.ListSandboxPoliciesResponse.revisions:type_name -> openshell.v1.SandboxPolicyRevision + 11, // 214: openshell.v1.ReportPolicyStatusRequest.status:type_name -> openshell.v1.PolicyStatus + 11, // 215: openshell.v1.SandboxPolicyRevision.status:type_name -> openshell.v1.PolicyStatus + 261, // 216: openshell.v1.SandboxPolicyRevision.created_time:type_name -> google.protobuf.Timestamp + 261, // 217: openshell.v1.SandboxPolicyRevision.loaded_time:type_name -> google.protobuf.Timestamp + 263, // 218: openshell.v1.SandboxPolicyRevision.policy:type_name -> openshell.sandbox.v1.SandboxPolicy + 259, // 219: openshell.v1.SandboxPolicyRevision.provenance:type_name -> openshell.v1.SandboxPolicyRevision.ProvenanceEntry + 261, // 220: openshell.v1.GetSandboxLogsRequest.since_time:type_name -> google.protobuf.Timestamp + 266, // 221: openshell.v1.GetSandboxLogsRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 108, // 222: openshell.v1.PushSandboxLogsRequest.logs:type_name -> openshell.v1.SandboxLogLine + 108, // 223: openshell.v1.GetSandboxLogsResponse.logs:type_name -> openshell.v1.SandboxLogLine + 178, // 224: openshell.v1.SupervisorMessage.hello:type_name -> openshell.v1.SupervisorHello + 181, // 225: openshell.v1.SupervisorMessage.heartbeat:type_name -> openshell.v1.SupervisorHeartbeat + 192, // 226: openshell.v1.SupervisorMessage.relay_open_result:type_name -> openshell.v1.RelayOpenResult + 193, // 227: openshell.v1.SupervisorMessage.relay_close:type_name -> openshell.v1.RelayClose + 179, // 228: openshell.v1.GatewayMessage.session_accepted:type_name -> openshell.v1.SessionAccepted + 180, // 229: openshell.v1.GatewayMessage.session_rejected:type_name -> openshell.v1.SessionRejected + 182, // 230: openshell.v1.GatewayMessage.heartbeat:type_name -> openshell.v1.GatewayHeartbeat + 187, // 231: openshell.v1.GatewayMessage.relay_open:type_name -> openshell.v1.RelayOpen + 193, // 232: openshell.v1.GatewayMessage.relay_close:type_name -> openshell.v1.RelayClose + 265, // 233: openshell.v1.SessionAccepted.heartbeat_interval:type_name -> google.protobuf.Duration + 188, // 234: openshell.v1.RelayOpen.ssh:type_name -> openshell.v1.SshRelayTarget + 189, // 235: openshell.v1.RelayOpen.tcp:type_name -> openshell.v1.TcpRelayTarget + 190, // 236: openshell.v1.RelayFrame.init:type_name -> openshell.v1.RelayInit + 261, // 237: openshell.v1.DenialSummary.first_seen_time:type_name -> google.protobuf.Timestamp + 261, // 238: openshell.v1.DenialSummary.last_seen_time:type_name -> google.protobuf.Timestamp + 194, // 239: openshell.v1.DenialSummary.l7_request_samples:type_name -> openshell.v1.L7RequestSample + 196, // 240: openshell.v1.NetworkActivitySummary.denials_by_group:type_name -> openshell.v1.DenialGroupCount + 272, // 241: openshell.v1.PolicyChunk.proposed_rule:type_name -> openshell.sandbox.v1.NetworkPolicyRule + 261, // 242: openshell.v1.PolicyChunk.created_time:type_name -> google.protobuf.Timestamp + 261, // 243: openshell.v1.PolicyChunk.decided_time:type_name -> google.protobuf.Timestamp + 261, // 244: openshell.v1.PolicyChunk.first_seen_time:type_name -> google.protobuf.Timestamp + 261, // 245: openshell.v1.PolicyChunk.last_seen_time:type_name -> google.protobuf.Timestamp + 263, // 246: openshell.v1.PolicyChunk.current_effective_policy:type_name -> openshell.sandbox.v1.SandboxPolicy + 263, // 247: openshell.v1.PolicyChunk.candidate_effective_policy:type_name -> openshell.sandbox.v1.SandboxPolicy + 195, // 248: openshell.v1.SubmitPolicyAnalysisRequest.summaries:type_name -> openshell.v1.DenialSummary + 198, // 249: openshell.v1.SubmitPolicyAnalysisRequest.proposed_chunks:type_name -> openshell.v1.PolicyChunk + 197, // 250: openshell.v1.SubmitPolicyAnalysisRequest.network_activity_summaries:type_name -> openshell.v1.NetworkActivitySummary + 266, // 251: openshell.v1.GetDraftPolicyRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 198, // 252: openshell.v1.GetDraftPolicyResponse.chunks:type_name -> openshell.v1.PolicyChunk + 261, // 253: openshell.v1.GetDraftPolicyResponse.last_analyzed_time:type_name -> google.protobuf.Timestamp + 266, // 254: openshell.v1.ApproveDraftChunkRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 266, // 255: openshell.v1.RejectDraftChunkRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 208, // 256: openshell.v1.ApproveAllDraftChunksRequest.approvals:type_name -> openshell.v1.DraftChunkApproval + 266, // 257: openshell.v1.ApproveAllDraftChunksRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 272, // 258: openshell.v1.EditDraftChunkRequest.proposed_rule:type_name -> openshell.sandbox.v1.NetworkPolicyRule + 266, // 259: openshell.v1.EditDraftChunkRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 266, // 260: openshell.v1.UndoDraftChunkRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 266, // 261: openshell.v1.ClearDraftChunksRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 266, // 262: openshell.v1.GetDraftHistoryRequest.workspace_scope:type_name -> openshell.datamodel.v1.WorkspaceSelector + 261, // 263: openshell.v1.DraftHistoryEntry.event_time:type_name -> google.protobuf.Timestamp + 218, // 264: openshell.v1.GetDraftHistoryResponse.entries:type_name -> openshell.v1.DraftHistoryEntry + 260, // 265: openshell.v1.CreateWorkspaceRequest.labels:type_name -> openshell.v1.CreateWorkspaceRequest.LabelsEntry + 275, // 266: openshell.v1.CreateWorkspaceResponse.workspace:type_name -> openshell.datamodel.v1.Workspace + 275, // 267: openshell.v1.GetWorkspaceResponse.workspace:type_name -> openshell.datamodel.v1.Workspace + 275, // 268: openshell.v1.ListWorkspacesResponse.workspaces:type_name -> openshell.datamodel.v1.Workspace + 15, // 269: openshell.v1.DeleteWorkspaceResponse.outcome:type_name -> openshell.v1.DeletionOutcome + 262, // 270: openshell.v1.WorkspaceMember.metadata:type_name -> openshell.datamodel.v1.ObjectMeta + 13, // 271: openshell.v1.WorkspaceMember.role:type_name -> openshell.v1.WorkspaceRole + 13, // 272: openshell.v1.AddWorkspaceMemberRequest.role:type_name -> openshell.v1.WorkspaceRole + 228, // 273: openshell.v1.AddWorkspaceMemberResponse.member:type_name -> openshell.v1.WorkspaceMember + 15, // 274: openshell.v1.RemoveWorkspaceMemberResponse.outcome:type_name -> openshell.v1.DeletionOutcome + 228, // 275: openshell.v1.ListWorkspaceMembersResponse.members:type_name -> openshell.v1.WorkspaceMember + 261, // 276: openshell.v1.ExtensionServiceCredential.expiration_time:type_name -> google.protobuf.Timestamp + 16, // 277: openshell.v1.EndpointObservation.result:type_name -> openshell.v1.EndpointResult + 236, // 278: openshell.v1.ReportEndpointStatusRequest.observations:type_name -> openshell.v1.EndpointObservation + 16, // 279: openshell.v1.EndpointStatus.last_result:type_name -> openshell.v1.EndpointResult + 261, // 280: openshell.v1.EndpointStatus.last_reported_time:type_name -> google.protobuf.Timestamp + 261, // 281: openshell.v1.UpdateProviderRequest.CredentialExpirationTimesEntry.value:type_name -> google.protobuf.Timestamp + 261, // 282: openshell.v1.GetSandboxProviderEnvironmentResponse.CredentialExpirationTimesEntry.value:type_name -> google.protobuf.Timestamp + 124, // 283: openshell.v1.GetSandboxProviderEnvironmentResponse.DynamicCredentialsEntry.value:type_name -> openshell.v1.ProviderProfileCredential + 152, // 284: openshell.v1.GetSandboxProviderEnvironmentResponse.StaticCredentialBindingsEntry.value:type_name -> openshell.v1.StaticCredentialBinding + 21, // 285: openshell.v1.OpenShell.Health:input_type -> openshell.v1.HealthRequest + 23, // 286: openshell.v1.OpenShell.GetCurrentUser:input_type -> openshell.v1.GetCurrentUserRequest + 25, // 287: openshell.v1.OpenShell.GetGatewayInfo:input_type -> openshell.v1.GetGatewayInfoRequest + 49, // 288: openshell.v1.OpenShell.CreateSandbox:input_type -> openshell.v1.CreateSandboxRequest + 57, // 289: openshell.v1.OpenShell.BeginRootfsTarStaging:input_type -> openshell.v1.BeginRootfsTarStagingRequest + 59, // 290: openshell.v1.OpenShell.GetSandbox:input_type -> openshell.v1.GetSandboxRequest + 60, // 291: openshell.v1.OpenShell.ListSandboxes:input_type -> openshell.v1.ListSandboxesRequest + 50, // 292: openshell.v1.OpenShell.CreateSandboxTemplate:input_type -> openshell.v1.CreateSandboxTemplateRequest + 51, // 293: openshell.v1.OpenShell.GetSandboxTemplate:input_type -> openshell.v1.GetSandboxTemplateRequest + 52, // 294: openshell.v1.OpenShell.ListSandboxTemplates:input_type -> openshell.v1.ListSandboxTemplatesRequest + 53, // 295: openshell.v1.OpenShell.DeleteSandboxTemplate:input_type -> openshell.v1.DeleteSandboxTemplateRequest + 61, // 296: openshell.v1.OpenShell.ListSandboxProviders:input_type -> openshell.v1.ListSandboxProvidersRequest + 62, // 297: openshell.v1.OpenShell.AttachSandboxProvider:input_type -> openshell.v1.AttachSandboxProviderRequest + 63, // 298: openshell.v1.OpenShell.DetachSandboxProvider:input_type -> openshell.v1.DetachSandboxProviderRequest + 79, // 299: openshell.v1.OpenShell.GetSandboxProviderStatus:input_type -> openshell.v1.GetSandboxProviderStatusRequest + 64, // 300: openshell.v1.OpenShell.DeleteSandbox:input_type -> openshell.v1.DeleteSandboxRequest + 65, // 301: openshell.v1.OpenShell.StopSandbox:input_type -> openshell.v1.StopSandboxRequest + 66, // 302: openshell.v1.OpenShell.StartSandbox:input_type -> openshell.v1.StartSandboxRequest + 84, // 303: openshell.v1.OpenShell.CreateSshSession:input_type -> openshell.v1.CreateSshSessionRequest + 86, // 304: openshell.v1.OpenShell.ExposeService:input_type -> openshell.v1.ExposeServiceRequest + 87, // 305: openshell.v1.OpenShell.GetService:input_type -> openshell.v1.GetServiceRequest + 88, // 306: openshell.v1.OpenShell.ListServices:input_type -> openshell.v1.ListServicesRequest + 90, // 307: openshell.v1.OpenShell.DeleteService:input_type -> openshell.v1.DeleteServiceRequest + 94, // 308: openshell.v1.OpenShell.RevokeSshSession:input_type -> openshell.v1.RevokeSshSessionRequest + 96, // 309: openshell.v1.OpenShell.ExecSandbox:input_type -> openshell.v1.ExecSandboxRequest + 102, // 310: openshell.v1.OpenShell.ForwardTcp:input_type -> openshell.v1.TcpForwardFrame + 103, // 311: openshell.v1.OpenShell.ExecSandboxInteractive:input_type -> openshell.v1.ExecSandboxInput + 110, // 312: openshell.v1.OpenShell.CreateProvider:input_type -> openshell.v1.CreateProviderRequest + 111, // 313: openshell.v1.OpenShell.GetProvider:input_type -> openshell.v1.GetProviderRequest + 112, // 314: openshell.v1.OpenShell.ListProviders:input_type -> openshell.v1.ListProvidersRequest + 117, // 315: openshell.v1.OpenShell.ListProviderProfiles:input_type -> openshell.v1.ListProviderProfilesRequest + 118, // 316: openshell.v1.OpenShell.GetProviderProfile:input_type -> openshell.v1.GetProviderProfileRequest + 141, // 317: openshell.v1.OpenShell.ImportProviderProfiles:input_type -> openshell.v1.ImportProviderProfilesRequest + 143, // 318: openshell.v1.OpenShell.UpdateProviderProfiles:input_type -> openshell.v1.UpdateProviderProfilesRequest + 145, // 319: openshell.v1.OpenShell.LintProviderProfiles:input_type -> openshell.v1.LintProviderProfilesRequest + 113, // 320: openshell.v1.OpenShell.UpdateProvider:input_type -> openshell.v1.UpdateProviderRequest + 130, // 321: openshell.v1.OpenShell.GetProviderRefreshStatus:input_type -> openshell.v1.GetProviderRefreshStatusRequest + 132, // 322: openshell.v1.OpenShell.ConfigureProviderRefresh:input_type -> openshell.v1.ConfigureProviderRefreshRequest + 134, // 323: openshell.v1.OpenShell.RotateProviderCredential:input_type -> openshell.v1.RotateProviderCredentialRequest + 136, // 324: openshell.v1.OpenShell.DeleteProviderRefresh:input_type -> openshell.v1.DeleteProviderRefreshRequest + 114, // 325: openshell.v1.OpenShell.DeleteProvider:input_type -> openshell.v1.DeleteProviderRequest + 148, // 326: openshell.v1.OpenShell.DeleteProviderProfile:input_type -> openshell.v1.DeleteProviderProfileRequest + 276, // 327: openshell.v1.OpenShell.GetSandboxConfig:input_type -> openshell.sandbox.v1.GetSandboxConfigRequest + 277, // 328: openshell.v1.OpenShell.GetGatewayConfig:input_type -> openshell.sandbox.v1.GetGatewayConfigRequest + 156, // 329: openshell.v1.OpenShell.UpdateConfig:input_type -> openshell.v1.UpdateConfigRequest + 165, // 330: openshell.v1.OpenShell.GetSandboxPolicyStatus:input_type -> openshell.v1.GetSandboxPolicyStatusRequest + 167, // 331: openshell.v1.OpenShell.ListSandboxPolicies:input_type -> openshell.v1.ListSandboxPoliciesRequest + 169, // 332: openshell.v1.OpenShell.ReportPolicyStatus:input_type -> openshell.v1.ReportPolicyStatusRequest + 237, // 333: openshell.v1.OpenShell.ReportEndpointStatus:input_type -> openshell.v1.ReportEndpointStatusRequest + 81, // 334: openshell.v1.OpenShell.ReportProviderReadiness:input_type -> openshell.v1.ReportProviderReadinessRequest + 150, // 335: openshell.v1.OpenShell.GetSandboxProviderEnvironment:input_type -> openshell.v1.GetSandboxProviderEnvironmentRequest + 154, // 336: openshell.v1.OpenShell.ExchangeProviderSubjectToken:input_type -> openshell.v1.ExchangeProviderSubjectTokenRequest + 172, // 337: openshell.v1.OpenShell.GetSandboxLogs:input_type -> openshell.v1.GetSandboxLogsRequest + 173, // 338: openshell.v1.OpenShell.PushSandboxLogs:input_type -> openshell.v1.PushSandboxLogsRequest + 176, // 339: openshell.v1.OpenShell.ConnectSupervisor:input_type -> openshell.v1.SupervisorMessage + 183, // 340: openshell.v1.OpenShell.ReportMainProcessExit:input_type -> openshell.v1.ReportMainProcessExitRequest + 185, // 341: openshell.v1.OpenShell.FinalizeMainProcessExit:input_type -> openshell.v1.FinalizeMainProcessExitRequest + 191, // 342: openshell.v1.OpenShell.RelayStream:input_type -> openshell.v1.RelayFrame + 106, // 343: openshell.v1.OpenShell.WatchSandbox:input_type -> openshell.v1.WatchSandboxRequest + 200, // 344: openshell.v1.OpenShell.SubmitPolicyAnalysis:input_type -> openshell.v1.SubmitPolicyAnalysisRequest + 202, // 345: openshell.v1.OpenShell.GetDraftPolicy:input_type -> openshell.v1.GetDraftPolicyRequest + 204, // 346: openshell.v1.OpenShell.ApproveDraftChunk:input_type -> openshell.v1.ApproveDraftChunkRequest + 206, // 347: openshell.v1.OpenShell.RejectDraftChunk:input_type -> openshell.v1.RejectDraftChunkRequest + 209, // 348: openshell.v1.OpenShell.ApproveAllDraftChunks:input_type -> openshell.v1.ApproveAllDraftChunksRequest + 211, // 349: openshell.v1.OpenShell.EditDraftChunk:input_type -> openshell.v1.EditDraftChunkRequest + 213, // 350: openshell.v1.OpenShell.UndoDraftChunk:input_type -> openshell.v1.UndoDraftChunkRequest + 215, // 351: openshell.v1.OpenShell.ClearDraftChunks:input_type -> openshell.v1.ClearDraftChunksRequest + 217, // 352: openshell.v1.OpenShell.GetDraftHistory:input_type -> openshell.v1.GetDraftHistoryRequest + 17, // 353: openshell.v1.OpenShell.IssueSandboxToken:input_type -> openshell.v1.IssueSandboxTokenRequest + 19, // 354: openshell.v1.OpenShell.RefreshSandboxToken:input_type -> openshell.v1.RefreshSandboxTokenRequest + 220, // 355: openshell.v1.OpenShell.CreateWorkspace:input_type -> openshell.v1.CreateWorkspaceRequest + 222, // 356: openshell.v1.OpenShell.GetWorkspace:input_type -> openshell.v1.GetWorkspaceRequest + 224, // 357: openshell.v1.OpenShell.ListWorkspaces:input_type -> openshell.v1.ListWorkspacesRequest + 226, // 358: openshell.v1.OpenShell.DeleteWorkspace:input_type -> openshell.v1.DeleteWorkspaceRequest + 229, // 359: openshell.v1.OpenShell.AddWorkspaceMember:input_type -> openshell.v1.AddWorkspaceMemberRequest + 231, // 360: openshell.v1.OpenShell.RemoveWorkspaceMember:input_type -> openshell.v1.RemoveWorkspaceMemberRequest + 233, // 361: openshell.v1.OpenShell.ListWorkspaceMembers:input_type -> openshell.v1.ListWorkspaceMembersRequest + 22, // 362: openshell.v1.OpenShell.Health:output_type -> openshell.v1.HealthResponse + 24, // 363: openshell.v1.OpenShell.GetCurrentUser:output_type -> openshell.v1.GetCurrentUserResponse + 26, // 364: openshell.v1.OpenShell.GetGatewayInfo:output_type -> openshell.v1.GetGatewayInfoResponse + 67, // 365: openshell.v1.OpenShell.CreateSandbox:output_type -> openshell.v1.SandboxResponse + 58, // 366: openshell.v1.OpenShell.BeginRootfsTarStaging:output_type -> openshell.v1.BeginRootfsTarStagingResponse + 67, // 367: openshell.v1.OpenShell.GetSandbox:output_type -> openshell.v1.SandboxResponse + 68, // 368: openshell.v1.OpenShell.ListSandboxes:output_type -> openshell.v1.ListSandboxesResponse + 54, // 369: openshell.v1.OpenShell.CreateSandboxTemplate:output_type -> openshell.v1.SandboxTemplateResponse + 54, // 370: openshell.v1.OpenShell.GetSandboxTemplate:output_type -> openshell.v1.SandboxTemplateResponse + 55, // 371: openshell.v1.OpenShell.ListSandboxTemplates:output_type -> openshell.v1.ListSandboxTemplatesResponse + 56, // 372: openshell.v1.OpenShell.DeleteSandboxTemplate:output_type -> openshell.v1.DeleteSandboxTemplateResponse + 69, // 373: openshell.v1.OpenShell.ListSandboxProviders:output_type -> openshell.v1.ListSandboxProvidersResponse + 70, // 374: openshell.v1.OpenShell.AttachSandboxProvider:output_type -> openshell.v1.AttachSandboxProviderResponse + 71, // 375: openshell.v1.OpenShell.DetachSandboxProvider:output_type -> openshell.v1.DetachSandboxProviderResponse + 80, // 376: openshell.v1.OpenShell.GetSandboxProviderStatus:output_type -> openshell.v1.GetSandboxProviderStatusResponse + 83, // 377: openshell.v1.OpenShell.DeleteSandbox:output_type -> openshell.v1.DeleteSandboxResponse + 67, // 378: openshell.v1.OpenShell.StopSandbox:output_type -> openshell.v1.SandboxResponse + 67, // 379: openshell.v1.OpenShell.StartSandbox:output_type -> openshell.v1.SandboxResponse + 85, // 380: openshell.v1.OpenShell.CreateSshSession:output_type -> openshell.v1.CreateSshSessionResponse + 93, // 381: openshell.v1.OpenShell.ExposeService:output_type -> openshell.v1.ServiceEndpointResponse + 93, // 382: openshell.v1.OpenShell.GetService:output_type -> openshell.v1.ServiceEndpointResponse + 89, // 383: openshell.v1.OpenShell.ListServices:output_type -> openshell.v1.ListServicesResponse + 91, // 384: openshell.v1.OpenShell.DeleteService:output_type -> openshell.v1.DeleteServiceResponse + 95, // 385: openshell.v1.OpenShell.RevokeSshSession:output_type -> openshell.v1.RevokeSshSessionResponse + 100, // 386: openshell.v1.OpenShell.ExecSandbox:output_type -> openshell.v1.ExecSandboxEvent + 102, // 387: openshell.v1.OpenShell.ForwardTcp:output_type -> openshell.v1.TcpForwardFrame + 100, // 388: openshell.v1.OpenShell.ExecSandboxInteractive:output_type -> openshell.v1.ExecSandboxEvent + 115, // 389: openshell.v1.OpenShell.CreateProvider:output_type -> openshell.v1.ProviderResponse + 115, // 390: openshell.v1.OpenShell.GetProvider:output_type -> openshell.v1.ProviderResponse + 116, // 391: openshell.v1.OpenShell.ListProviders:output_type -> openshell.v1.ListProvidersResponse + 140, // 392: openshell.v1.OpenShell.ListProviderProfiles:output_type -> openshell.v1.ListProviderProfilesResponse + 139, // 393: openshell.v1.OpenShell.GetProviderProfile:output_type -> openshell.v1.ProviderProfileResponse + 142, // 394: openshell.v1.OpenShell.ImportProviderProfiles:output_type -> openshell.v1.ImportProviderProfilesResponse + 144, // 395: openshell.v1.OpenShell.UpdateProviderProfiles:output_type -> openshell.v1.UpdateProviderProfilesResponse + 146, // 396: openshell.v1.OpenShell.LintProviderProfiles:output_type -> openshell.v1.LintProviderProfilesResponse + 115, // 397: openshell.v1.OpenShell.UpdateProvider:output_type -> openshell.v1.ProviderResponse + 131, // 398: openshell.v1.OpenShell.GetProviderRefreshStatus:output_type -> openshell.v1.GetProviderRefreshStatusResponse + 133, // 399: openshell.v1.OpenShell.ConfigureProviderRefresh:output_type -> openshell.v1.ConfigureProviderRefreshResponse + 135, // 400: openshell.v1.OpenShell.RotateProviderCredential:output_type -> openshell.v1.RotateProviderCredentialResponse + 137, // 401: openshell.v1.OpenShell.DeleteProviderRefresh:output_type -> openshell.v1.DeleteProviderRefreshResponse + 147, // 402: openshell.v1.OpenShell.DeleteProvider:output_type -> openshell.v1.DeleteProviderResponse + 149, // 403: openshell.v1.OpenShell.DeleteProviderProfile:output_type -> openshell.v1.DeleteProviderProfileResponse + 278, // 404: openshell.v1.OpenShell.GetSandboxConfig:output_type -> openshell.sandbox.v1.GetSandboxConfigResponse + 279, // 405: openshell.v1.OpenShell.GetGatewayConfig:output_type -> openshell.sandbox.v1.GetGatewayConfigResponse + 164, // 406: openshell.v1.OpenShell.UpdateConfig:output_type -> openshell.v1.UpdateConfigResponse + 166, // 407: openshell.v1.OpenShell.GetSandboxPolicyStatus:output_type -> openshell.v1.GetSandboxPolicyStatusResponse + 168, // 408: openshell.v1.OpenShell.ListSandboxPolicies:output_type -> openshell.v1.ListSandboxPoliciesResponse + 170, // 409: openshell.v1.OpenShell.ReportPolicyStatus:output_type -> openshell.v1.ReportPolicyStatusResponse + 238, // 410: openshell.v1.OpenShell.ReportEndpointStatus:output_type -> openshell.v1.ReportEndpointStatusResponse + 82, // 411: openshell.v1.OpenShell.ReportProviderReadiness:output_type -> openshell.v1.ReportProviderReadinessResponse + 153, // 412: openshell.v1.OpenShell.GetSandboxProviderEnvironment:output_type -> openshell.v1.GetSandboxProviderEnvironmentResponse + 155, // 413: openshell.v1.OpenShell.ExchangeProviderSubjectToken:output_type -> openshell.v1.ExchangeProviderSubjectTokenResponse + 175, // 414: openshell.v1.OpenShell.GetSandboxLogs:output_type -> openshell.v1.GetSandboxLogsResponse + 174, // 415: openshell.v1.OpenShell.PushSandboxLogs:output_type -> openshell.v1.PushSandboxLogsResponse + 177, // 416: openshell.v1.OpenShell.ConnectSupervisor:output_type -> openshell.v1.GatewayMessage + 184, // 417: openshell.v1.OpenShell.ReportMainProcessExit:output_type -> openshell.v1.ReportMainProcessExitResponse + 186, // 418: openshell.v1.OpenShell.FinalizeMainProcessExit:output_type -> openshell.v1.FinalizeMainProcessExitResponse + 191, // 419: openshell.v1.OpenShell.RelayStream:output_type -> openshell.v1.RelayFrame + 107, // 420: openshell.v1.OpenShell.WatchSandbox:output_type -> openshell.v1.SandboxStreamEvent + 201, // 421: openshell.v1.OpenShell.SubmitPolicyAnalysis:output_type -> openshell.v1.SubmitPolicyAnalysisResponse + 203, // 422: openshell.v1.OpenShell.GetDraftPolicy:output_type -> openshell.v1.GetDraftPolicyResponse + 205, // 423: openshell.v1.OpenShell.ApproveDraftChunk:output_type -> openshell.v1.ApproveDraftChunkResponse + 207, // 424: openshell.v1.OpenShell.RejectDraftChunk:output_type -> openshell.v1.RejectDraftChunkResponse + 210, // 425: openshell.v1.OpenShell.ApproveAllDraftChunks:output_type -> openshell.v1.ApproveAllDraftChunksResponse + 212, // 426: openshell.v1.OpenShell.EditDraftChunk:output_type -> openshell.v1.EditDraftChunkResponse + 214, // 427: openshell.v1.OpenShell.UndoDraftChunk:output_type -> openshell.v1.UndoDraftChunkResponse + 216, // 428: openshell.v1.OpenShell.ClearDraftChunks:output_type -> openshell.v1.ClearDraftChunksResponse + 219, // 429: openshell.v1.OpenShell.GetDraftHistory:output_type -> openshell.v1.GetDraftHistoryResponse + 18, // 430: openshell.v1.OpenShell.IssueSandboxToken:output_type -> openshell.v1.IssueSandboxTokenResponse + 20, // 431: openshell.v1.OpenShell.RefreshSandboxToken:output_type -> openshell.v1.RefreshSandboxTokenResponse + 221, // 432: openshell.v1.OpenShell.CreateWorkspace:output_type -> openshell.v1.CreateWorkspaceResponse + 223, // 433: openshell.v1.OpenShell.GetWorkspace:output_type -> openshell.v1.GetWorkspaceResponse + 225, // 434: openshell.v1.OpenShell.ListWorkspaces:output_type -> openshell.v1.ListWorkspacesResponse + 227, // 435: openshell.v1.OpenShell.DeleteWorkspace:output_type -> openshell.v1.DeleteWorkspaceResponse + 230, // 436: openshell.v1.OpenShell.AddWorkspaceMember:output_type -> openshell.v1.AddWorkspaceMemberResponse + 232, // 437: openshell.v1.OpenShell.RemoveWorkspaceMember:output_type -> openshell.v1.RemoveWorkspaceMemberResponse + 234, // 438: openshell.v1.OpenShell.ListWorkspaceMembers:output_type -> openshell.v1.ListWorkspaceMembersResponse + 362, // [362:439] is the sub-list for method output_type + 285, // [285:362] is the sub-list for method input_type + 285, // [285:285] is the sub-list for extension type_name + 285, // [285:285] is the sub-list for extension extendee + 0, // [0:285] is the sub-list for field type_name } func init() { file_openshell_proto_init() } @@ -18871,40 +19063,40 @@ func file_openshell_proto_init() { if File_openshell_proto != nil { return } - file_openshell_proto_msgTypes[19].OneofWrappers = []any{} file_openshell_proto_msgTypes[20].OneofWrappers = []any{} - file_openshell_proto_msgTypes[28].OneofWrappers = []any{} - file_openshell_proto_msgTypes[55].OneofWrappers = []any{ + file_openshell_proto_msgTypes[21].OneofWrappers = []any{} + file_openshell_proto_msgTypes[29].OneofWrappers = []any{} + file_openshell_proto_msgTypes[56].OneofWrappers = []any{ (*ConfigSnapshotRevision_SandboxConfig)(nil), (*ConfigSnapshotRevision_ProviderEnvironment)(nil), (*ConfigSnapshotRevision_ProviderTarget)(nil), } - file_openshell_proto_msgTypes[82].OneofWrappers = []any{ + file_openshell_proto_msgTypes[83].OneofWrappers = []any{ (*ExecSandboxEvent_Stdout)(nil), (*ExecSandboxEvent_Stderr)(nil), (*ExecSandboxEvent_Exit)(nil), } - file_openshell_proto_msgTypes[83].OneofWrappers = []any{ + file_openshell_proto_msgTypes[84].OneofWrappers = []any{ (*TcpForwardInit_Ssh)(nil), (*TcpForwardInit_Tcp)(nil), } - file_openshell_proto_msgTypes[84].OneofWrappers = []any{ + file_openshell_proto_msgTypes[85].OneofWrappers = []any{ (*TcpForwardFrame_Init)(nil), (*TcpForwardFrame_Data)(nil), } - file_openshell_proto_msgTypes[85].OneofWrappers = []any{ + file_openshell_proto_msgTypes[86].OneofWrappers = []any{ (*ExecSandboxInput_Start)(nil), (*ExecSandboxInput_Stdin)(nil), (*ExecSandboxInput_Resize)(nil), } - file_openshell_proto_msgTypes[89].OneofWrappers = []any{ + file_openshell_proto_msgTypes[90].OneofWrappers = []any{ (*SandboxStreamEvent_Sandbox)(nil), (*SandboxStreamEvent_Log)(nil), (*SandboxStreamEvent_Event)(nil), (*SandboxStreamEvent_Warning)(nil), (*SandboxStreamEvent_DraftPolicyUpdate)(nil), } - file_openshell_proto_msgTypes[139].OneofWrappers = []any{ + file_openshell_proto_msgTypes[140].OneofWrappers = []any{ (*PolicyMergeOperation_AddRule)(nil), (*PolicyMergeOperation_RemoveEndpoint)(nil), (*PolicyMergeOperation_RemoveRule)(nil), @@ -18912,24 +19104,24 @@ func file_openshell_proto_init() { (*PolicyMergeOperation_AddAllowRules)(nil), (*PolicyMergeOperation_RemoveBinary)(nil), } - file_openshell_proto_msgTypes[158].OneofWrappers = []any{ + file_openshell_proto_msgTypes[159].OneofWrappers = []any{ (*SupervisorMessage_Hello)(nil), (*SupervisorMessage_Heartbeat)(nil), (*SupervisorMessage_RelayOpenResult)(nil), (*SupervisorMessage_RelayClose)(nil), } - file_openshell_proto_msgTypes[159].OneofWrappers = []any{ + file_openshell_proto_msgTypes[160].OneofWrappers = []any{ (*GatewayMessage_SessionAccepted)(nil), (*GatewayMessage_SessionRejected)(nil), (*GatewayMessage_Heartbeat)(nil), (*GatewayMessage_RelayOpen)(nil), (*GatewayMessage_RelayClose)(nil), } - file_openshell_proto_msgTypes[169].OneofWrappers = []any{ + file_openshell_proto_msgTypes[170].OneofWrappers = []any{ (*RelayOpen_Ssh)(nil), (*RelayOpen_Tcp)(nil), } - file_openshell_proto_msgTypes[173].OneofWrappers = []any{ + file_openshell_proto_msgTypes[174].OneofWrappers = []any{ (*RelayFrame_Init)(nil), (*RelayFrame_Data)(nil), } @@ -18938,8 +19130,8 @@ func file_openshell_proto_init() { File: protoimpl.DescBuilder{ GoPackagePath: reflect.TypeOf(x{}).PkgPath(), RawDescriptor: unsafe.Slice(unsafe.StringData(file_openshell_proto_rawDesc), len(file_openshell_proto_rawDesc)), - NumEnums: 16, - NumMessages: 243, + NumEnums: 17, + NumMessages: 244, NumExtensions: 0, NumServices: 1, }, diff --git a/skills/debug-openshell-cluster/SKILL.md b/skills/debug-openshell-cluster/SKILL.md index 3f6da5ddcc..57c0933938 100644 --- a/skills/debug-openshell-cluster/SKILL.md +++ b/skills/debug-openshell-cluster/SKILL.md @@ -117,7 +117,7 @@ injects it only into the selected local driver. TLS-enabled Docker, Podman, and VM drivers fail startup when neither those paths nor the package-managed local bundle is available; Kubernetes projects its bundle through a Secret. -Custom names use `[openshell.drivers.].socket_path`. A launch-time `--compute-driver-socket` override may also use `docker`, `podman`, `kubernetes`, or `vm`; the endpoint then takes precedence over built-in construction. First-party standalone drivers require the socket parent directory to be owned by the driver's effective UID, force its mode to `0700`, create the socket with mode `0600`, and accept only peers with that same UID. Check the parent and socket separately with `stat`; a gateway running under a different UID cannot connect even when filesystem permissions or group membership would otherwise allow it. Operator-supplied drivers must provide equivalent access control appropriate to their implementation. Check gateway logs for connection errors, `GetCapabilities` failures, or an unexpected advertised driver name. The advertised name is diagnostic metadata; negotiated features control optional behavior. The gateway does not create or supervise operator-supplied driver processes or sockets. +Custom names use `[openshell.drivers.].socket_path`. A launch-time `--compute-driver-socket` override may also use `docker`, `podman`, `kubernetes`, or `vm`; the endpoint then takes precedence over built-in construction. First-party standalone drivers require the socket parent directory to be owned by the driver's effective UID, force its mode to `0700`, create the socket with mode `0600`, and accept only peers with that same UID. Check the parent and socket separately with `stat`; a gateway running under a different UID cannot connect even when filesystem permissions or group membership would otherwise allow it. Operator-supplied drivers must provide equivalent access control appropriate to their implementation. Check gateway logs for connection errors, `GetCapabilities` failures, missing peer metadata, protocol-major mismatch, unmet required capabilities, or an unexpected advertised driver name. `openshell gateway info` reports successful startup negotiations. The advertised name is diagnostic metadata; negotiated features control optional behavior. The gateway does not create or supervise operator-supplied driver processes or sockets. For a configured Vault credential driver, inspect its endpoint and trust bundle before debugging provider resolution. Non-loopback addresses must use HTTPS, @@ -148,7 +148,7 @@ journalctl -u --no-pager --lines=200 journalctl -u openshell-gateway --no-pager --lines=200 ``` -The gateway calls each interceptor's `Describe` RPC and validates its manifest at startup. Check for unreachable endpoints, invalid RPC/phase bindings, strict `allowlist` or `exact` mismatches, and `post_commit` bindings that resolve to `fail_closed`. If gateway JWT signing is enabled, authenticated network interceptors require HTTPS and a valid bearer token; check the private CA path, endpoint hostname, expected audience, issuer, `kid`, and interceptor logs for token rejection. `allow_insecure_transport = true` explicitly preserves unauthenticated plaintext behavior. If `provider_profile_sources` names an interceptor, that interceptor must advertise provider-profile capability and return a valid, duplicate-free catalog. A selected interceptor-only source is authoritative; include `builtin` or `user` sources explicitly when composition is intended. +The gateway calls each interceptor's `Describe` RPC and validates its manifest at startup. Check for missing peer metadata, protocol-major mismatch, unmet required capabilities, unreachable endpoints, invalid RPC/phase bindings, strict `allowlist` or `exact` mismatches, and `post_commit` bindings that resolve to `fail_closed`. If gateway JWT signing is enabled, authenticated network interceptors require HTTPS and a valid bearer token; check the private CA path, endpoint hostname, expected audience, issuer, `kid`, and interceptor logs for token rejection. `allow_insecure_transport = true` explicitly preserves unauthenticated plaintext behavior. If `provider_profile_sources` names an interceptor, that interceptor must advertise provider-profile capability and return a valid, duplicate-free catalog. A selected interceptor-only source is authoritative; include `builtin` or `user` sources explicitly when composition is intended. If the deployment uses supervisor middleware, follow the [supervisor middleware troubleshooting reference](references/supervisor-middleware.md) @@ -760,6 +760,7 @@ credential failures. | Gateway fails before serving health after enabling an interceptor | Interceptor endpoint unavailable or manifest/binding validation failed | Gateway and interceptor logs; interceptor socket; `binding_policy`, phases, and failure policy | | Authenticated interceptor rejects gateway calls | Private CA or hostname mismatch, expected audience or issuer mismatch, stale/unknown `kid`, or malformed extension token | `tls_ca_cert_path`, registration `audience`, service verifier config and logs; fetch well-known metadata only through the already-trusted gateway TLS endpoint | | Provider profiles disappear after enabling an interceptor catalog | `provider_profile_sources` selected only an authoritative interceptor or returned invalid/duplicate IDs | Inspect source list and interceptor `Describe`/catalog logs; include `builtin` and `user` when intended | +| Gateway rejects an extension before serving health | Missing peer metadata, incompatible protocol major, or unmet `required_capabilities` | Gateway and extension startup logs; compare `PeerMetadata`; upgrade the extension before the gateway | | Policy mutation returns `FAILED_PRECONDITION` for endpoint ambiguity | Equally specific effective endpoint selectors disagree on connection or request-processing metadata | CLI error, base and provider-composed policy, affected profile attachments; confirm no new revision was stored | | Supervisor enters policy quarantine | A runtime candidate failed validation while `policy_validation_failure_mode = "fail_closed"` | Sandbox OCSF config/finding events, validation rationale, active generation, `previous_policy_active` | | Custom compute driver is unavailable | Driver process/socket missing, inaccessible, or selected name does not match its endpoint/config key | Socket ownership/mode, driver service logs, gateway `GetCapabilities` logs | diff --git a/skills/debug-openshell-cluster/references/supervisor-middleware.md b/skills/debug-openshell-cluster/references/supervisor-middleware.md index a1d7524662..73aacbbbd5 100644 --- a/skills/debug-openshell-cluster/references/supervisor-middleware.md +++ b/skills/debug-openshell-cluster/references/supervisor-middleware.md @@ -20,7 +20,7 @@ openshell logs --tail --source sandbox ## Startup and authentication -The middleware service must start before the gateway and be reachable from both the gateway and sandbox supervisors. Gateway startup fails if `Describe` is unavailable, a manifest exposes duplicate operation/phase bindings, the registration claims the reserved `openshell/` namespace, or payload and timeout limits are invalid. Supported V1 bindings are `HTTP_REQUEST/PRE_CREDENTIALS`, `HTTP_RESPONSE/PRE_RETURN`, and `WEBSOCKET_MESSAGE/PRE_CREDENTIALS`. +The middleware service must start before the gateway and be reachable from both the gateway and sandbox supervisors. Gateway startup fails if `Describe` is unavailable, peer metadata is missing, the protocol major is incompatible, a required capability is absent, a manifest exposes duplicate operation/phase bindings, the registration claims the reserved `openshell/` namespace, or payload and timeout limits are invalid. Current services receive `MiddlewareDescribeRequest` instead of an empty request; regenerate bindings when upgrading a legacy service. Supported V1 bindings are `HTTP_REQUEST/PRE_CREDENTIALS`, `HTTP_RESPONSE/PRE_RETURN`, and `WEBSOCKET_MESSAGE/PRE_CREDENTIALS`. When gateway JWT signing is disabled, supervisors preserve the legacy unauthenticated connector and do not request extension credentials. When signing is enabled, credential acquisition and verification failures are fail closed: check HTTPS trust and hostname validation, audience and issuer agreement, the token `kid`, gateway `RefreshSandboxToken` errors, and middleware logs. Changing a registration requires a gateway restart. A policy update can also fail before persistence if the selected implementation rejects its `network_middlewares` config. @@ -44,6 +44,7 @@ WebSocket message sequences are allocated session-wide; each stage receives a st |---|---|---| | Authenticated middleware rejects gateway calls | Private CA or hostname mismatch, expected audience or issuer mismatch, stale/unknown `kid`, or malformed extension token | `tls_ca_cert_path`, registration `audience`, service verifier config and logs; fetch well-known metadata only through the already-trusted gateway TLS endpoint | | Gateway fails after registering supervisor middleware | Service unavailable, invalid manifest, duplicate binding, reserved name, or invalid payload/timeout limit | Middleware service and gateway logs; `[[openshell.supervisor.middleware]]`; `Describe` response | +| Gateway rejects middleware before serving health | Missing peer metadata, incompatible protocol major, or unmet `required_capabilities` | Gateway and middleware startup logs; compare `PeerMetadata`; upgrade the middleware before the gateway | | Policy update rejects `network_middlewares` | Unknown middleware name, implementation-owned config invalid, duplicate order, broad/invalid host selector, or fail-closed coverage of `tls: skip` | Policy error, gateway logs, middleware `ValidateConfig`, selector and order fields | | HTTP request returns `middleware_failed` or `middleware_denied`, or WebSocket closes with `1008` | Selected stage failed or explicitly denied admitted traffic | Sandbox OCSF logs; policy-local middleware config; service availability; binding operation; `on_error` | | HTTP response becomes canonical `403 middleware_denied`, `502 response_delivery_failed`, or closes mid-body | Response middleware blocked, failed before commitment, or stopped delivery after commitment | Sandbox OCSF response middleware events; `HTTP_RESPONSE/PRE_RETURN` binding; `on_error`; `whole_body_accumulation_timeout`; service stream lifecycle | diff --git a/skills/openshell-cli/SKILL.md b/skills/openshell-cli/SKILL.md index f449903d2b..49f0c2f193 100644 --- a/skills/openshell-cli/SKILL.md +++ b/skills/openshell-cli/SKILL.md @@ -749,6 +749,8 @@ openshell gateway info --name production openshell status ``` +`openshell gateway info` reports the immutable startup snapshot for compute drivers, credential drivers, gateway interceptors, and supervisor middleware. Use each entry's protocol version, implementation version, supported capabilities, and gateway requirements when diagnosing extension skew; implementation versions do not identify underlying Docker, Kubernetes, or credential backends. + Register or remove gateways: ```bash From 994e36df63b99590e420bda33c52e5eae5c31877 Mon Sep 17 00:00:00 2001 From: Seth Jennings Date: Thu, 17 Sep 2026 14:03:55 -0500 Subject: [PATCH 2/5] fix(credentials): fail fast on negotiation errors Signed-off-by: Seth Jennings --- crates/openshell-server/src/credentials.rs | 91 +++++++++++++++++++--- 1 file changed, 79 insertions(+), 12 deletions(-) diff --git a/crates/openshell-server/src/credentials.rs b/crates/openshell-server/src/credentials.rs index 0d853c3126..29a57a1cdb 100644 --- a/crates/openshell-server/src/credentials.rs +++ b/crates/openshell-server/src/credentials.rs @@ -1531,7 +1531,9 @@ async fn connect_uds_driver( spawn_uds_driver(driver_name, config, socket_path).await } else { let (channel, negotiated_extension) = - connect_ready_credential_driver(driver_name, socket_path).await?; + connect_ready_credential_driver(driver_name, socket_path) + .await + .map_err(CredentialDriverReadinessError::into_error)?; Ok(BuiltCredentialDriver { driver: Arc::new(RemoteCredentialDriver::new(channel)), process: None, @@ -1655,6 +1657,24 @@ async fn wait_for_launched_credential_driver( child: &mut tokio::process::Child, timeout: Duration, ) -> CoreResult<(Channel, NegotiatedExtension)> { + wait_for_launched_credential_driver_with(driver_name, socket_path, child, timeout, || { + connect_ready_credential_driver(driver_name, socket_path) + }) + .await +} + +#[cfg(unix)] +async fn wait_for_launched_credential_driver_with( + driver_name: &str, + socket_path: &Path, + child: &mut tokio::process::Child, + timeout: Duration, + mut connect: F, +) -> CoreResult<(Channel, NegotiatedExtension)> +where + F: FnMut() -> Fut, + Fut: Future>, +{ let deadline = Instant::now() + timeout; let mut last_error: Option = None; @@ -1679,14 +1699,12 @@ async fn wait_for_launched_credential_driver( ))); } - match tokio::time::timeout( - remaining, - connect_ready_credential_driver(driver_name, socket_path), - ) - .await - { + match tokio::time::timeout(remaining, connect()).await { Ok(Ok(connected)) => return Ok(connected), - Ok(Err(err)) => last_error = Some(err.to_string()), + Ok(Err(CredentialDriverReadinessError::Retryable(err))) => { + last_error = Some(err.to_string()); + } + Ok(Err(CredentialDriverReadinessError::Terminal(err))) => return Err(err), Err(_) => { return Err(Error::execution(format!( "timed out waiting for credential driver '{driver_name}' to respond to GetCapabilities" @@ -1706,12 +1724,30 @@ async fn wait_for_launched_credential_driver( } } +#[cfg(unix)] +#[derive(Debug)] +enum CredentialDriverReadinessError { + Retryable(Error), + Terminal(Error), +} + +#[cfg(unix)] +impl CredentialDriverReadinessError { + fn into_error(self) -> Error { + match self { + Self::Retryable(error) | Self::Terminal(error) => error, + } + } +} + #[cfg(unix)] async fn connect_ready_credential_driver( driver_name: &str, socket_path: &Path, -) -> CoreResult<(Channel, NegotiatedExtension)> { - let channel = connect_credential_driver_socket(driver_name, socket_path).await?; +) -> Result<(Channel, NegotiatedExtension), CredentialDriverReadinessError> { + let channel = connect_credential_driver_socket(driver_name, socket_path) + .await + .map_err(CredentialDriverReadinessError::Retryable)?; let mut client = CredentialDriverClient::new(channel.clone()); let gateway = gateway_metadata(ExtensionFamily::Credentials); let mut request = Request::new(GetCredentialDriverCapabilitiesRequest { @@ -1724,14 +1760,15 @@ async fn connect_ready_credential_driver( timeout, client.get_capabilities(request), ) - .await?; + .await + .map_err(CredentialDriverReadinessError::Retryable)?; let negotiated_extension = negotiate( ExtensionFamily::Credentials, driver_name, &gateway, capabilities.extension, ) - .map_err(|error| Error::config(error.to_string()))?; + .map_err(|error| CredentialDriverReadinessError::Terminal(Error::config(error.to_string())))?; Ok((channel, negotiated_extension)) } @@ -2527,6 +2564,36 @@ socket_path = {socket_path_toml} assert!(err.to_string().contains("GetCapabilities timed out")); } + #[cfg(unix)] + #[tokio::test] + async fn launched_driver_protocol_incompatibility_is_terminal() { + let mut child = Command::new("sleep") + .arg("30") + .kill_on_drop(true) + .spawn() + .unwrap(); + let started = Instant::now(); + + let err = wait_for_launched_credential_driver_with( + "enterprise-secrets", + Path::new("/unused-test-socket"), + &mut child, + Duration::from_secs(30), + || { + std::future::ready(Err(CredentialDriverReadinessError::Terminal( + Error::config( + "credentials extension 'enterprise-secrets' uses unsupported protocol 2.0; gateway supports 1.0", + ), + ))) + }, + ) + .await + .unwrap_err(); + + assert!(err.to_string().contains("unsupported protocol 2.0")); + assert!(started.elapsed() < Duration::from_secs(1)); + } + #[test] fn parse_driver_table_preserves_backend_config_without_transport_fields() { let parsed = parse_driver_table( From dce52b9b06a112b31e685ecf9a6a55f2d2a88ee2 Mon Sep 17 00:00:00 2001 From: Seth Jennings Date: Thu, 17 Sep 2026 14:10:16 -0500 Subject: [PATCH 3/5] fix(extensions): validate gateway handshake metadata Signed-off-by: Seth Jennings --- architecture/compute-runtimes.md | 3 +- architecture/gateway.md | 11 +++-- .../openshell-core/src/extension_protocol.rs | 38 +++++++++++++++ crates/openshell-driver-docker/src/lib.rs | 12 ++++- crates/openshell-driver-docker/src/tests.rs | 36 +++++++++++++-- .../src/lib.rs | 14 ++++-- .../openshell-driver-kubernetes/src/grpc.rs | 21 ++++++--- crates/openshell-driver-mxc/src/grpc.rs | 12 ++++- crates/openshell-driver-podman/src/grpc.rs | 30 +++++++++--- crates/openshell-driver-vault/src/lib.rs | 46 +++++++++++++++++-- crates/openshell-driver-vm/src/driver.rs | 24 ++++++++-- crates/openshell-gateway/src/vm.rs | 6 ++- docs/extensibility/extension-negotiation.mdx | 4 +- docs/extensibility/supervisor-middleware.mdx | 2 +- docs/reference/gateway-config.mdx | 4 +- examples/governance-interceptor/src/main.rs | 12 ++++- examples/governance-interceptor/src/tests.rs | 21 +++++++++ .../src/main.rs | 37 +++++++++++++-- skills/debug-openshell-cluster/SKILL.md | 2 +- .../references/supervisor-middleware.md | 2 +- 20 files changed, 286 insertions(+), 51 deletions(-) diff --git a/architecture/compute-runtimes.md b/architecture/compute-runtimes.md index 1dab57f92d..9ebcb9a6e1 100644 --- a/architecture/compute-runtimes.md +++ b/architecture/compute-runtimes.md @@ -119,7 +119,8 @@ image used by the gateway. GPU availability stays driver-local and is validated when a sandbox create request asks for GPU resources. The gateway sends its common extension peer metadata with the startup capability -request and rejects a driver whose protocol major or capability requirements are +request. The driver validates that metadata before responding, and the gateway +rejects a driver whose protocol major or capability requirements are incompatible. It records the negotiated protocol, implementation identity and version, capability sets, and typed resource support once. Elevated gateway info reports that immutable snapshot instead of re-querying drivers on each request. diff --git a/architecture/gateway.md b/architecture/gateway.md index ef6dd1ec04..3b3eacb2e7 100644 --- a/architecture/gateway.md +++ b/architecture/gateway.md @@ -736,11 +736,12 @@ placeholder generations from an earlier provider credential snapshot. All gateway-owned extension registries negotiate the same peer metadata envelope before accepting work. Compute drivers, credential drivers, gateway interceptors, -and supervisor middleware retain their typed family manifests, while the shared -validator enforces protocol-major compatibility and mutual required-capability -sets. The gateway aggregates immutable, non-secret startup snapshots for the -protected gateway-info API; it does not publish transport, authentication, or -backend configuration. +and supervisor middleware retain their typed family manifests. Both the gateway +and extension run the shared validator against the startup exchange, enforcing +protocol-major compatibility and mutual required-capability sets before either +peer accepts the other. The gateway aggregates immutable, non-secret startup +snapshots for the protected gateway-info API; it does not publish transport, +authentication, or backend configuration. Static credential delivery is capability-negotiated and endpoint-bound. The gateway classifies each returned environment entry as either a credential or diff --git a/crates/openshell-core/src/extension_protocol.rs b/crates/openshell-core/src/extension_protocol.rs index 2886b223dc..9b5a8f2a97 100644 --- a/crates/openshell-core/src/extension_protocol.rs +++ b/crates/openshell-core/src/extension_protocol.rs @@ -60,6 +60,10 @@ pub enum NegotiationError { "{family} extension '{name}' did not provide protocol metadata; upgrade the extension to a version that supports OpenShell extension negotiation" )] MissingMetadata { family: &'static str, name: String }, + #[error( + "gateway did not provide protocol metadata to {family} extension '{name}'; upgrade the gateway and extension together" + )] + MissingGatewayMetadata { family: &'static str, name: String }, #[error("{family} extension '{name}' did not provide a protocol version")] MissingProtocolVersion { family: &'static str, name: String }, #[error( @@ -242,6 +246,20 @@ pub fn negotiate( }) } +pub fn validate_gateway_metadata( + family: ExtensionFamily, + extension_name: impl Into, + extension: Option<&PeerMetadata>, + gateway: Option, +) -> Result<(), NegotiationError> { + let extension_name = extension_name.into(); + let gateway = gateway.ok_or_else(|| NegotiationError::MissingGatewayMetadata { + family: family.as_str(), + name: extension_name.clone(), + })?; + negotiate(family, extension_name, &gateway, extension.cloned()).map(drop) +} + fn validate_text( family: &'static str, name: &str, @@ -449,4 +467,24 @@ mod tests { Err(NegotiationError::InvalidMetadata { .. }) )); } + + #[test] + fn extension_side_rejects_missing_and_incompatible_gateway_metadata() { + let (mut gateway, extension) = compatible(); + assert!(matches!( + validate_gateway_metadata(ExtensionFamily::Compute, "example", Some(&extension), None,), + Err(NegotiationError::MissingGatewayMetadata { .. }) + )); + + gateway.protocol_version.as_mut().unwrap().major = 2; + assert!(matches!( + validate_gateway_metadata( + ExtensionFamily::Compute, + "example", + Some(&extension), + Some(gateway), + ), + Err(NegotiationError::IncompatibleProtocol { .. }) + )); + } } diff --git a/crates/openshell-driver-docker/src/lib.rs b/crates/openshell-driver-docker/src/lib.rs index c741f5f519..5949dcf891 100644 --- a/crates/openshell-driver-docker/src/lib.rs +++ b/crates/openshell-driver-docker/src/lib.rs @@ -3063,9 +3063,17 @@ impl ComputeDriver for DockerComputeDriver { async fn get_capabilities( &self, - _request: Request, + request: Request, ) -> Result, Status> { - Ok(Response::new(self.capabilities())) + let capabilities = self.capabilities(); + openshell_core::extension_protocol::validate_gateway_metadata( + openshell_core::extension_protocol::ExtensionFamily::Compute, + "docker", + capabilities.extension.as_ref(), + request.into_inner().gateway, + ) + .map_err(|error| Status::failed_precondition(error.to_string()))?; + Ok(Response::new(capabilities)) } async fn get_gateway_listener_requirements( diff --git a/crates/openshell-driver-docker/src/tests.rs b/crates/openshell-driver-docker/src/tests.rs index 239f9bf7b6..454a2b3649 100644 --- a/crates/openshell-driver-docker/src/tests.rs +++ b/crates/openshell-driver-docker/src/tests.rs @@ -235,6 +235,23 @@ fn capabilities_report_static_resource_support() { assert!(gpu.count_selection_supported); } +#[tokio::test] +async fn capabilities_reject_missing_gateway_metadata() { + let driver = test_driver_with_config(runtime_config()); + + let error = + ComputeDriver::get_capabilities(&driver, Request::new(GetCapabilitiesRequest::default())) + .await + .unwrap_err(); + + assert_eq!(error.code(), tonic::Code::FailedPrecondition); + assert!( + error + .message() + .contains("gateway did not provide protocol metadata") + ); +} + type TestDriverClient = openshell_core::proto::compute::v1::compute_driver_client::ComputeDriverClient< tonic::transport::Channel, @@ -297,7 +314,11 @@ async fn tracing_standalone_rpc_layer_propagates_context_and_records_errors() { let (mut client, shutdown, server) = standalone_traced_client().await; client - .get_capabilities(request_with_traceparent(GetCapabilitiesRequest::default())) + .get_capabilities(request_with_traceparent(GetCapabilitiesRequest { + gateway: Some(openshell_core::extension_protocol::gateway_metadata( + openshell_core::extension_protocol::ExtensionFamily::Compute, + )), + })) .await .expect("capabilities should succeed"); client @@ -450,9 +471,16 @@ async fn tracing_in_process_service_preserves_the_driver_rpc_server_boundary() { otel.name = "openshell.compute.v1.ComputeDriver/GetCapabilities", otel.kind = "client" ); - ComputeDriver::get_capabilities(&service, Request::new(GetCapabilitiesRequest::default())) - .instrument(gateway_span) - .await?; + ComputeDriver::get_capabilities( + &service, + Request::new(GetCapabilitiesRequest { + gateway: Some(openshell_core::extension_protocol::gateway_metadata( + openshell_core::extension_protocol::ExtensionFamily::Compute, + )), + }), + ) + .instrument(gateway_span) + .await?; let unrelated = tracing::info_span!( target: "openshell_driver_kubernetes::compute", diff --git a/crates/openshell-driver-kubernetes-secrets/src/lib.rs b/crates/openshell-driver-kubernetes-secrets/src/lib.rs index 669b7ac514..365c9a6797 100644 --- a/crates/openshell-driver-kubernetes-secrets/src/lib.rs +++ b/crates/openshell-driver-kubernetes-secrets/src/lib.rs @@ -461,9 +461,9 @@ impl Clone for KubernetesSecretsCredentialDriver { impl CredentialDriver for CredentialDriverService { async fn get_capabilities( &self, - _request: Request, + request: Request, ) -> Result, Status> { - Ok(Response::new(GetCredentialDriverCapabilitiesResponse { + let capabilities = GetCredentialDriverCapabilitiesResponse { driver_name: KubernetesSecretsCredentialDriver::NAME.to_string(), driver_version: VERSION.to_string(), backend_kind: KubernetesSecretsCredentialDriver::NAME.to_string(), @@ -475,7 +475,15 @@ impl CredentialDriver for CredentialDriverService { VERSION, [], )), - })) + }; + openshell_core::extension_protocol::validate_gateway_metadata( + openshell_core::extension_protocol::ExtensionFamily::Credentials, + KubernetesSecretsCredentialDriver::NAME, + capabilities.extension.as_ref(), + request.into_inner().gateway, + ) + .map_err(|error| Status::failed_precondition(error.to_string()))?; + Ok(Response::new(capabilities)) } async fn store_credential( diff --git a/crates/openshell-driver-kubernetes/src/grpc.rs b/crates/openshell-driver-kubernetes/src/grpc.rs index 3f077ca1ab..cbe5469727 100644 --- a/crates/openshell-driver-kubernetes/src/grpc.rs +++ b/crates/openshell-driver-kubernetes/src/grpc.rs @@ -71,14 +71,19 @@ impl ComputeDriver for ComputeDriverService { async fn get_capabilities( &self, - _request: Request, + request: Request, ) -> Result, Status> { self.rpc_tracer .trace(openshell_otel::rpc::GET_CAPABILITIES, async { - self.driver - .capabilities() - .map(Response::new) - .map_err(Status::internal) + let capabilities = self.driver.capabilities().map_err(Status::internal)?; + openshell_core::extension_protocol::validate_gateway_metadata( + openshell_core::extension_protocol::ExtensionFamily::Compute, + "kubernetes", + capabilities.extension.as_ref(), + request.into_inner().gateway, + ) + .map_err(|error| Status::failed_precondition(error.to_string()))?; + Ok(Response::new(capabilities)) }) .await } @@ -378,7 +383,11 @@ mod tests { ); ComputeDriver::get_capabilities( &service, - Request::new(GetCapabilitiesRequest::default()), + Request::new(GetCapabilitiesRequest { + gateway: Some(openshell_core::extension_protocol::gateway_metadata( + openshell_core::extension_protocol::ExtensionFamily::Compute, + )), + }), ) .instrument(gateway_span) .await?; diff --git a/crates/openshell-driver-mxc/src/grpc.rs b/crates/openshell-driver-mxc/src/grpc.rs index 9a166057ef..c81b68c9bb 100644 --- a/crates/openshell-driver-mxc/src/grpc.rs +++ b/crates/openshell-driver-mxc/src/grpc.rs @@ -37,9 +37,17 @@ impl ComputeDriverService { impl ComputeDriver for ComputeDriverService { async fn get_capabilities( &self, - _request: Request, + request: Request, ) -> Result, Status> { - Ok(Response::new(self.backend.capabilities())) + let capabilities = self.backend.capabilities(); + openshell_core::extension_protocol::validate_gateway_metadata( + openshell_core::extension_protocol::ExtensionFamily::Compute, + "mxc", + capabilities.extension.as_ref(), + request.into_inner().gateway, + ) + .map_err(|error| Status::failed_precondition(error.to_string()))?; + Ok(Response::new(capabilities)) } async fn authenticate_sandbox( diff --git a/crates/openshell-driver-podman/src/grpc.rs b/crates/openshell-driver-podman/src/grpc.rs index 7c7e6f8f91..d5a6ecce41 100644 --- a/crates/openshell-driver-podman/src/grpc.rs +++ b/crates/openshell-driver-podman/src/grpc.rs @@ -67,14 +67,19 @@ impl ComputeDriver for ComputeDriverService { async fn get_capabilities( &self, - _request: Request, + request: Request, ) -> Result, Status> { self.rpc_tracer .trace(openshell_otel::rpc::GET_CAPABILITIES, async { - self.driver - .capabilities() - .map(Response::new) - .map_err(Status::from) + let capabilities = self.driver.capabilities().map_err(Status::from)?; + openshell_core::extension_protocol::validate_gateway_metadata( + openshell_core::extension_protocol::ExtensionFamily::Compute, + "podman", + capabilities.extension.as_ref(), + request.into_inner().gateway, + ) + .map_err(|error| Status::failed_precondition(error.to_string()))?; + Ok(Response::new(capabilities)) }) .await } @@ -378,7 +383,14 @@ mod tests { async { let gateway_span = tracing::info_span!(target: "openshell_server::compute", "driver", otel.name = "openshell.compute.v1.ComputeDriver/GetCapabilities", otel.kind = "client"); - ComputeDriver::get_capabilities(&service, Request::new(GetCapabilitiesRequest::default())) + ComputeDriver::get_capabilities( + &service, + Request::new(GetCapabilitiesRequest { + gateway: Some(openshell_core::extension_protocol::gateway_metadata( + openshell_core::extension_protocol::ExtensionFamily::Compute, + )), + }), + ) .instrument(gateway_span) .await } @@ -441,7 +453,11 @@ mod tests { let (mut client, shutdown, server) = standalone_traced_client().await; client - .get_capabilities(request_with_traceparent(GetCapabilitiesRequest::default())) + .get_capabilities(request_with_traceparent(GetCapabilitiesRequest { + gateway: Some(openshell_core::extension_protocol::gateway_metadata( + openshell_core::extension_protocol::ExtensionFamily::Compute, + )), + })) .await .expect("capabilities should succeed"); client diff --git a/crates/openshell-driver-vault/src/lib.rs b/crates/openshell-driver-vault/src/lib.rs index 528cb59d60..94c1f65e54 100644 --- a/crates/openshell-driver-vault/src/lib.rs +++ b/crates/openshell-driver-vault/src/lib.rs @@ -501,9 +501,9 @@ impl Clone for VaultCredentialDriver { impl CredentialDriver for CredentialDriverService { async fn get_capabilities( &self, - _request: Request, + request: Request, ) -> Result, Status> { - Ok(Response::new(GetCredentialDriverCapabilitiesResponse { + let capabilities = GetCredentialDriverCapabilitiesResponse { driver_name: VaultCredentialDriver::NAME.to_string(), driver_version: VERSION.to_string(), backend_kind: VaultCredentialDriver::NAME.to_string(), @@ -515,7 +515,15 @@ impl CredentialDriver for CredentialDriverService { VERSION, [], )), - })) + }; + openshell_core::extension_protocol::validate_gateway_metadata( + openshell_core::extension_protocol::ExtensionFamily::Credentials, + VaultCredentialDriver::NAME, + capabilities.extension.as_ref(), + request.into_inner().gateway, + ) + .map_err(|error| Status::failed_precondition(error.to_string()))?; + Ok(Response::new(capabilities)) } async fn store_credential( @@ -1010,6 +1018,38 @@ mod tests { file } + #[tokio::test] + async fn capabilities_reject_missing_gateway_metadata() { + let token = token_file("dev-token"); + let driver = VaultCredentialDriver::from_config(&table(&[ + ( + "address", + toml::Value::String("http://127.0.0.1:8200".to_string()), + ), + ("auth_method", toml::Value::String("token_file".to_string())), + ( + "token_path", + toml::Value::String(token.path().display().to_string()), + ), + ])) + .unwrap(); + let service = CredentialDriverService::new(driver); + + let error = CredentialDriver::get_capabilities( + &service, + Request::new(GetCredentialDriverCapabilitiesRequest::default()), + ) + .await + .unwrap_err(); + + assert_eq!(error.code(), Code::FailedPrecondition); + assert!( + error + .message() + .contains("gateway did not provide protocol metadata") + ); + } + fn test_ca() -> (rcgen::Certificate, KeyPair) { let mut params = CertificateParams::new(Vec::::new()).unwrap(); params.is_ca = IsCa::Ca(rcgen::BasicConstraints::Unconstrained); diff --git a/crates/openshell-driver-vm/src/driver.rs b/crates/openshell-driver-vm/src/driver.rs index b88a47cfc8..4eb5df74e6 100644 --- a/crates/openshell-driver-vm/src/driver.rs +++ b/crates/openshell-driver-vm/src/driver.rs @@ -4243,9 +4243,17 @@ impl ComputeDriver for VmDriver { async fn get_capabilities( &self, - _request: Request, + request: Request, ) -> Result, Status> { - Ok(Response::new(self.capabilities())) + let capabilities = self.capabilities(); + openshell_core::extension_protocol::validate_gateway_metadata( + openshell_core::extension_protocol::ExtensionFamily::Compute, + DRIVER_NAME, + capabilities.extension.as_ref(), + request.into_inner().gateway, + ) + .map_err(|error| Status::failed_precondition(error.to_string()))?; + Ok(Response::new(capabilities)) } async fn get_gateway_listener_requirements( @@ -7147,7 +7155,11 @@ mod tests { let mut client = traced_driver_client(driver).await; client - .get_capabilities(request_with_traceparent(GetCapabilitiesRequest::default())) + .get_capabilities(request_with_traceparent(GetCapabilitiesRequest { + gateway: Some(openshell_core::extension_protocol::gateway_metadata( + openshell_core::extension_protocol::ExtensionFamily::Compute, + )), + })) .await .unwrap(); client.shutdown().await; @@ -7179,7 +7191,11 @@ mod tests { let mut client = traced_driver_client(driver).await; client - .get_capabilities(request_with_traceparent(GetCapabilitiesRequest::default())) + .get_capabilities(request_with_traceparent(GetCapabilitiesRequest { + gateway: Some(openshell_core::extension_protocol::gateway_metadata( + openshell_core::extension_protocol::ExtensionFamily::Compute, + )), + })) .await .unwrap(); assert!( diff --git a/crates/openshell-gateway/src/vm.rs b/crates/openshell-gateway/src/vm.rs index 3956eca30f..a066b4b88b 100644 --- a/crates/openshell-gateway/src/vm.rs +++ b/crates/openshell-gateway/src/vm.rs @@ -718,7 +718,11 @@ async fn wait_for_compute_driver( let mut client = ComputeDriverClient::with_interceptor(channel.clone(), TraceContextInterceptor); match client - .get_capabilities(tonic::Request::new(GetCapabilitiesRequest::default())) + .get_capabilities(tonic::Request::new(GetCapabilitiesRequest { + gateway: Some(openshell_core::extension_protocol::gateway_metadata( + openshell_core::extension_protocol::ExtensionFamily::Compute, + )), + })) .await { Ok(_) => return Ok(channel), diff --git a/docs/extensibility/extension-negotiation.mdx b/docs/extensibility/extension-negotiation.mdx index 7f2cba3904..c8e3a1d791 100644 --- a/docs/extensibility/extension-negotiation.mdx +++ b/docs/extensibility/extension-negotiation.mdx @@ -57,8 +57,8 @@ Built-in and external extensions follow the same validator. A built-in cannot by 1. Regenerate bindings from the current OpenShell protobuf files. Supervisor middleware authors must update `Describe` from `google.protobuf.Empty` to `MiddlewareDescribeRequest`. 2. Read and validate the gateway metadata supplied in the startup request. 3. Return protocol `1.0`, a stable implementation name, the extension build version, the family base capability, and any additional supported or required capabilities. -4. Deploy the upgraded extension before upgrading the gateway. A gateway with mandatory negotiation rejects an older extension that omits metadata. -5. Run mixed-minor tests with required capabilities present and absent. Verify that a major mismatch and missing metadata fail before runtime traffic. +4. Schedule a coordinated gateway and extension upgrade. There is no supported mixed legacy/current pairing: current extensions reject legacy gateways that omit metadata, and current gateways reject legacy extensions that omit metadata. Stop traffic, upgrade both peers, and restart them together. +5. Run mixed-minor tests with required capabilities present and absent after both peers implement negotiation. Verify that a major mismatch and missing metadata fail before runtime traffic. The legacy compute and credential `driver_version` fields and middleware `service_version` field remain populated during migration. New integrations must use `PeerMetadata.implementation_version`; the legacy fields are diagnostic compatibility fields and may be removed in a future protocol major. diff --git a/docs/extensibility/supervisor-middleware.mdx b/docs/extensibility/supervisor-middleware.mdx index d74c075078..8e053772a3 100644 --- a/docs/extensibility/supervisor-middleware.mdx +++ b/docs/extensibility/supervisor-middleware.mdx @@ -84,7 +84,7 @@ Each binding returned by `Describe` may advertise a shorter `timeout` using the The gateway connects to every registered service and verifies its capabilities before accepting traffic. Gateway startup fails when a service is unavailable, reports an invalid capability, or exposes more than one binding for the same operation and phase. The manifest `name` is diagnostic metadata and does not need to match the operator registration name. Operator-run registration names cannot claim the reserved `openshell/` namespace. -`MiddlewareDescribeRequest` carries the caller's common protocol metadata, and `MiddlewareManifest.extension` returns the service's protocol and implementation metadata. This replaces the former empty `Describe` request. Regenerate service bindings and return protocol `1.0` plus `openshell.supervisor-middleware.contract` before upgrading the gateway. See [Extension Protocol Negotiation](/extensibility/extension-negotiation) for the skew policy and migration sequence. +`MiddlewareDescribeRequest` carries the caller's common protocol metadata, and `MiddlewareManifest.extension` returns the service's protocol and implementation metadata. This replaces the former empty `Describe` request. Regenerate service bindings and return protocol `1.0` plus `openshell.supervisor-middleware.contract`. Legacy gateways and current middleware cannot interoperate, so upgrade both peers during a coordinated outage. See [Extension Protocol Negotiation](/extensibility/extension-negotiation) for the skew policy and migration sequence. Registration is static. Restart the gateway after adding, removing, or changing a service. See [Gateway Configuration](/reference/gateway-config#supervisor-middleware-services) for the complete gateway TOML context. diff --git a/docs/reference/gateway-config.mdx b/docs/reference/gateway-config.mdx index ce41a64a73..5e050c6e91 100644 --- a/docs/reference/gateway-config.mdx +++ b/docs/reference/gateway-config.mdx @@ -361,7 +361,7 @@ Each service implements the supervisor middleware gRPC contract and exposes bind The gateway connects to every registered service and validates `Describe` before it starts. The service must therefore be running before the gateway. Policy creation and full policy updates call `ValidateConfig`; an unavailable service or invalid middleware configuration rejects the policy before persistence. -Startup also requires compatible [extension protocol metadata](/extensibility/extension-negotiation). Upgrade operator-run services first; a new gateway rejects a service that omits peer metadata, uses another protocol major, or requires unsupported gateway capabilities. Protected `GetGatewayInfo` and `openshell gateway info` report the resulting non-secret snapshot. +Startup also requires compatible [extension protocol metadata](/extensibility/extension-negotiation). Upgrade legacy gateways and operator-run services together during a coordinated outage; neither mixed legacy/current pairing is supported. A service rejects a gateway that omits peer metadata, and a gateway rejects a service that omits metadata, uses another protocol major, or requires unsupported gateway capabilities. Protected `GetGatewayInfo` and `openshell gateway info` report the resulting non-secret snapshot. `max_payload_bytes` is the shared operator limit for inspectable logical payloads across every binding exposed by the service. It caps HTTP request and response units, replacement bodies, and complete WebSocket text messages and replacements. Whole-response inspection uses it as the stage's total body limit. Streaming response inspection applies it to each unit. The value must be greater than zero, no larger than each binding's advertised `max_payload_bytes` capability, and no larger than the 4 MiB platform maximum. OpenShell rejects oversized values instead of silently clamping them. Binary WebSocket messages are not exposed to V1 middleware, so this field does not limit binary pass-through. Middleware gRPC servers should allow messages of at least 4 MiB plus 293 KiB so a maximum-size payload and its protobuf envelope fit on the transport. @@ -377,7 +377,7 @@ See [Supervisor Middleware](/extensibility/supervisor-middleware) for selection, `[[openshell.gateway.interceptors]]` configures gateway-side interceptor services. The gateway calls each service's `Describe` RPC at startup, validates its declared OpenShell RPC bindings against the compiled service descriptor, and applies matching phases from a central gRPC middleware path. Interceptors can target only methods in the gateway's built-in allowlist of unary mutation RPCs. New RPCs are non-interceptable until they are deliberately added to that allowlist; adding one does not require handler-specific interceptor code. Request bodies are exposed as protobuf JSON objects. Fields marked secret in the protobuf schema are recursively omitted from requests and post-commit responses. Interceptors cannot patch an omitted field or a containing object. -Each interceptor must also complete [extension protocol negotiation](/extensibility/extension-negotiation) during `Describe`. Upgrade the interceptor first when moving from the legacy manifest: the gateway rejects missing metadata, incompatible protocol majors, and unmet requirements before serving requests. +Each interceptor must also complete [extension protocol negotiation](/extensibility/extension-negotiation) during `Describe`. Upgrade legacy gateways and interceptors together during a coordinated outage; neither mixed legacy/current pairing is supported. The interceptor rejects missing or incompatible gateway metadata, and the gateway rejects missing metadata, incompatible protocol majors, and unmet requirements before serving requests. HTTPS interceptor endpoints use the platform trust store by default. Set `tls_ca_cert_path` to a PEM certificate bundle for a private CA; normal TLS hostname verification still applies. `audience` sets the exact audience for gateway-minted service tokens and defaults to `urn:openshell:extension:interceptor:`. After authenticated `Describe` succeeds, the gateway treats a non-empty manifest `expected_audience` as a consistency assertion and refuses to start when it differs from the configured audience. A strict verifier may reject an incorrect audience before returning the manifest. When `gateway_jwt` is configured, network interceptors must use HTTPS and receive short-lived gateway-caller bearer credentials; local Unix sockets are also supported. Set `allow_insecure_transport = true` to keep a plaintext `http://` interceptor endpoint with no credential attached and a startup warning. diff --git a/examples/governance-interceptor/src/main.rs b/examples/governance-interceptor/src/main.rs index 1a9129437a..57c992e3dd 100644 --- a/examples/governance-interceptor/src/main.rs +++ b/examples/governance-interceptor/src/main.rs @@ -555,9 +555,17 @@ impl GovernanceInterceptorService { impl GatewayInterceptor for GovernanceInterceptorService { async fn describe( &self, - _request: Request, + request: Request, ) -> Result, Status> { - Ok(Response::new(self.manifest())) + let manifest = self.manifest(); + openshell_core::extension_protocol::validate_gateway_metadata( + openshell_core::extension_protocol::ExtensionFamily::GatewayInterceptor, + "provider-governance", + manifest.extension.as_ref(), + request.into_inner().gateway, + ) + .map_err(|error| Status::failed_precondition(error.to_string()))?; + Ok(Response::new(manifest)) } async fn evaluate( diff --git a/examples/governance-interceptor/src/tests.rs b/examples/governance-interceptor/src/tests.rs index 1df9c25727..640a3e2862 100644 --- a/examples/governance-interceptor/src/tests.rs +++ b/examples/governance-interceptor/src/tests.rs @@ -12,6 +12,27 @@ fn service() -> GovernanceInterceptorService { GovernanceInterceptorService::from_profiles(profiles).unwrap() } +#[tokio::test] +async fn describe_rejects_incompatible_gateway_metadata() { + let service = service(); + let mut gateway = openshell_core::extension_protocol::gateway_metadata( + openshell_core::extension_protocol::ExtensionFamily::GatewayInterceptor, + ); + gateway.protocol_version.as_mut().unwrap().major = 2; + + let error = GatewayInterceptor::describe( + &service, + Request::new(DescribeRequest { + gateway: Some(gateway), + }), + ) + .await + .unwrap_err(); + + assert_eq!(error.code(), Code::FailedPrecondition); + assert!(error.message().contains("unsupported protocol")); +} + fn evaluation( method: &str, phase: GatewayInterceptorPhase, diff --git a/examples/supervisor-middleware-content-guard/src/main.rs b/examples/supervisor-middleware-content-guard/src/main.rs index 8f4f6742bb..dbf9494259 100644 --- a/examples/supervisor-middleware-content-guard/src/main.rs +++ b/examples/supervisor-middleware-content-guard/src/main.rs @@ -230,9 +230,9 @@ impl SupervisorMiddleware for ContentGuard { async fn describe( &self, - _request: Request, + request: Request, ) -> Result, Status> { - Ok(Response::new(MiddlewareManifest { + let manifest = MiddlewareManifest { name: MANIFEST_NAME.into(), service_version: env!("CARGO_PKG_VERSION").into(), bindings: vec![ @@ -262,7 +262,15 @@ impl SupervisorMiddleware for ContentGuard { openshell_core::VERSION, [], )), - })) + }; + openshell_core::extension_protocol::validate_gateway_metadata( + openshell_core::extension_protocol::ExtensionFamily::SupervisorMiddleware, + MANIFEST_NAME, + manifest.extension.as_ref(), + request.into_inner().gateway, + ) + .map_err(|error| Status::failed_precondition(error.to_string()))?; + Ok(Response::new(manifest)) } async fn validate_config( @@ -686,7 +694,11 @@ mod tests { async fn manifest_advertises_request_response_and_websocket_bindings() { let manifest = SupervisorMiddleware::describe( &ContentGuard, - Request::new(MiddlewareDescribeRequest::default()), + Request::new(MiddlewareDescribeRequest { + gateway: Some(openshell_core::extension_protocol::gateway_metadata( + openshell_core::extension_protocol::ExtensionFamily::SupervisorMiddleware, + )), + }), ) .await .expect("describe") @@ -809,6 +821,23 @@ mod tests { } } + #[tokio::test] + async fn describe_rejects_missing_gateway_metadata() { + let error = SupervisorMiddleware::describe( + &ContentGuard, + Request::new(MiddlewareDescribeRequest::default()), + ) + .await + .unwrap_err(); + + assert_eq!(error.code(), tonic::Code::FailedPrecondition); + assert!( + error + .message() + .contains("gateway did not provide protocol metadata") + ); + } + #[tokio::test] async fn websocket_stream_redacts_text_messages() { let events = tokio_stream::iter([ diff --git a/skills/debug-openshell-cluster/SKILL.md b/skills/debug-openshell-cluster/SKILL.md index 57c0933938..565c7383f8 100644 --- a/skills/debug-openshell-cluster/SKILL.md +++ b/skills/debug-openshell-cluster/SKILL.md @@ -760,7 +760,7 @@ credential failures. | Gateway fails before serving health after enabling an interceptor | Interceptor endpoint unavailable or manifest/binding validation failed | Gateway and interceptor logs; interceptor socket; `binding_policy`, phases, and failure policy | | Authenticated interceptor rejects gateway calls | Private CA or hostname mismatch, expected audience or issuer mismatch, stale/unknown `kid`, or malformed extension token | `tls_ca_cert_path`, registration `audience`, service verifier config and logs; fetch well-known metadata only through the already-trusted gateway TLS endpoint | | Provider profiles disappear after enabling an interceptor catalog | `provider_profile_sources` selected only an authoritative interceptor or returned invalid/duplicate IDs | Inspect source list and interceptor `Describe`/catalog logs; include `builtin` and `user` when intended | -| Gateway rejects an extension before serving health | Missing peer metadata, incompatible protocol major, or unmet `required_capabilities` | Gateway and extension startup logs; compare `PeerMetadata`; upgrade the extension before the gateway | +| Gateway or extension rejects its peer before serving health | Missing peer metadata, incompatible protocol major, or unmet `required_capabilities` | Gateway and extension startup logs; compare `PeerMetadata`; legacy-to-current migration requires a coordinated gateway and extension outage | | Policy mutation returns `FAILED_PRECONDITION` for endpoint ambiguity | Equally specific effective endpoint selectors disagree on connection or request-processing metadata | CLI error, base and provider-composed policy, affected profile attachments; confirm no new revision was stored | | Supervisor enters policy quarantine | A runtime candidate failed validation while `policy_validation_failure_mode = "fail_closed"` | Sandbox OCSF config/finding events, validation rationale, active generation, `previous_policy_active` | | Custom compute driver is unavailable | Driver process/socket missing, inaccessible, or selected name does not match its endpoint/config key | Socket ownership/mode, driver service logs, gateway `GetCapabilities` logs | diff --git a/skills/debug-openshell-cluster/references/supervisor-middleware.md b/skills/debug-openshell-cluster/references/supervisor-middleware.md index 73aacbbbd5..6a71f95914 100644 --- a/skills/debug-openshell-cluster/references/supervisor-middleware.md +++ b/skills/debug-openshell-cluster/references/supervisor-middleware.md @@ -44,7 +44,7 @@ WebSocket message sequences are allocated session-wide; each stage receives a st |---|---|---| | Authenticated middleware rejects gateway calls | Private CA or hostname mismatch, expected audience or issuer mismatch, stale/unknown `kid`, or malformed extension token | `tls_ca_cert_path`, registration `audience`, service verifier config and logs; fetch well-known metadata only through the already-trusted gateway TLS endpoint | | Gateway fails after registering supervisor middleware | Service unavailable, invalid manifest, duplicate binding, reserved name, or invalid payload/timeout limit | Middleware service and gateway logs; `[[openshell.supervisor.middleware]]`; `Describe` response | -| Gateway rejects middleware before serving health | Missing peer metadata, incompatible protocol major, or unmet `required_capabilities` | Gateway and middleware startup logs; compare `PeerMetadata`; upgrade the middleware before the gateway | +| Gateway or middleware rejects its peer before serving health | Missing peer metadata, incompatible protocol major, or unmet `required_capabilities` | Gateway and middleware startup logs; compare `PeerMetadata`; legacy-to-current migration requires a coordinated gateway and middleware outage | | Policy update rejects `network_middlewares` | Unknown middleware name, implementation-owned config invalid, duplicate order, broad/invalid host selector, or fail-closed coverage of `tls: skip` | Policy error, gateway logs, middleware `ValidateConfig`, selector and order fields | | HTTP request returns `middleware_failed` or `middleware_denied`, or WebSocket closes with `1008` | Selected stage failed or explicitly denied admitted traffic | Sandbox OCSF logs; policy-local middleware config; service availability; binding operation; `on_error` | | HTTP response becomes canonical `403 middleware_denied`, `502 response_delivery_failed`, or closes mid-body | Response middleware blocked, failed before commitment, or stopped delivery after commitment | Sandbox OCSF response middleware events; `HTTP_RESPONSE/PRE_RETURN` binding; `on_error`; `whole_body_accumulation_timeout`; service stream lifecycle | From 874a1c835f2057c40ab353f6cad9feea3cfbd780 Mon Sep 17 00:00:00 2001 From: Seth Jennings Date: Thu, 17 Sep 2026 14:12:29 -0500 Subject: [PATCH 4/5] fix(go-sdk): re-export extension kind constants Signed-off-by: Seth Jennings --- sdk/go/openshell/v1/health.go | 9 +++++++++ sdk/go/openshell/v1/health_client_test.go | 8 ++++++++ 2 files changed, 17 insertions(+) diff --git a/sdk/go/openshell/v1/health.go b/sdk/go/openshell/v1/health.go index e7745dd76b..ac05337460 100644 --- a/sdk/go/openshell/v1/health.go +++ b/sdk/go/openshell/v1/health.go @@ -24,6 +24,15 @@ type ExtensionInfo = types.ExtensionInfo // ExtensionKind identifies one supported extension family. type ExtensionKind = types.ExtensionKind +// ExtensionKind constants re-exported from the types package. +const ( + ExtensionKindComputeDriver = types.ExtensionKindComputeDriver + ExtensionKindCredentialDriver = types.ExtensionKindCredentialDriver + ExtensionKindGatewayInterceptor = types.ExtensionKindGatewayInterceptor + ExtensionKindSupervisorMiddleware = types.ExtensionKindSupervisorMiddleware + ExtensionKindUnknown = types.ExtensionKindUnknown +) + // ServiceStatus describes the health state of the gateway. type ServiceStatus = types.ServiceStatus diff --git a/sdk/go/openshell/v1/health_client_test.go b/sdk/go/openshell/v1/health_client_test.go index 688639120a..dc82fe1e4e 100644 --- a/sdk/go/openshell/v1/health_client_test.go +++ b/sdk/go/openshell/v1/health_client_test.go @@ -31,6 +31,14 @@ type mockHealthServer struct { currentUserErr error } +func TestExtensionKindConstantsAreReexported(t *testing.T) { + assert.Equal(t, ExtensionKind("ComputeDriver"), ExtensionKindComputeDriver) + assert.Equal(t, ExtensionKind("CredentialDriver"), ExtensionKindCredentialDriver) + assert.Equal(t, ExtensionKind("GatewayInterceptor"), ExtensionKindGatewayInterceptor) + assert.Equal(t, ExtensionKind("SupervisorMiddleware"), ExtensionKindSupervisorMiddleware) + assert.Equal(t, ExtensionKind("Unknown"), ExtensionKindUnknown) +} + func (s *mockHealthServer) Health(_ context.Context, _ *pb.HealthRequest) (*pb.HealthResponse, error) { if s.err != nil { return nil, s.err From bc2c68643082283e6a47d153b62fdf994c31e029 Mon Sep 17 00:00:00 2001 From: Seth Jennings Date: Thu, 17 Sep 2026 16:38:36 -0500 Subject: [PATCH 5/5] fix(extensions): fail fast on credential handshake rejection Signed-off-by: Seth Jennings --- crates/openshell-server/src/credentials.rs | 109 ++++++++++++++---- .../src/response.rs | 14 ++- .../src/l7/rest.rs | 6 + .../openshell-supervisor-network/src/proxy.rs | 6 + 4 files changed, 114 insertions(+), 21 deletions(-) diff --git a/crates/openshell-server/src/credentials.rs b/crates/openshell-server/src/credentials.rs index 29a57a1cdb..afc331e3a4 100644 --- a/crates/openshell-server/src/credentials.rs +++ b/crates/openshell-server/src/credentials.rs @@ -1701,10 +1701,10 @@ where match tokio::time::timeout(remaining, connect()).await { Ok(Ok(connected)) => return Ok(connected), - Ok(Err(CredentialDriverReadinessError::Retryable(err))) => { - last_error = Some(err.to_string()); + Ok(Err(error)) if error.is_retryable() => { + last_error = Some(error.into_error().to_string()); } - Ok(Err(CredentialDriverReadinessError::Terminal(err))) => return Err(err), + Ok(Err(error)) => return Err(error.into_error()), Err(_) => { return Err(Error::execution(format!( "timed out waiting for credential driver '{driver_name}' to respond to GetCapabilities" @@ -1728,14 +1728,44 @@ where #[derive(Debug)] enum CredentialDriverReadinessError { Retryable(Error), + RpcStatus { driver_name: String, status: Status }, Terminal(Error), } #[cfg(unix)] impl CredentialDriverReadinessError { + fn rpc_status(driver_name: &str, status: Status) -> Self { + Self::RpcStatus { + driver_name: driver_name.to_string(), + status, + } + } + + fn is_retryable(&self) -> bool { + match self { + Self::Retryable(_) => true, + Self::RpcStatus { status, .. } => matches!( + status.code(), + tonic::Code::Unavailable + | tonic::Code::DeadlineExceeded + | tonic::Code::ResourceExhausted + | tonic::Code::Aborted + | tonic::Code::Internal + | tonic::Code::Unknown + ), + Self::Terminal(_) => false, + } + } + fn into_error(self) -> Error { match self { Self::Retryable(error) | Self::Terminal(error) => error, + Self::RpcStatus { + driver_name, + status, + } => Error::config(format!( + "credential driver '{driver_name}' GetCapabilities failed: {status}" + )), } } } @@ -1760,8 +1790,7 @@ async fn connect_ready_credential_driver( timeout, client.get_capabilities(request), ) - .await - .map_err(CredentialDriverReadinessError::Retryable)?; + .await?; let negotiated_extension = negotiate( ExtensionFamily::Credentials, driver_name, @@ -1779,19 +1808,15 @@ async fn await_credential_driver_capabilities( response: impl Future< Output = Result, Status>, >, -) -> CoreResult { +) -> Result { tokio::time::timeout(timeout, response) .await .map_err(|_| { - Error::config(format!( + CredentialDriverReadinessError::Retryable(Error::config(format!( "credential driver '{driver_name}' GetCapabilities timed out" - )) + ))) })? - .map_err(|status| { - Error::config(format!( - "credential driver '{driver_name}' GetCapabilities failed: {status}" - )) - }) + .map_err(|status| CredentialDriverReadinessError::rpc_status(driver_name, status)) .map(tonic::Response::into_inner) } @@ -2559,14 +2584,15 @@ socket_path = {socket_path_toml} response, ) .await - .unwrap_err(); + .unwrap_err() + .into_error(); assert!(err.to_string().contains("GetCapabilities timed out")); } #[cfg(unix)] #[tokio::test] - async fn launched_driver_protocol_incompatibility_is_terminal() { + async fn launched_driver_failed_precondition_is_terminal() { let mut child = Command::new("sleep") .arg("30") .kill_on_drop(true) @@ -2579,12 +2605,16 @@ socket_path = {socket_path_toml} Path::new("/unused-test-socket"), &mut child, Duration::from_secs(30), - || { - std::future::ready(Err(CredentialDriverReadinessError::Terminal( - Error::config( + || async { + await_credential_driver_capabilities( + "enterprise-secrets", + Duration::from_secs(30), + std::future::ready(Err(Status::failed_precondition( "credentials extension 'enterprise-secrets' uses unsupported protocol 2.0; gateway supports 1.0", - ), - ))) + ))), + ) + .await?; + unreachable!("failed-precondition response cannot produce capabilities") }, ) .await @@ -2594,6 +2624,45 @@ socket_path = {socket_path_toml} assert!(started.elapsed() < Duration::from_secs(1)); } + #[cfg(unix)] + #[test] + fn credential_driver_rpc_status_retries_only_transient_failures() { + for code in [ + Code::Unavailable, + Code::DeadlineExceeded, + Code::ResourceExhausted, + Code::Aborted, + Code::Internal, + Code::Unknown, + ] { + assert!( + CredentialDriverReadinessError::rpc_status( + "enterprise-secrets", + Status::new(code, "not ready"), + ) + .is_retryable(), + "{code:?} should be retried" + ); + } + + for code in [ + Code::InvalidArgument, + Code::FailedPrecondition, + Code::PermissionDenied, + Code::Unauthenticated, + Code::Unimplemented, + ] { + assert!( + !CredentialDriverReadinessError::rpc_status( + "enterprise-secrets", + Status::new(code, "incompatible"), + ) + .is_retryable(), + "{code:?} should fail immediately" + ); + } + } + #[test] fn parse_driver_table_preserves_backend_config_without_transport_fields() { let parsed = parse_driver_table( diff --git a/crates/openshell-supervisor-middleware/src/response.rs b/crates/openshell-supervisor-middleware/src/response.rs index 073bebd88d..6fe6d6c427 100644 --- a/crates/openshell-supervisor-middleware/src/response.rs +++ b/crates/openshell-supervisor-middleware/src/response.rs @@ -1247,7 +1247,7 @@ mod tests { async fn describe( &self, - _request: tonic::Request<()>, + _request: tonic::Request, ) -> Result, tonic::Status> { Ok(tonic::Response::new(response_manifest( "test/remote-response", @@ -1377,6 +1377,12 @@ mod tests { }), }], expected_audience: String::new(), + extension: Some(openshell_core::extension_protocol::extension_metadata( + openshell_core::extension_protocol::ExtensionFamily::SupervisorMiddleware, + "openshell/test-response-middleware", + "test", + [], + )), } } @@ -1717,6 +1723,12 @@ mod tests { request_timeout: None, }], expected_audience: String::new(), + extension: Some(openshell_core::extension_protocol::extension_metadata( + openshell_core::extension_protocol::ExtensionFamily::SupervisorMiddleware, + name, + "test", + [], + )), } } diff --git a/crates/openshell-supervisor-network/src/l7/rest.rs b/crates/openshell-supervisor-network/src/l7/rest.rs index 4c65c983e6..f532b6ee64 100644 --- a/crates/openshell-supervisor-network/src/l7/rest.rs +++ b/crates/openshell-supervisor-network/src/l7/rest.rs @@ -3609,6 +3609,12 @@ mod tests { request_timeout: None, }], expected_audience: String::new(), + extension: Some(openshell_core::extension_protocol::extension_metadata( + openshell_core::extension_protocol::ExtensionFamily::SupervisorMiddleware, + "openshell/test-response-relay", + "test", + [], + )), } } diff --git a/crates/openshell-supervisor-network/src/proxy.rs b/crates/openshell-supervisor-network/src/proxy.rs index 56d7b62ac4..9799d59ff7 100644 --- a/crates/openshell-supervisor-network/src/proxy.rs +++ b/crates/openshell-supervisor-network/src/proxy.rs @@ -6786,6 +6786,12 @@ process: request_timeout: None, }], expected_audience: String::new(), + extension: Some(openshell_core::extension_protocol::extension_metadata( + openshell_core::extension_protocol::ExtensionFamily::SupervisorMiddleware, + "openshell/test-forward-response", + "test", + [], + )), } }