Files
codex/codex-rs/config/src/mcp_ema_cancellation.rs
T
jif feadd9441e Preserve enterprise MCP authorization across runtime refreshes (#55696)
## Why

Configuration reloads must cancel stale enterprise MCP startups while preserving access for running threads that still pass validation. Replacing a runtime during `thread/revert` must also leave the replacement able to use enterprise tools.

## What changed

- Separate pending startup cancellation from published thread lifetimes, with independent startup state for forks and replacement runtimes.
- Retain eligible enterprise MCP connections across refreshes and explicit reconnects while applying updated tool restrictions and approvals. Do not create replacement enterprise connections after initial startup.
- Revoke enterprise authorization when a thread is removed, drain requests when access is disabled, and revoke a connection's authority when token renewal requires authentication.

## Testing

Extend regression coverage to verify enterprise tool calls survive `thread/revert`, inherited fork configurations are cancelled after a reload, and enterprise calls fail after logout while ordinary MCP calls remain available.

GitOrigin-RevId: 2d634be3011854b57f73c741bd1ec6b5aed94ee5
2026-10-20 23:03:56 +00:00

85 lines
2.6 KiB
Rust

//! Carries EMA startup cancellation across configuration loading and thread publication.
//! Once published, a thread's existing config refresh gate owns selective revocation.
use std::sync::Arc;
use std::sync::atomic::AtomicBool;
use std::sync::atomic::Ordering;
use tokio_util::sync::CancellationToken;
#[derive(Clone, Debug, Default)]
pub struct McpEmaCancellation(Arc<State>);
#[derive(Debug, Default)]
struct State {
startup: CancellationToken,
owner: CancellationToken,
lifetime: CancellationToken,
published: AtomicBool,
}
impl McpEmaCancellation {
/// Capture before loading configuration so reload can fence a delayed startup.
pub fn pending(startup: CancellationToken, owner: CancellationToken) -> Self {
let lifetime = owner.child_token();
Self(Arc::new(State {
startup,
owner,
lifetime,
published: AtomicBool::new(false),
}))
}
/// A fork gets its own publication state, even when it inherits loaded config.
pub fn for_startup(&self) -> Self {
let pending = Self::pending(self.0.startup.clone(), self.0.owner.clone());
if self.is_cancelled() {
pending.cancel();
}
pending
}
/// A validated session keeps its authority and records the current startup fence
/// for later forks. The session publication gate must protect this replacement.
pub fn refreshed(&self, incoming: &Self) -> Self {
Self(Arc::new(State {
startup: incoming.0.startup.clone(),
owner: self.0.owner.clone(),
lifetime: self.0.lifetime.clone(),
published: AtomicBool::new(true),
}))
}
/// Call while holding the thread registry's publication lock. A reload either
/// cancels this pending snapshot or discovers the published thread for validation.
pub fn publish(&self) {
if !self.0.published.swap(true, Ordering::AcqRel) && self.0.startup.is_cancelled() {
self.cancel();
}
}
pub fn cancel(&self) {
self.0.lifetime.cancel();
}
pub fn is_cancelled(&self) -> bool {
self.0.lifetime.is_cancelled()
|| (!self.0.published.load(Ordering::Acquire) && self.0.startup.is_cancelled())
}
pub fn token(&self) -> CancellationToken {
self.0.lifetime.clone()
}
pub async fn cancelled(&self) {
tokio::select! {
biased;
() = self.0.lifetime.cancelled() => return,
() = self.0.startup.cancelled() => {}
}
if self.0.published.load(Ordering::Acquire) {
self.0.lifetime.cancelled().await;
}
}
}