Wire up UdfOutcome to isolate2 (#24680)

I've added test helpers to run a single UDF test with both isolate v1 and isolate v2! Over time I'll port more tests as we implement features.

GitOrigin-RevId: 938d8101c1a3027551835fa25bcc71dcc6afcec8

Author: Sujay Jayakar

crates/isolate/src/isolate2/client.rs

@@ -27,6 +27,7 @@ use value::{
 };
 
 use super::{
+    environment::EnvironmentOutcome,
     FunctionId,
     PromiseId,
 };
@@ -58,7 +59,10 @@ pub enum IsolateThreadRequest {
 
 #[derive(Debug)]
 pub enum EvaluateResult {
-    Ready(ConvexValue),
+    Ready {
+        result: ConvexValue,
+        outcome: EnvironmentOutcome,
+    },
     Pending {
         async_syscalls: Vec<PendingAsyncSyscall>,
     },

crates/isolate/src/isolate2/context.rs

@@ -8,7 +8,6 @@ use deno_core::{
     },
     ModuleSpecifier,
 };
-use futures::future::Either;
 use value::ConvexObject;
 
 use super::{
@@ -111,16 +110,13 @@ impl Context {
         let function_id = self.next_function_id;
         self.next_function_id += 1;
 
-        let result = match self.enter(session, |mut ctx| {
+        let (promise, result) = self.enter(session, |mut ctx| {
             ctx.start_evaluate_function(udf_type, module, name, args)
-        })? {
-            Either::Left(result) => (function_id, EvaluateResult::Ready(result)),
-            Either::Right((promise, async_syscalls)) => {
-                self.pending_functions.insert(function_id, promise);
-                (function_id, EvaluateResult::Pending { async_syscalls })
-            },
+        })?;
+        if let EvaluateResult::Pending { .. } = result {
+            self.pending_functions.insert(function_id, promise);
         };
-        Ok(result)
+        Ok((function_id, result))
     }
 
     pub fn poll_function(
@@ -129,18 +125,13 @@ impl Context {
         function_id: FunctionId,
         completions: Vec<AsyncSyscallCompletion>,
     ) -> anyhow::Result<EvaluateResult> {
-        let promise = self
-            .pending_functions
-            .remove(&function_id)
-            .ok_or_else(|| anyhow!("Function {function_id} not found"))?;
-        let result =
-            match self.enter(session, |mut ctx| ctx.poll_function(completions, &promise))? {
-                Either::Left(result) => EvaluateResult::Ready(result),
-                Either::Right((promise, async_syscalls)) => {
-                    self.pending_functions.insert(function_id, promise);
-                    EvaluateResult::Pending { async_syscalls }
-                },
-            };
+        let Some(promise) = self.pending_functions.remove(&function_id) else {
+            anyhow::bail!("Function {function_id} not found");
+        };
+        let result = self.enter(session, |mut ctx| ctx.poll_function(completions, &promise))?;
+        if let EvaluateResult::Pending { .. } = result {
+            self.pending_functions.insert(function_id, promise);
+        }
         Ok(result)
     }
 

crates/isolate/src/isolate2/entered_context.rs

@@ -12,7 +12,6 @@ use deno_core::{
     ModuleSpecifier,
 };
 use errors::ErrorMetadata;
-use futures::future::Either;
 use serde_json::Value as JsonValue;
 use value::{
     ConvexObject,
@@ -22,6 +21,7 @@ use value::{
 use super::{
     client::{
         AsyncSyscallCompletion,
+        EvaluateResult,
         PendingAsyncSyscall,
     },
     context_state::ContextState,
@@ -302,10 +302,10 @@ impl<'enter, 'scope: 'enter> EnteredContext<'enter, 'scope> {
         url: &ModuleSpecifier,
         name: &str,
         args: ConvexObject,
-    ) -> anyhow::Result<Either<ConvexValue, (v8::Global<v8::Promise>, Vec<PendingAsyncSyscall>)>>
-    {
+    ) -> anyhow::Result<(v8::Global<v8::Promise>, EvaluateResult)> {
         let module_global = {
-            let context_state = self.context_state()?;
+            let context_state = self.context_state_mut()?;
+            context_state.environment.start_execution()?;
             context_state
                 .module_map
                 .modules
@@ -392,32 +392,15 @@ impl<'enter, 'scope: 'enter> EnteredContext<'enter, 'scope> {
             .ok_or_else(|| anyhow!("Failed to call invoke function"))?
             .try_into()?;
 
-        match promise.state() {
-            v8::PromiseState::Pending => {
-                let promise = v8::Global::new(self.scope, promise);
-                let pending = mem::take(&mut self.context_state_mut()?.pending_async_syscalls);
-                Ok(Either::Right((promise, pending)))
-            },
-            v8::PromiseState::Fulfilled => {
-                let result: v8::Local<v8::String> = promise.result(self.scope).try_into()?;
-                let result = helpers::to_rust_string(self.scope, &result)?;
-                // TODO: `deserialize_udf_result`
-                let result_json: JsonValue = serde_json::from_str(&result)?;
-                let result = ConvexValue::try_from(result_json)?;
-                Ok(Either::Left(result))
-            },
-            v8::PromiseState::Rejected => {
-                todo!()
-            },
-        }
+        let evaluate_result = self.check_promise_result(&promise)?;
+        Ok((v8::Global::new(self.scope, promise), evaluate_result))
     }
 
     pub fn poll_function(
         &mut self,
         completions: Vec<AsyncSyscallCompletion>,
         promise: &v8::Global<v8::Promise>,
-    ) -> anyhow::Result<Either<ConvexValue, (v8::Global<v8::Promise>, Vec<PendingAsyncSyscall>)>>
-    {
+    ) -> anyhow::Result<EvaluateResult> {
         let completed = {
             let context_state = self.context_state_mut()?;
             let mut completed = vec![];
@@ -451,19 +434,27 @@ impl<'enter, 'scope: 'enter> EnteredContext<'enter, 'scope> {
         self.execute_user_code(|s| s.perform_microtask_checkpoint())?;
 
         let promise = v8::Local::new(self.scope, promise);
+        self.check_promise_result(&promise)
+    }
+
+    fn check_promise_result(
+        &mut self,
+        promise: &v8::Local<v8::Promise>,
+    ) -> anyhow::Result<EvaluateResult> {
         match promise.state() {
             v8::PromiseState::Pending => {
-                let promise = v8::Global::new(self.scope, promise);
-                let pending = mem::take(&mut self.context_state_mut()?.pending_async_syscalls);
-                Ok(Either::Right((promise, pending)))
+                let async_syscalls =
+                    mem::take(&mut self.context_state_mut()?.pending_async_syscalls);
+                Ok(EvaluateResult::Pending { async_syscalls })
             },
             v8::PromiseState::Fulfilled => {
                 let result: v8::Local<v8::String> = promise.result(self.scope).try_into()?;
                 let result = helpers::to_rust_string(self.scope, &result)?;
                 // TODO: `deserialize_udf_result`
                 let result_json: JsonValue = serde_json::from_str(&result)?;
                 let result = ConvexValue::try_from(result_json)?;
-                Ok(Either::Left(result))
+                let outcome = self.context_state_mut()?.environment.finish_execution()?;
+                Ok(EvaluateResult::Ready { result, outcome })
             },
             v8::PromiseState::Rejected => {
                 todo!()

crates/isolate/src/isolate2/environment.rs

@@ -12,6 +12,12 @@ use common::{
 use rand_chacha::ChaCha12Rng;
 use serde_json::Value as JsonValue;
 
+#[derive(Debug)]
+pub struct EnvironmentOutcome {
+    pub observed_rng: bool,
+    pub observed_time: bool,
+}
+
 pub trait Environment {
     fn syscall(&mut self, name: &str, args: JsonValue) -> anyhow::Result<JsonValue>;
 
@@ -28,4 +34,10 @@ pub trait Environment {
 
     fn get_environment_variable(&mut self, name: EnvVarName)
         -> anyhow::Result<Option<EnvVarValue>>;
+
+    // Signal that we've finished the import phase and are ready to start execution.
+    fn start_execution(&mut self) -> anyhow::Result<()>;
+
+    // Signal that we've finished execution.
+    fn finish_execution(&mut self) -> anyhow::Result<EnvironmentOutcome>;
 }