Skip to content

Commit 6699658

Browse files
fix(k8s): address workspace namespace review findings
Signed-off-by: Derek Carr <[email protected]>
1 parent d2bf75f commit 6699658

8 files changed

Lines changed: 382 additions & 151 deletions

File tree

‎crates/openshell-driver-kubernetes-secrets/src/lib.rs‎

Lines changed: 62 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -532,12 +532,29 @@ impl KubernetesSecretsDriverSettings {
532532
}
533533
None => default_namespace(),
534534
};
535+
let gateway_id = config.gateway_id.unwrap_or_default();
536+
if config.workspace_mode == WorkspaceMode::Managed {
537+
let gateway_id = trimmed_config_string("gateway_id", &gateway_id)?;
538+
if !is_dns_label(gateway_id) {
539+
return Err(Error::config(
540+
"[openshell.credential_drivers.kubernetes-secrets] gateway_id must be a DNS-1123 label in managed workspace mode",
541+
));
542+
}
543+
// Workspace names are limited to 19 characters by the gateway.
544+
// Keep the longest generated namespace within Kubernetes' 63-char
545+
// DNS label limit, matching the Kubernetes compute driver.
546+
if "openshell-".len() + gateway_id.len() + 1 + 19 > 63 {
547+
return Err(Error::config(
548+
"[openshell.credential_drivers.kubernetes-secrets] gateway_id is too long for managed workspace mode",
549+
));
550+
}
551+
}
535552

536553
Ok(Self {
537554
namespace,
538555
allow_reference_namespace: config.allow_reference_namespace,
539556
workspace_mode: config.workspace_mode,
540-
gateway_id: config.gateway_id.unwrap_or_default(),
557+
gateway_id,
541558
})
542559
}
543560
}
@@ -808,6 +825,50 @@ mod tests {
808825
assert!(err.to_string().contains("namespace"));
809826
}
810827

