Skip to content

armgit / moli

Public Imported from GitHub
0

Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust

Support instance-scoped CDP Browser.close shutdown

nengc99d2914c705
diff --git a/moli-protocol-server/src/cdp_writer.rs b/moli-protocol-server/src/cdp_writer.rs
index 88569afdf..c6e57076a 100644
--- a/moli-protocol-server/src/cdp_writer.rs
+++ b/moli-protocol-server/src/cdp_writer.rs
@@ -1,4 +1,4 @@
-use std::time::Instant;
+use std::time::{Duration, Instant};
use axum::extract::ws::{Message, WebSocket};
use futures_util::{SinkExt, stream::SplitSink};
@@ -17,6 +17,7 @@ mod tests;
const DEFAULT_WRITER_QUEUE_CAPACITY: usize = 1024;
const DEFAULT_MAX_PENDING_WRITER_BYTES: usize = 64 * 1024 * 1024;
const DEFAULT_MAX_WRITER_MESSAGE_BYTES: usize = 64 * 1024 * 1024;
+const WRITER_CLOSE_TIMEOUT: Duration = Duration::from_secs(1);
#[derive(Clone)]
pub(crate) struct CdpSocketSink {
@@ -35,6 +36,7 @@ struct ProtocolOutputEnvelope {
enum SocketWriterCommand {
Output(ProtocolOutputEnvelope),
+ Flush(oneshot::Sender<bool>),
CloseAfterFlush,
}
@@ -84,8 +86,21 @@ fn spawn_socket_sink_with_limits(
command
}
};
- let SocketWriterCommand::Output(envelope) = command else {
- break;
+ let envelope = match command {
+ SocketWriterCommand::Output(envelope) => envelope,
+ SocketWriterCommand::CloseAfterFlush => break,
+ SocketWriterCommand::Flush(completed) => {
+ let flushed = tokio::select! {
+ biased;
+ _ = close_rx.changed() => false,
+ result = socket.flush() => result.is_ok(),
+ };
+ let _ = completed.send(flushed);
+ if !flushed {
+ break;
+ }
+ continue;
+ }
};
let ProtocolOutputEnvelope {
message,
@@ -131,10 +146,10 @@ fn spawn_socket_sink_with_limits(
}
match close_signal {
SocketCloseSignal::PeerCloseReceived => {
- let _ = socket.flush().await;
+ let _ = tokio::time::timeout(WRITER_CLOSE_TIMEOUT, socket.flush()).await;
}
SocketCloseSignal::Open | SocketCloseSignal::ImmediateClose => {
- let _ = socket.close().await;
+ let _ = tokio::time::timeout(WRITER_CLOSE_TIMEOUT, socket.close()).await;
}
}
notify_socket_writer_finished(&mut finished_tx);
@@ -151,6 +166,21 @@ fn spawn_socket_sink_with_limits(
}
impl CdpSocketSink {
+ /// Confirms that every preceding output was flushed by the sole writer.
+ /// Callers must bound their wait; a stalled peer must not trigger shutdown.
+ pub(crate) async fn flush(&self) -> bool {
+ let (completed, receiver) = oneshot::channel();
+ if self
+ .output_tx
+ .send(SocketWriterCommand::Flush(completed))
+ .await
+ .is_err()
+ {
+ return false;
+ }
+ receiver.await.unwrap_or(false)
+ }
+
pub(crate) fn enqueue_owned_message(&self, message: Value) -> bool {
let available_pending_bytes = self.pending_byte_budget.available();
let serialization_limit = self.max_message_bytes.min(available_pending_bytes);
diff --git a/moli-protocol-server/src/cdp_writer/tests.rs b/moli-protocol-server/src/cdp_writer/tests.rs
index c4024c301..e18396b11 100644
--- a/moli-protocol-server/src/cdp_writer/tests.rs
+++ b/moli-protocol-server/src/cdp_writer/tests.rs
@@ -67,6 +67,32 @@ fn graceful_close_is_queued_after_existing_output() {
));
}
+#[tokio::test]
+async fn flush_confirmation_is_ordered_after_output_and_propagates_failure() {
+ let (sink, mut output_rx, _close_rx) = test_sink_with_limits(
+ 2,
+ DEFAULT_MAX_PENDING_WRITER_BYTES,
+ DEFAULT_MAX_WRITER_MESSAGE_BYTES,
+ );
+ assert!(sink.enqueue_owned_message(json!({"id": 1, "result": {}})));
+ let pending = tokio::spawn(async move { sink.flush().await });
+ assert!(matches!(
+ output_rx.recv().await,
+ Some(SocketWriterCommand::Output(_))
+ ));
+ let Some(SocketWriterCommand::Flush(completed)) = output_rx.recv().await else {
+ panic!("flush must be queued after preceding output");
+ };
+ assert!(
+ !pending.is_finished(),
+ "queue admission is not a flush confirmation"
+ );
+ completed
+ .send(false)
+ .expect("flush waiter remains attached");
+ assert!(!pending.await.expect("flush task"));
+}
+
#[test]
fn peer_close_signal_has_priority_over_immediate_close() {
let (sink, _output_rx, close_rx) = test_sink();
diff --git a/moli-protocol-server/src/protocol_server/cdp.rs b/moli-protocol-server/src/protocol_server/cdp.rs
index 6257b86ef..4cb29b9f4 100644
--- a/moli-protocol-server/src/protocol_server/cdp.rs
+++ b/moli-protocol-server/src/protocol_server/cdp.rs
@@ -274,8 +274,14 @@ pub(super) async fn ws_browser_upgrade_handler(
return StatusCode::NOT_FOUND.into_response();
}
let owner_registry = state.cdp_owner_registry;
+ let shutdown = state.shutdown;
ws.on_upgrade(move |socket| {
- run_shared_frontend_socket(socket, owner_registry, CdpFrontendSocketKind::Browser)
+ run_shared_frontend_socket(
+ socket,
+ owner_registry,
+ CdpFrontendSocketKind::Browser,
+ shutdown,
+ )
})
}
@@ -296,13 +302,14 @@ pub(super) async fn ws_target_upgrade_handler(
let Some(route) = state.cdp_agent_host_directory.lookup_target(&target_id) else {
return StatusCode::NOT_FOUND.into_response();
};
- target_ws_upgrade_response(ws, target_id, route.endpoint)
+ target_ws_upgrade_response(ws, target_id, route.endpoint, state.shutdown)
}
async fn run_shared_frontend_socket(
socket: WebSocket,
owner_registry: SharedCdpOwnerRegistry,
kind: CdpFrontendSocketKind,
+ shutdown: super::instance_shutdown::InstanceShutdown,
) {
let endpoint = match owner_registry.shared_owner() {
Ok(endpoint) => endpoint,
@@ -311,19 +318,21 @@ async fn run_shared_frontend_socket(
return;
}
};
- run_cdp_frontend_socket(socket, endpoint, kind).await;
+ run_cdp_frontend_socket(socket, endpoint, kind, shutdown).await;
}
fn target_ws_upgrade_response(
ws: WebSocketUpgrade,
target_id: String,
endpoint: crate::cdp_frontend::CdpFrontendEndpoint,
+ shutdown: super::instance_shutdown::InstanceShutdown,
) -> Response {
ws.on_upgrade(move |socket| async move {
run_cdp_frontend_socket(
socket,
endpoint,
CdpFrontendSocketKind::Target { target_id },
+ shutdown,
)
.await;
})
diff --git a/moli-protocol-server/src/protocol_server/cdp_socket.rs b/moli-protocol-server/src/protocol_server/cdp_socket.rs
index e5f34edf3..d3aa40b74 100644
--- a/moli-protocol-server/src/protocol_server/cdp_socket.rs
+++ b/moli-protocol-server/src/protocol_server/cdp_socket.rs
@@ -1,8 +1,15 @@
use axum::extract::ws::{Message, WebSocket};
use futures_util::StreamExt;
+use serde_json::{Value, json};
use std::time::Duration;
-use crate::{cdp_frontend::CdpFrontendEndpoint, cdp_writer::spawn_socket_sink};
+use super::instance_shutdown::InstanceShutdown;
+use crate::{
+ cdp_frontend::CdpFrontendEndpoint,
+ cdp_writer::{CdpSocketSink, spawn_socket_sink},
+};
+
+const BROWSER_CLOSE_FLUSH_BUDGET: Duration = Duration::from_secs(1);
pub(super) enum CdpFrontendSocketKind {
Browser,
@@ -13,7 +20,12 @@ pub(super) async fn run_cdp_frontend_socket(
socket: WebSocket,
endpoint: CdpFrontendEndpoint,
kind: CdpFrontendSocketKind,
+ shutdown: InstanceShutdown,
) -> bool {
+ let Some(_connection) = shutdown.connection() else {
+ return false;
+ };
+ let browser_socket = matches!(&kind, CdpFrontendSocketKind::Browser);
let (socket_tx, mut socket_rx) = socket.split();
let (sink, mut writer_finished_rx) = spawn_socket_sink(socket_tx);
let socket_sink = sink.clone();
@@ -41,6 +53,7 @@ pub(super) async fn run_cdp_frontend_socket(
let exit = loop {
tokio::select! {
+ _ = shutdown.requested() => break CdpSocketExit::TransportClose,
_ = endpoint.wait_for_shutdown() => break CdpSocketExit::TransportClose,
_ = &mut writer_finished_rx => break CdpSocketExit::WriterFinished,
maybe_message = socket_rx.next() => {
@@ -49,6 +62,16 @@ pub(super) async fn run_cdp_frontend_socket(
};
match message {
Message::Text(text) => {
+ if let Some((response, should_close)) = browser_close_response(&text, browser_socket) {
+ if should_close {
+ acknowledge_browser_close(&socket_sink, &shutdown, response).await;
+ break CdpSocketExit::TransportClose;
+ }
+ if !socket_sink.enqueue_owned_message(response) {
+ break CdpSocketExit::TransportClose;
+ }
+ continue;
+ }
if !endpoint.command(frontend_id, text.to_string()).await {
break CdpSocketExit::TransportClose;
}
@@ -74,6 +97,47 @@ pub(super) async fn run_cdp_frontend_socket(
true
}
+// Instance control belongs to the browser-root transport, not an attached page
+// or an individual owner actor. Every other command keeps its existing route.
+fn browser_close_response(text: &str, browser_socket: bool) -> Option<(Value, bool)> {
+ if !browser_socket {
+ return None;
+ }
+ let command: Value = serde_json::from_str(text).ok()?;
+ if command.get("method")?.as_str()? != "Browser.close" || command.get("sessionId").is_some() {
+ return None;
+ }
+ let id = command.get("id")?.as_u64()?;
+ if command
+ .get("params")
+ .is_some_and(|params| !params.as_object().is_some_and(serde_json::Map::is_empty))
+ {
+ return Some((
+ json!({"id": id, "error": {"code": -32602, "message": "InvalidParams"}}),
+ false,
+ ));
+ }
+ Some((json!({"id": id, "result": {}}), true))
+}
+
+async fn acknowledge_browser_close(
+ sink: &CdpSocketSink,
+ shutdown: &InstanceShutdown,
+ response: Value,
+) -> bool {
+ if !sink.enqueue_owned_message(response) {
+ return false;
+ }
+ if !matches!(
+ tokio::time::timeout(BROWSER_CLOSE_FLUSH_BUDGET, sink.flush()).await,
+ Ok(true)
+ ) {
+ return false;
+ }
+ shutdown.request();
+ true
+}
+
enum CdpSocketExit {
WriterFinished,
PeerClose,
@@ -120,3 +184,55 @@ impl Drop for CdpFrontendDetachGuard {
self.detach();
}
}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn only_a_valid_browser_root_close_can_request_instance_shutdown() {
+ for params in [
+ json!({"id": 7, "method": "Browser.close"}),
+ json!({"id": 7, "method": "Browser.close", "params": {}}),
+ ] {
+ let (response, close) = browser_close_response(&params.to_string(), true).unwrap();
+ assert!(close);
+ assert_eq!(response, json!({"id": 7, "result": {}}));
+ }
+ for command in [
+ json!({"id": 7, "method": "Browser.close", "sessionId": "page"}),
+ json!({"id": 7, "method": "Browser.close", "sessionId": null}),
+ json!({"id": -1, "method": "Browser.close"}),
+ json!({"id": "7", "method": "Browser.close"}),
+ json!({"method": "Browser.close"}),
+ json!({"id": 7, "method": "browser.close"}),
+ ] {
+ assert!(browser_close_response(&command.to_string(), true).is_none());
+ }
+ assert!(browser_close_response(r#"{"id":7,"method":"Browser.close"}"#, false).is_none());
+ for params in [json!(null), json!([]), json!({"force": true})] {
+ let (response, close) = browser_close_response(
+ &json!({"id": 7, "method": "Browser.close", "params": params}).to_string(),
+ true,
+ )
+ .unwrap();
+ assert!(!close);
+ assert_eq!(response["error"]["code"], -32602);
+ }
+ }
+
+ #[tokio::test]
+ async fn failed_or_unconfirmed_flush_does_not_stop_the_instance() {
+ let shutdown = InstanceShutdown::default();
+ let sink = CdpSocketSink::for_test();
+ assert!(!acknowledge_browser_close(&sink, &shutdown, json!({"id": 1, "result": {}})).await);
+ let (sink, _stalled_writer) = CdpSocketSink::with_stalled_writer_for_test(2);
+ assert!(!acknowledge_browser_close(&sink, &shutdown, json!({"id": 2, "result": {}})).await);
+ assert!(
+ tokio::time::timeout(Duration::from_millis(10), shutdown.requested())
+ .await
+ .is_err()
+ );
+ assert!(shutdown.connection().is_some());
+ }
+}
diff --git a/moli-protocol-server/src/protocol_server/instance_shutdown.rs b/moli-protocol-server/src/protocol_server/instance_shutdown.rs
new file mode 100644
index 000000000..4a326c46c
--- /dev/null
+++ b/moli-protocol-server/src/protocol_server/instance_shutdown.rs
@@ -0,0 +1,102 @@
+use tokio::sync::watch;
+
+/// One server instance's persistent stop signal and admitted WebSocket workers.
+/// It is not an ownership or authentication mechanism for protocol clients.
+#[derive(Clone, Debug)]
+pub(super) struct InstanceShutdown {
+ state: watch::Sender<ShutdownState>,
+}
+
+#[derive(Clone, Copy, Debug, Default)]
+struct ShutdownState {
+ requested: bool,
+ connections: usize,
+}
+
+impl Default for InstanceShutdown {
+ fn default() -> Self {
+ let (state, _) = watch::channel(ShutdownState::default());
+ Self { state }
+ }
+}
+
+impl InstanceShutdown {
+ pub(super) fn request(&self) {
+ self.state.send_modify(|state| state.requested = true);
+ }
+
+ pub(super) async fn requested(&self) {
+ let mut receiver = self.state.subscribe();
+ let _ = receiver.wait_for(|state| state.requested).await;
+ }
+
+ pub(super) fn connection(&self) -> Option<InstanceConnection> {
+ let mut admitted = false;
+ self.state.send_if_modified(|state| {
+ if state.requested {
+ return false;
+ }
+ let Some(count) = state.connections.checked_add(1) else {
+ return false;
+ };
+ state.connections = count;
+ admitted = true;
+ true
+ });
+ admitted.then(|| InstanceConnection(self.clone()))
+ }
+
+ pub(super) async fn drained(&self) {
+ let mut receiver = self.state.subscribe();
+ let _ = receiver.wait_for(|state| state.connections == 0).await;
+ }
+}
+
+pub(super) struct InstanceConnection(InstanceShutdown);
+
+impl Drop for InstanceConnection {
+ fn drop(&mut self) {
+ self.0.state.send_modify(|state| state.connections -= 1);
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use std::time::Duration;
+ use tokio::time::timeout;
+
+ #[tokio::test]
+ async fn shutdown_is_persistent_and_repeated_requests_do_not_admit_connections() {
+ let instance = InstanceShutdown::default();
+ let connection = instance.connection().expect("initial connection admitted");
+ instance.request();
+ instance.request();
+ timeout(Duration::from_millis(100), instance.requested())
+ .await
+ .expect("late subscriber observes stop");
+ assert!(instance.connection().is_none());
+ assert!(
+ timeout(Duration::from_millis(10), instance.drained())
+ .await
+ .is_err()
+ );
+ drop(connection);
+ timeout(Duration::from_millis(100), instance.drained())
+ .await
+ .expect("all workers released");
+ }
+
+ #[tokio::test]
+ async fn shutdown_does_not_affect_another_instance() {
+ let first = InstanceShutdown::default();
+ let second = InstanceShutdown::default();
+ first.request();
+ assert!(second.connection().is_some());
+ assert!(
+ timeout(Duration::from_millis(10), second.requested())
+ .await
+ .is_err()
+ );
+ }
+}
diff --git a/moli-protocol-server/src/protocol_server/mod.rs b/moli-protocol-server/src/protocol_server/mod.rs
index 88b54b135..3738b8ba3 100644
--- a/moli-protocol-server/src/protocol_server/mod.rs
+++ b/moli-protocol-server/src/protocol_server/mod.rs
@@ -1,8 +1,10 @@
#[cfg(test)]
use std::path::PathBuf;
use std::{
+ future::IntoFuture,
net::SocketAddr,
sync::{Arc, atomic::AtomicU64},
+ time::Duration,
};
use anyhow::Result;
@@ -10,9 +12,10 @@ use anyhow::{Context, anyhow};
use axum::{
Router,
body::Body,
+ extract::State,
http::{HeaderValue, Request, header},
middleware::{self, Next},
- response::Response,
+ response::{IntoResponse, Response},
routing::{any, get, post, put},
serve::ListenerExt,
};
@@ -39,6 +42,7 @@ mod cdp;
mod cdp_agent_host;
mod cdp_owner;
mod cdp_socket;
+mod instance_shutdown;
mod protocol_local_executor;
mod tcp_options;
mod webdriver_bidi;
@@ -47,6 +51,7 @@ mod webdriver_files;
use cdp_agent_host::SharedCdpAgentHostDirectory;
use cdp_owner::SharedCdpOwnerRegistry;
+use instance_shutdown::InstanceShutdown;
use webdriver_bidi::SharedBidiSessionRegistry;
use webdriver_classic::SharedClassicSessionRegistry;
@@ -158,19 +163,50 @@ impl ProtocolServer {
self.config.screencast_interval_ms,
)?;
- let cdp_owner_registry = app_state.cdp_owner_registry.clone();
- let app = build_router(app_state);
+ serve_listener(listener, app_state).await
+ }
+}
- let listener = listener.tap_io(|tcp_stream| {
- tcp_options::configure_accepted_protocol_stream(tcp_stream);
+/// Shared by the executable and instance-lifecycle integration tests.
+async fn serve_listener(listener: TcpListener, app_state: AppState) -> Result<()> {
+ const SHUTDOWN_BUDGET: Duration = Duration::from_secs(5);
+ let shutdown = app_state.shutdown.clone();
+ let cdp_owner_registry = app_state.cdp_owner_registry.clone();
+ let classic_session_registry = app_state.classic_session_registry.clone();
+ let cookie_profile = app_state.cookie_profile.clone();
+ let listener =
+ listener.tap_io(|stream| tcp_options::configure_accepted_protocol_stream(stream));
+ let stop_accepting = shutdown.clone();
+ let serving = axum::serve(listener, build_router(app_state))
+ .with_graceful_shutdown(async move { stop_accepting.requested().await })
+ .into_future();
+ tokio::pin!(serving);
+ let completed = tokio::select! {
+ result = &mut serving => Some(result),
+ _ = shutdown.requested() => None,
+ };
+ shutdown.request();
+ tokio::time::timeout(SHUTDOWN_BUDGET, async {
+ let (_, result) = tokio::join!(cdp_owner_registry.shutdown(), async {
+ // Drain in-flight HTTP requests before taking the final Classic
+ // session set. New requests and upgraded sockets are rejected.
+ match completed {
+ Some(result) => result,
+ None => (&mut serving).await,
+ }
+ .context("protocol server failed")?;
+ classic_session_registry.shutdown(&cookie_profile).await?;
+ shutdown.drained().await;
+ Ok(())
});
- let result = axum::serve(listener, app).await;
- cdp_owner_registry.shutdown().await;
- result.context("protocol server failed")
- }
+ result
+ })
+ .await
+ .context("protocol server shutdown timed out; checkpoints may be incomplete")?
}
fn build_router(app_state: AppState) -> Router {
+ let shutdown = app_state.shutdown.clone();
Router::new()
.route("/status", get(webdriver_classic::webdriver_classic_status))
.route("/status/", get(webdriver_classic::webdriver_classic_status))
@@ -686,6 +722,18 @@ fn build_router(app_state: AppState) -> Router {
.layer(middleware::from_fn(
classic_webdriver_response_headers_middleware,
))
+ .layer(middleware::from_fn_with_state(shutdown, instance_admission))
+}
+
+async fn instance_admission(
+ State(shutdown): State<InstanceShutdown>,
+ request: Request<Body>,
+ next: Next,
+) -> Response {
+ let Some(_connection) = shutdown.connection() else {
+ return axum::http::StatusCode::SERVICE_UNAVAILABLE.into_response();
+ };
+ next.run(request).await
}
async fn classic_webdriver_response_headers_middleware(
@@ -737,6 +785,7 @@ fn is_websocket_upgrade_request(request: &Request<Body>) -> bool {
#[derive(Clone)]
struct AppState {
+ shutdown: InstanceShutdown,
browser_ws_url: String,
page_ws_url: String,
bidi_ws_url: String,
@@ -810,6 +859,7 @@ impl AppState {
screencast_interval_ms,
);
Self {
+ shutdown: InstanceShutdown::default(),
browser_ws_url: format!("ws://{addr}/devtools/browser/{DEFAULT_BROWSER_ID}"),
page_ws_url: format!("ws://{addr}/devtools/page/{DEFAULT_TARGET_ID}"),
bidi_ws_url: format!("ws://{addr}/session"),
diff --git a/moli-protocol-server/src/protocol_server/tests/cdp_dynamic_page.rs b/moli-protocol-server/src/protocol_server/tests/cdp_dynamic_page.rs
index b86eb9580..dea98a6fb 100644
--- a/moli-protocol-server/src/protocol_server/tests/cdp_dynamic_page.rs
+++ b/moli-protocol-server/src/protocol_server/tests/cdp_dynamic_page.rs
@@ -4,6 +4,7 @@ mod auto_attach_startup;
mod auxiliary_page_identity;
mod auxiliary_page_retirement;
mod blank_navigation_inheritance;
+mod browser_close;
mod noopener_blank_inheritance;
mod popup_navigation_referrer;
diff --git a/moli-protocol-server/src/protocol_server/tests/cdp_dynamic_page/browser_close.rs b/moli-protocol-server/src/protocol_server/tests/cdp_dynamic_page/browser_close.rs
new file mode 100644
index 000000000..3ff276900
--- /dev/null
+++ b/moli-protocol-server/src/protocol_server/tests/cdp_dynamic_page/browser_close.rs
@@ -0,0 +1,249 @@
+use super::*;
+
+async fn instance(
+ cookie_path: Option<PathBuf>,
+) -> (
+ SocketAddr,
+ tokio::task::JoinHandle<anyhow::Result<()>>,
+ AppState,
+) {
+ let listener = TcpListener::bind("127.0.0.1:0")
+ .await
+ .expect("bind owned instance");
+ let addr = listener.local_addr().expect("owned instance address");
+ let state = AppState::from_parts(
+ addr,
+ SharedCookieProfile::new(Vec::new(), cookie_path.into_iter().collect()),
+ Arc::new(StoragePartitionState::open(None).expect("in-memory storage")),
+ protocol_server_test_runtime_config(
+ FetchConfig::default(),
+ OptionalResourceFetchMask::NONE,
+ ),
+ crate::config::DEFAULT_SCREENCAST_INTERVAL_MS,
+ );
+ let serving = state.clone();
+ let task = tokio::spawn(async move { serve_listener(listener, serving).await });
+ (addr, task, state)
+}
+
+async fn browser(addr: SocketAddr) -> TestCdpSocket {
+ connect_async(format!("ws://{addr}/devtools/browser/{DEFAULT_BROWSER_ID}"))
+ .await
+ .expect("connect owned browser")
+ .0
+}
+
+async fn joined(task: tokio::task::JoinHandle<anyhow::Result<()>>) {
+ timeout(Duration::from_secs(7), task)
+ .await
+ .expect("instance exits within total shutdown budget")
+ .expect("server task joins")
+ .expect("server completes shutdown without a timeout or join error");
+}
+
+async fn closed(socket: &mut TestCdpSocket) {
+ timeout(Duration::from_secs(2), async {
+ while let Some(Ok(message)) = socket.next().await {
+ if matches!(message, WsMessage::Close(_)) {
+ break;
+ }
+ }
+ })
+ .await
+ .expect("owned socket terminates");
+}
+
+async fn close_instance(socket: &mut TestCdpSocket, id: u64) {
+ let response = send_cdp_command(socket, id, "Browser.close", None, json!({})).await;
+ assert_eq!(
+ response_by_id(&response, id),
+ &json!({"id": id, "result": {}}),
+ "the close response must arrive before transport EOF"
+ );
+}
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn browser_close_joins_its_listener_connections_and_checkpoint_only() {
+ let profile = TempDir::new("browser-close-checkpoint");
+ fs::create_dir_all(&profile.path).expect("own checkpoint directory");
+ let cookie_path = profile.path.join("cookies.json");
+ let (addr, task, state) = instance(Some(cookie_path.clone())).await;
+ let (other_addr, other_task, other_state) = instance(None).await;
+ let mut root = browser(addr).await;
+ let mut other_root = browser(other_addr).await;
+ let first = create_dynamic_target(&mut root, 1).await;
+ let _second = create_dynamic_target(&mut root, 2).await;
+ let mut page = connect_dynamic_page(addr, &first).await;
+ let cookie = send_cdp_command(&mut page, 3, "Network.setCookie", None,
+ json!({"name": "owned-close", "value": "persisted", "url": "https://browser-close.invalid/"})).await;
+ assert!(response_by_id(&cookie, 3)["error"].is_null());
+
+ // Keep both independent BiDi and Classic-attached BiDi sockets open while
+ // closing the instance; upgraded connections cannot be left detached.
+ let (mut bidi, _) = connect_async(format!("ws://{addr}/session"))
+ .await
+ .expect("BiDi");
+ let bidi_session = send_cdp_command(&mut bidi, 4, "session.new", None, json!({})).await;
+ assert_eq!(response_by_id(&bidi_session, 4)["type"], "success");
+ let classic = build_router(state.clone())
+ .oneshot(
+ Request::builder()
+ .method(Method::POST)
+ .uri("/session")
+ .header(header::CONTENT_TYPE, "application/json")
+ .body(Body::from("{}"))
+ .expect("Classic session request"),
+ )
+ .await
+ .expect("Classic response");
+ assert_eq!(classic.status(), StatusCode::OK);
+ let classic: serde_json::Value = serde_json::from_slice(
+ &to_bytes(classic.into_body(), 65536)
+ .await
+ .expect("Classic body"),
+ )
+ .expect("Classic JSON");
+ let classic_id = classic["value"]["sessionId"].as_str().expect("Classic ID");
+ let (mut attached, _) = connect_async(format!("ws://{addr}/session/{classic_id}"))
+ .await
+ .expect("attached BiDi");
+ let attached_ready =
+ send_cdp_command(&mut attached, 5, "browser.getUserContexts", None, json!({})).await;
+ assert_eq!(response_by_id(&attached_ready, 5)["type"], "success");
+ assert!(state.classic_session_registry.has_session(classic_id));
+
+ close_instance(&mut root, 100).await;
+ joined(task).await;
+ closed(&mut root).await;
+ closed(&mut page).await;
+ closed(&mut bidi).await;
+ closed(&mut attached).await;
+ assert!(
+ tokio::net::TcpStream::connect(addr).await.is_err(),
+ "closed listener must not accept"
+ );
+ assert_eq!(state.cdp_owner_registry.owner_count(), 0);
+ assert!(!state.classic_session_registry.has_session(classic_id));
+ assert_eq!(state.bidi_session_registry.lock().active_session_count(), 0);
+ let persisted = cookie_cache::load_cookie_cache(&cookie_path).expect("checkpoint on disk");
+ assert!(
+ persisted
+ .iter()
+ .any(|cookie| cookie.name == "owned-close" && cookie.value == "persisted")
+ );
+
+ let version =
+ send_cdp_command(&mut other_root, 101, "Browser.getVersion", None, json!({})).await;
+ assert!(response_by_id(&version, 101)["result"]["product"].is_string());
+ assert!(!other_task.is_finished(), "another instance survives");
+ assert!(other_state.shutdown.connection().is_some());
+ close_instance(&mut other_root, 102).await;
+ joined(other_task).await;
+}
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn page_attached_invalid_close_and_frontend_disconnect_do_not_stop_instance() {
+ let (addr, task, state) = instance(None).await;
+ let mut root = browser(addr).await;
+ let target = create_dynamic_target(&mut root, 1).await;
+ let mut page = connect_dynamic_page(addr, &target).await;
+ let attach = send_cdp_command(
+ &mut root,
+ 2,
+ "Target.attachToTarget",
+ None,
+ json!({"targetId": target, "flatten": true}),
+ )
+ .await;
+ let session = response_by_id(&attach, 2)["result"]["sessionId"]
+ .as_str()
+ .expect("attached ID");
+ let page_close = send_cdp_command(&mut page, 3, "Browser.close", None, json!({})).await;
+ assert!(response_by_id(&page_close, 3)["error"].is_object());
+ let attached_close =
+ send_cdp_command(&mut root, 4, "Browser.close", Some(session), json!({})).await;
+ assert!(response_by_id(&attached_close, 4)["error"].is_object());
+ let invalid =
+ send_cdp_command(&mut root, 5, "Browser.close", None, json!({"force": true})).await;
+ assert_eq!(response_by_id(&invalid, 5)["error"]["code"], -32602);
+ root.close(None).await.expect("disconnect viewer only");
+ closed(&mut root).await;
+ let alive = send_cdp_command(
+ &mut page,
+ 6,
+ "Runtime.evaluate",
+ None,
+ json!({"expression": "21 * 2"}),
+ )
+ .await;
+ assert_eq!(response_by_id(&alive, 6)["result"]["result"]["value"], 42);
+ assert!(!task.is_finished());
+ assert!(state.shutdown.connection().is_some());
+ let mut replacement = browser(addr).await;
+ close_instance(&mut replacement, 7).await;
+ joined(task).await;
+}
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn simultaneous_close_requests_finish_once_without_hanging() {
+ let (addr, task, state) = instance(None).await;
+ let mut first = browser(addr).await;
+ let mut second = browser(addr).await;
+ let (left, right) = tokio::join!(
+ first.send(WsMessage::Text(
+ json!({"id": 1, "method": "Browser.close"})
+ .to_string()
+ .into()
+ )),
+ second.send(WsMessage::Text(
+ json!({"id": 2, "method": "Browser.close", "params": {}})
+ .to_string()
+ .into()
+ ))
+ );
+ assert!(left.is_ok() || right.is_ok());
+ async fn accepted(socket: &mut TestCdpSocket) -> bool {
+ timeout(Duration::from_secs(2), async {
+ while let Some(Ok(message)) = socket.next().await {
+ if let WsMessage::Text(text) = message {
+ let response: serde_json::Value =
+ serde_json::from_str(&text).expect("close JSON");
+ if response["result"] == json!({}) {
+ return true;
+ }
+ }
+ }
+ false
+ })
+ .await
+ .unwrap_or(false)
+ }
+ let (left, right) = tokio::join!(accepted(&mut first), accepted(&mut second));
+ assert!(
+ left || right,
+ "at least one close is acknowledged before exit"
+ );
+ joined(task).await;
+ assert_eq!(state.cdp_owner_registry.owner_count(), 0);
+ assert!(tokio::net::TcpStream::connect(addr).await.is_err());
+}
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn incomplete_worker_drain_is_bounded_and_not_reported_as_clean_shutdown() {
+ let (addr, task, state) = instance(None).await;
+ let held_worker = state
+ .shutdown
+ .connection()
+ .expect("controlled stalled worker");
+ let mut root = browser(addr).await;
+ close_instance(&mut root, 1).await;
+ let error = timeout(Duration::from_secs(7), task)
+ .await
+ .expect("bounded shutdown")
+ .expect("server task joins")
+ .expect_err("stalled worker cannot be clean shutdown");
+ assert!(error.to_string().contains("checkpoints may be incomplete"));
+ assert_eq!(state.cdp_owner_registry.owner_count(), 0);
+ assert!(tokio::net::TcpStream::connect(addr).await.is_err());
+ drop(held_worker);
+}
diff --git a/moli-protocol-server/src/protocol_server/webdriver_bidi.rs b/moli-protocol-server/src/protocol_server/webdriver_bidi.rs
index 49e8e146e..820de530d 100644
--- a/moli-protocol-server/src/protocol_server/webdriver_bidi.rs
+++ b/moli-protocol-server/src/protocol_server/webdriver_bidi.rs
@@ -57,7 +57,7 @@ use crate::cdp_scheduler::{
use super::webdriver_files::selected_files_from_paths;
use super::{
- AppState, CookieProfileCommit, SharedCookieProfile,
+ AppState, CookieProfileCommit, SharedCookieProfile, instance_shutdown::InstanceShutdown,
protocol_local_executor::spawn_protocol_local_task,
};
@@ -71,6 +71,7 @@ pub(super) async fn ws_bidi_session_upgrade_handler(
let web_socket_url = state.bidi_ws_url;
let session_registry = state.bidi_session_registry;
let cookie_profile = state.cookie_profile;
+ let shutdown = state.shutdown;
let navigation_runtime_config = NavigationRuntimeConfig::new_with_layout_configuration(
state.fetch_config,
state.optional_resource_fetch_mask,
@@ -86,6 +87,7 @@ pub(super) async fn ws_bidi_session_upgrade_handler(
initial_cookie_snapshot,
initial_storage_partition,
navigation_runtime_config,
+ shutdown,
)
})
}
@@ -114,6 +116,9 @@ pub(super) async fn ws_bidi_existing_session_upgrade_handler(
.map(str::to_owned);
let web_socket_url = format!("{}/{}", state.bidi_ws_url.trim_end_matches('/'), session_id);
ws.on_upgrade(move |socket| async move {
+ let Some(_connection) = state.shutdown.connection() else {
+ return;
+ };
if !runtime
.attach_bidi_socket(
socket,
@@ -137,7 +142,11 @@ async fn handle_bidi_session_socket(
initial_cookie_snapshot: Vec<StoredCookie>,
initial_storage_partition: CdpInitialStoragePartition,
navigation_runtime_config: NavigationRuntimeConfig,
+ shutdown: InstanceShutdown,
) {
+ let Some(_connection) = shutdown.connection() else {
+ return;
+ };
let cookie_commit = spawn_protocol_local_task("bidi-socket", move || {
handle_bidi_session_socket_local(
socket,
@@ -146,6 +155,7 @@ async fn handle_bidi_session_socket(
initial_cookie_snapshot,
initial_storage_partition,
navigation_runtime_config,
+ shutdown,
)
})
.await;
@@ -169,6 +179,7 @@ async fn handle_bidi_session_socket_local(
initial_cookie_snapshot: Vec<StoredCookie>,
initial_storage_partition: CdpInitialStoragePartition,
navigation_runtime_config: NavigationRuntimeConfig,
+ shutdown: InstanceShutdown,
) -> CookieProfileCommit {
let mut actor = BidiSocketActor::new(socket, web_socket_url);
let (mut scheduler, mut receivers) = CdpScheduler::new_with_initial_state_runtime_config(
@@ -182,6 +193,7 @@ async fn handle_bidi_session_socket_local(
adapter_scheduler.schedule_turn_if_needed(&scheduler, page_javascript_blocked);
tokio::select! {
biased;
+ _ = shutdown.requested() => break,
maybe_message = actor.socket.recv() => {
let Some(message) = maybe_message else {
break;
diff --git a/moli-protocol-server/src/protocol_server/webdriver_classic.rs b/moli-protocol-server/src/protocol_server/webdriver_classic.rs
index 609c13897..604e5a2b3 100644
--- a/moli-protocol-server/src/protocol_server/webdriver_classic.rs
+++ b/moli-protocol-server/src/protocol_server/webdriver_classic.rs
@@ -1607,6 +1607,12 @@ pub(super) async fn webdriver_classic_new_session(
State(state): State<AppState>,
body: Bytes,
) -> Response {
+ let Some(instance_connection) = state.shutdown.connection() else {
+ return classic_error_into_response(ClassicError::new(
+ ClassicErrorCode::SessionNotCreated,
+ "protocol server is shutting down",
+ ));
+ };
let params = match classic_json_body(&body) {
Ok(params) => params,
Err(error) => return classic_error_into_response(error),
@@ -1671,6 +1677,7 @@ pub(super) async fn webdriver_classic_new_session(
state.subframe_loading_enabled,
state.layout_configuration,
),
+ instance_connection,
);
let create_context = ClassicDevToolsCommandContext::new(session.session_id.as_str());
let target_id = match runtime
diff --git a/moli-protocol-server/src/protocol_server/webdriver_classic/state.rs b/moli-protocol-server/src/protocol_server/webdriver_classic/state.rs
index 2358a7d4a..2c1fae1d7 100644
--- a/moli-protocol-server/src/protocol_server/webdriver_classic/state.rs
+++ b/moli-protocol-server/src/protocol_server/webdriver_classic/state.rs
@@ -37,7 +37,10 @@ use crate::cdp_scheduler::{
use super::super::webdriver_bidi::{
BidiSocketActor, BidiSocketActorInput, SharedBidiSessionRegistry,
};
-use super::super::{CookieProfileCommit, protocol_local_executor::spawn_protocol_local_task};
+use super::super::{
+ CookieProfileCommit, SharedCookieProfile, instance_shutdown::InstanceConnection,
+ protocol_local_executor::spawn_protocol_local_task,
+};
const CLASSIC_SCRIPT_TERMINATION_TIMEOUT: Duration = Duration::from_secs(5);
@@ -47,6 +50,35 @@ pub(in crate::protocol_server) struct SharedClassicSessionRegistry {
}
impl SharedClassicSessionRegistry {
+ pub(in crate::protocol_server) async fn shutdown(
+ &self,
+ cookie_profile: &SharedCookieProfile,
+ ) -> anyhow::Result<()> {
+ let runtimes = {
+ let mut manager = self.inner.lock();
+ let session_ids = manager.runtimes.keys().cloned().collect::<Vec<_>>();
+ session_ids
+ .iter()
+ .filter_map(|id| manager.release_session(id))
+ .collect::<Vec<_>>()
+ };
+ let commits = futures_util::future::join_all(
+ runtimes
+ .into_iter()
+ .map(ClassicSessionRuntimeHandle::shutdown_and_join),
+ )
+ .await;
+ let mut result = Ok(());
+ for commit in commits {
+ if let Err(error) = commit.and_then(|commit| cookie_profile.commit_and_save(commit))
+ && result.is_ok()
+ {
+ result = Err(error);
+ }
+ }
+ result
+ }
+
pub(super) fn lock(&self) -> parking_lot::MutexGuard<'_, ClassicSessionManager> {
self.inner.lock()
}
@@ -473,6 +505,7 @@ impl ClassicSessionBinding {
#[derive(Debug, Clone)]
pub(in crate::protocol_server) struct ClassicSessionRuntimeHandle {
tx: mpsc::UnboundedSender<ClassicSessionRuntimeRequest>,
+ completion: Arc<tokio::sync::Mutex<Option<oneshot::Receiver<CookieProfileCommit>>>>,
}
impl ClassicSessionRuntimeHandle {
@@ -480,17 +513,24 @@ impl ClassicSessionRuntimeHandle {
initial_cookie_snapshot: Vec<StoredCookie>,
initial_storage_partition: CdpInitialStoragePartition,
navigation_runtime_config: NavigationRuntimeConfig,
+ instance_connection: InstanceConnection,
) -> Self {
let (tx, rx) = mpsc::unbounded_channel();
- let _runtime_finished_rx = spawn_protocol_local_task("classic-session", move || {
- classic_session_runtime_loop(
- rx,
- initial_cookie_snapshot,
- initial_storage_partition,
- navigation_runtime_config,
- )
- });
- Self { tx }
+ let runtime_finished_rx =
+ spawn_protocol_local_task("classic-session", move || async move {
+ let _instance_connection = instance_connection;
+ classic_session_runtime_loop(
+ rx,
+ initial_cookie_snapshot,
+ initial_storage_partition,
+ navigation_runtime_config,
+ )
+ .await
+ });
+ Self {
+ tx,
+ completion: Arc::new(tokio::sync::Mutex::new(Some(runtime_finished_rx))),
+ }
}
pub(super) async fn execute(
@@ -811,6 +851,19 @@ impl ClassicSessionRuntimeHandle {
.unwrap_or_else(|_| CookieProfileCommit::unchanged())
}
+ async fn shutdown_and_join(self) -> anyhow::Result<CookieProfileCommit> {
+ let completion = self.completion.clone();
+ let _ = self.shutdown().await;
+ let receiver = completion
+ .lock()
+ .await
+ .take()
+ .ok_or_else(|| anyhow::anyhow!("Classic runtime completion already consumed"))?;
+ receiver
+ .await
+ .map_err(|_| anyhow::anyhow!("Classic runtime stopped before checkpoint completion"))
+ }
+
pub(in crate::protocol_server) async fn attach_bidi_socket(
&self,
socket: WebSocket,