Merge branch 'main' into f_cache_env_file

Author: marshallwalker

cli/main.rs

@@ -292,7 +292,7 @@ async fn run_subcommand(
       }
     }),
     DenoSubcommand::Serve(serve_flags) => spawn_subcommand(async move {
-      tools::serve::serve(flags, serve_flags).await
+      tools::serve::serve(flags, serve_flags, unconfigured_runtime, roots).await
     }),
     DenoSubcommand::Task(task_flags) => spawn_subcommand(async {
       tools::task::execute_script(flags, task_flags).await
@@ -610,6 +610,8 @@ fn wait_for_start(
   Some(async move {
     use tokio::io::AsyncBufReadExt;
     use tokio::io::AsyncRead;
+    use tokio::io::AsyncWrite;
+    use tokio::io::AsyncWriteExt;
     use tokio::io::BufReader;
     use tokio::net::TcpListener;
     use tokio::net::UnixSocket;
@@ -630,18 +632,23 @@ fn wait_for_start(
       vec![],
     );
 
-    let stream: Box<dyn AsyncRead + Unpin> = match addr.split_once(':') {
+    let (rx, mut tx): (
+      Box<dyn AsyncRead + Unpin>,
+      Box<dyn AsyncWrite + Send + Unpin>,
+    ) = match addr.split_once(':') {
       Some(("tcp", addr)) => {
         let listener = TcpListener::bind(addr).await?;
         let (stream, _) = listener.accept().await?;
-        Box::new(stream)
+        let (rx, tx) = stream.into_split();
+        (Box::new(rx), Box::new(tx))
       }
       Some(("unix", path)) => {
         let socket = UnixSocket::new_stream()?;
         socket.bind(path)?;
         let listener = socket.listen(1)?;
         let (stream, _) = listener.accept().await?;
-        Box::new(stream)
+        let (rx, tx) = stream.into_split();
+        (Box::new(rx), Box::new(tx))
       }
       Some(("vsock", addr)) => {
         let Some((cid, port)) = addr.split_once(':') else {
@@ -652,17 +659,28 @@ fn wait_for_start(
         let addr = VsockAddr::new(cid, port);
         let listener = VsockListener::bind(addr)?;
         let (stream, _) = listener.accept().await?;
-        Box::new(stream)
+        let (rx, tx) = stream.into_split();
+        (Box::new(rx), Box::new(tx))
       }
       _ => {
         deno_core::anyhow::bail!("invalid control sock");
       }
     };
 
-    let mut stream = BufReader::new(stream);
-
     let mut buf = Vec::with_capacity(1024);
-    stream.read_until(b'\n', &mut buf).await?;
+    BufReader::new(rx).read_until(b'\n', &mut buf).await?;
+
+    tokio::spawn(async move {
+      deno_runtime::deno_http::SERVE_NOTIFIER.notified().await;
+
+      #[derive(deno_core::serde::Serialize)]
+      enum Event {
+        Serving,
+      }
+
+      let buf = deno_core::serde_json::to_vec(&Event::Serving).unwrap();
+      let _ = tx.write_all(&buf).await;
+    });
 
     #[derive(deno_core::serde::Deserialize)]
     struct Start {

cli/tools/serve.rs

@@ -7,6 +7,8 @@ use deno_core::error::AnyError;
 use deno_core::futures::FutureExt;
 use deno_core::futures::TryFutureExt;
 use deno_core::ModuleSpecifier;
+use deno_lib::worker::LibWorkerFactoryRoots;
+use deno_runtime::UnconfiguredRuntime;
 
 use super::run::check_permission_before_script;
 use super::run::maybe_npm_install;
@@ -20,6 +22,8 @@ use crate::worker::CliMainWorkerFactory;
 pub async fn serve(
   flags: Arc<Flags>,
   serve_flags: ServeFlags,
+  unconfigured_runtime: Option<UnconfiguredRuntime>,
+  roots: LibWorkerFactoryRoots,
 ) -> Result<i32, AnyError> {
   check_permission_before_script(&flags);
 
@@ -45,8 +49,11 @@ pub async fn serve(
 
   maybe_npm_install(&factory).await?;
 
-  let worker_factory =
-    Arc::new(factory.create_cli_main_worker_factory().await?);
+  let worker_factory = Arc::new(
+    factory
+      .create_cli_main_worker_factory_with_roots(roots)
+      .await?,
+  );
 
   if serve_flags.open_site {
     let url = resolve_serve_url(serve_flags.host, serve_flags.port);
@@ -62,6 +69,7 @@ pub async fn serve(
     main_module.clone(),
     serve_flags.worker_count,
     hmr,
+    unconfigured_runtime,
   )
   .await
 }
@@ -71,14 +79,16 @@ async fn do_serve(
   main_module: ModuleSpecifier,
   worker_count: Option<usize>,
   hmr: bool,
+  unconfigured_runtime: Option<UnconfiguredRuntime>,
 ) -> Result<i32, AnyError> {
   let mut worker = worker_factory
-    .create_main_worker(
+    .create_main_worker_with_unconfigured_runtime(
       deno_runtime::WorkerExecutionMode::Serve {
         is_main: true,
         worker_count,
       },
       main_module.clone(),
+      unconfigured_runtime,
     )
     .await?;
   let worker_count = match worker_count {
@@ -176,7 +186,7 @@ async fn serve_with_watch(
         let worker_factory =
           Arc::new(factory.create_cli_main_worker_factory().await?);
 
-        do_serve(worker_factory, main_module.clone(), worker_count, hmr)
+        do_serve(worker_factory, main_module.clone(), worker_count, hmr, None)
           .await?;
 
         Ok(())

cli/tsc/dts/lib.deno.ns.d.ts

@@ -1510,7 +1510,7 @@ declare namespace Deno {
      *
      * ```ts
      * console.log(Deno.env.get("HOME"));  // e.g. outputs "/home/alice"
-     * console.log(Deno.env.get("MADE_UP_VAR"));  // outputs "undefined"
+     * console.log(Deno.env.get("MADE_UP_VAR"));  // outputs undefined
      * ```
      *
      * Requires `allow-env` permission.

ext/http/00_serve.ts

@@ -14,6 +14,7 @@ import {
   op_http_get_request_headers,
   op_http_get_request_method_and_url,
   op_http_metric_handle_otel_error,
+  op_http_notify_serving,
   op_http_read_request_body,
   op_http_request_on_cancel,
   op_http_serve,
@@ -1049,6 +1050,8 @@ function serveHttpOn(context, addr, callback) {
     }
   })();
 
+  op_http_notify_serving();
+
   return {
     addr,
     finished,

ext/http/lib.rs

@@ -15,6 +15,8 @@ use std::net::SocketAddr;
 use std::pin::pin;
 use std::pin::Pin;
 use std::rc::Rc;
+use std::sync::atomic::AtomicBool;
+use std::sync::atomic::Ordering;
 use std::sync::Arc;
 use std::task::ready;
 use std::task::Context;
@@ -80,6 +82,7 @@ use serde::Serialize;
 use tokio::io::AsyncRead;
 use tokio::io::AsyncWrite;
 use tokio::io::AsyncWriteExt;
+use tokio::sync::Notify;
 
 use crate::network_buffered_stream::NetworkBufferedStream;
 use crate::reader_stream::ExternallyAbortableReaderStream;
@@ -201,6 +204,7 @@ deno_core::extension!(
     op_http_write_headers,
     op_http_write_resource,
     op_http_write,
+    op_http_notify_serving,
     http_next::op_http_close_after_finish,
     http_next::op_http_get_request_header,
     http_next::op_http_get_request_headers,
@@ -1764,6 +1768,20 @@ fn parse_serve_address(input: &str) -> (u8, String, u32, bool) {
   }
 }
 
+pub static SERVE_NOTIFIER: Notify = Notify::const_new();
+
+#[op2(fast)]
+fn op_http_notify_serving() {
+  static ONCE: AtomicBool = AtomicBool::new(false);
+
+  if ONCE
+    .compare_exchange(false, true, Ordering::Acquire, Ordering::Relaxed)
+    .is_ok()
+  {
+    SERVE_NOTIFIER.notify_one();
+  }
+}
+
 #[cfg(test)]
 mod tests {
   use super::*;

tests/specs/run/unconfigured/main.out

@@ -1,3 +1,4 @@
 true
 hello world
+EVENT: "Serving"
 [Object: null prototype] { success: true, code: 0, signal: null }

tests/specs/run/unconfigured/main.ts

@@ -36,6 +36,7 @@ Deno.writeTextFile(
   `
 console.log(Deno[Deno.internal].isFromUnconfiguredRuntime());
 console.log(Deno.env.get('A'));
+Deno.serve({ onListen() {} }, () => {}).shutdown();
 `,
 );
 
@@ -47,4 +48,9 @@ const data = JSON.stringify({
 
 await sock.write(new TextEncoder().encode(data + "\n"));
 
+const buf = new Uint8Array(128);
+const n = await sock.read(buf);
+
+console.log("EVENT:", new TextDecoder().decode(buf.subarray(0, n)));
+
 console.log(await child.status);