828+
#[test]
829+
fn settings_managed_mode_requires_gateway_id() {
830+
let err = KubernetesSecretsDriverSettings::from_table(&toml::toml! {
831+
workspace_mode = "managed"
832+
})
833+
.unwrap_err();
834+
835+
assert!(err.to_string().contains("gateway_id"));
836+
}
837+
838+
#[test]
839+
fn settings_managed_mode_rejects_invalid_gateway_id() {
840+
let err = KubernetesSecretsDriverSettings::from_table(&toml::toml! {
841+
workspace_mode = "managed"
842+
gateway_id = "Invalid_Gateway"
843+
})
844+
.unwrap_err();
845+
846+
assert!(err.to_string().contains("DNS-1123"));
847+
}
848+
849+
#[test]
850+
fn settings_managed_mode_rejects_gateway_id_that_is_too_long() {
851+
let gateway_id = "a".repeat(35);
852+
let err = KubernetesSecretsDriverSettings::from_table(&toml::toml! {
853+
workspace_mode = "managed"
854+
gateway_id = gateway_id
855+
})
856+
.unwrap_err();
857+
858+
assert!(err.to_string().contains("too long"));
859+
}
860+
861+
#[test]
862+
fn settings_managed_mode_accepts_valid_gateway_id() {
863+
let settings = KubernetesSecretsDriverSettings::from_table(&toml::toml! {
864+
workspace_mode = "managed"
865+
gateway_id = "gateway-1"
866+
})
867+
.unwrap();
868+
869+
assert_eq!(settings.gateway_id, "gateway-1");
870+
}
871+
811872
#[test]
812873
fn handle_resolves_secret_reference() {
813874
let reference = KubernetesSecretsCredentialDriver::parse_handle(

‎crates/openshell-driver-kubernetes/README.md‎

Lines changed: 5 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -12,9 +12,12 @@ workspace namespace modes via `workspace_mode`:
1212
(`openshell-{gateway_id}-{workspace_name}`), creates a ServiceAccount in each,
1313
and copies OpenShift SCC annotations from the gateway namespace when present.
1414
- **Operator**: Workspace names map 1:1 to pre-provisioned namespaces discovered
15-
via label selector (`operator_namespace_label`) and/or drop-in allowlist file
15+
through exactly one source: either a label selector
16+
(`operator_namespace_label`) or a drop-in allowlist file
1617
(`operator_namespace_file`). Sandbox creation fails closed if the workspace
17-
namespace is not in the current allowlist.
18+
namespace is not in the current allowlist. Workspace deletion only removes
19+
gateway state; it never deletes or otherwise accesses the operator-managed
20+
Kubernetes namespace.
1821

1922
Workspace namespace modes assume exclusive control of the sandbox identity
2023
resource chain. In shared and managed modes, only the gateway and its trusted

‎crates/openshell-driver-kubernetes/src/config.rs‎

Lines changed: 59 additions & 15 deletions
Original file line numberDiff line numberDiff line change
@@ -849,6 +849,18 @@ pub struct OperatorNamespaceAllowlist {
849849
}
850850

851851
impl OperatorNamespaceAllowlist {
852+
fn read_guard(&self) -> std::sync::RwLockReadGuard<'_, BTreeSet<String>> {
853+
self.inner
854+
.read()
855+
.unwrap_or_else(std::sync::PoisonError::into_inner)
856+
}
857+
858+
fn write_guard(&self) -> std::sync::RwLockWriteGuard<'_, BTreeSet<String>> {
859+
self.inner
860+
.write()
861+
.unwrap_or_else(std::sync::PoisonError::into_inner)
862+
}
863+
852864
#[must_use]
853865
pub fn new() -> Self {
854866
Self {
@@ -865,44 +877,35 @@ impl OperatorNamespaceAllowlist {
865877

866878
/// Replace the entire allowlist (used by background watchers on refresh).
867879
pub fn replace(&self, new_set: BTreeSet<String>) {
868-
let mut guard = self.inner.write().expect("allowlist lock poisoned");
880+
let mut guard = self.write_guard();
869881
*guard = new_set;
870882
}
871883

872884
/// Merge additional namespaces into the allowlist.
873885
pub fn merge(&self, additional: &BTreeSet<String>) {
874-
let mut guard = self.inner.write().expect("allowlist lock poisoned");
886+
let mut guard = self.write_guard();
875887
guard.extend(additional.iter().cloned());
876888
}
877889

878890
/// Read the current allowlist snapshot.
879891
pub fn read(&self) -> std::sync::RwLockReadGuard<'_, BTreeSet<String>> {
880-
self.inner.read().expect("allowlist lock poisoned")
892+
self.read_guard()
881893
}
882894

883895
/// Check whether a namespace is in the allowlist.
884896
#[must_use]
885897
pub fn contains(&self, namespace: &str) -> bool {
886-
self.inner
887-
.read()
888-
.expect("allowlist lock poisoned")
889-
.contains(namespace)
898+
self.read_guard().contains(namespace)
890899
}
891900

892901
/// Insert a namespace into the allowlist. Returns `true` if it was new.
893902
pub fn insert(&self, name: String) -> bool {
894-
self.inner
895-
.write()
896-
.expect("allowlist lock poisoned")
897-
.insert(name)
903+
self.write_guard().insert(name)
898904
}
899905

900906
/// Remove a namespace from the allowlist. Returns `true` if it was present.
901907
pub fn remove(&self, name: &str) -> bool {
902-
self.inner
903-
.write()
904-
.expect("allowlist lock poisoned")
905-
.remove(name)
908+
self.write_guard().remove(name)
906909
}
907910

908911
/// Return a clone of the inner `Arc` for sharing with background tasks.
@@ -1674,6 +1677,18 @@ mod tests {
16741677
);
16751678
}
16761679

1680+
#[test]
1681+
fn namespace_for_workspace_operator_requires_allowlist() {
1682+
let cfg = KubernetesComputeConfig {
1683+
workspace_mode: WorkspaceMode::Operator,
1684+
operator_namespace_label: Some("openshell.ai/workspace=true".to_string()),
1685+
..KubernetesComputeConfig::default()
1686+
};
1687+
1688+
let err = cfg.namespace_for_workspace("prod", None).unwrap_err();
1689+
assert_eq!(err, "operator mode requires a namespace allowlist");
1690+
}
1691+
16771692
#[test]
16781693
fn kube_resource_name_shared_prefixes_workspace() {
16791694
let cfg = KubernetesComputeConfig::default();
@@ -1830,6 +1845,19 @@ mod tests {
18301845
cfg.validate_workspace_mode().unwrap();
18311846
}
18321847

1848+
#[test]
1849+
fn validate_workspace_mode_operator_rejects_label_and_file() {
1850+
let cfg = KubernetesComputeConfig {
1851+
workspace_mode: WorkspaceMode::Operator,
1852+
operator_namespace_label: Some("openshell.ai/workspace=true".to_string()),
1853+
operator_namespace_file: Some("/etc/openshell/namespaces.json".to_string()),
1854+
..KubernetesComputeConfig::default()
1855+
};
1856+
1857+
let err = cfg.validate_workspace_mode().unwrap_err();
1858+
assert!(err.contains("not both"), "{err}");
1859+
}
1860+
18331861
#[test]
18341862
fn dns_1123_label_validation() {
18351863
assert!(is_dns_1123_label("openshell"));
@@ -1885,4 +1913,20 @@ mod tests {
18851913
al.replace(BTreeSet::new());
18861914
assert!(!al.contains("ns1"));
18871915
}
1916+
1917+
#[test]
1918+
fn operator_allowlist_recovers_from_poisoned_lock() {
1919+
let al = OperatorNamespaceAllowlist::from_set(BTreeSet::from(["ns1".to_string()]));
1920+
let shared = al.shared();
1921+
let _ = std::thread::spawn(move || {
1922+
let _guard = shared.write().unwrap();
1923+
panic!("poison allowlist lock");
1924+
})
1925+
.join();
1926+
1927+
assert!(al.contains("ns1"));
1928+
assert!(al.insert("ns2".to_string()));
1929+
assert!(al.read().contains("ns2"));
1930+
assert!(al.remove("ns1"));
1931+
}
18881932
}

0 commit comments

Comments
 (0)