exec: extract common option as record

Author: noise64

exec/exec/src/component.rs

@@ -1,6 +1,6 @@
 use crate::durability::{DurableExec, EmptySnapshot, SessionSnapshot};
 use crate::golem::exec::executor::{
-    Error, ExecResult, File, Guest, GuestSession, Language, Limits,
+    Error, ExecResult, File, Guest, GuestSession, Language, RunOptions,
 };
 use crate::golem::exec::types::LanguageKind;
 use crate::{get_contents, io_error, stage_result_failure};
@@ -13,19 +13,16 @@ impl Guest for Component {
 
     fn run(
         lang: Language,
-        snippet: String,
         modules: Vec<File>,
-        stdin: Option<String>,
-        args: Vec<String>,
-        env: Vec<(String, String)>,
-        constraints: Option<Limits>,
+        snippet: String,
+        options: RunOptions,
     ) -> Result<ExecResult, Error> {
         match &lang.kind {
             LanguageKind::Javascript => {
                 #[cfg(feature = "javascript")]
                 {
                     let session = crate::javascript::JavaScriptSession::new(lang, modules);
-                    session.run(snippet, args, stdin, env, constraints)
+                    session.run(snippet, options)
                 }
                 #[cfg(not(feature = "javascript"))]
                 {
@@ -36,7 +33,7 @@ impl Guest for Component {
                 #[cfg(feature = "python")]
                 {
                     let session = crate::python::PythonSession::new(lang, modules);
-                    session.run(snippet, args, stdin, env, constraints)
+                    session.run(snippet, options)
                 }
                 #[cfg(not(feature = "python"))]
                 {
@@ -121,19 +118,12 @@ impl GuestSession for Session {
         Ok(())
     }
 
-    fn run(
-        &self,
-        snippet: String,
-        args: Vec<String>,
-        stdin: Option<String>,
-        env: Vec<(String, String)>,
-        constraints: Option<Limits>,
-    ) -> Result<ExecResult, Error> {
+    fn run(&self, snippet: String, options: RunOptions) -> Result<ExecResult, Error> {
         match self {
             #[cfg(feature = "javascript")]
-            Session::Javascript(session) => session.run(snippet, args, stdin, env, constraints),
+            Session::Javascript(session) => session.run(snippet, options),
             #[cfg(feature = "python")]
-            Session::Python(session) => session.run(snippet, args, stdin, env, constraints),
+            Session::Python(session) => session.run(snippet, options),
             Session::Unsupported => Err(Error::UnsupportedLanguage),
         }
     }

exec/exec/src/durability.rs

@@ -24,21 +24,20 @@ pub struct EmptySnapshot {}
 #[cfg(not(feature = "durability"))]
 mod passthrough_impl {
     use crate::durability::DurableExec;
-    use crate::golem::exec::executor::{Error, ExecResult, File, Guest, Language, Limits};
+    use crate::golem::exec::executor::{
+        Error, ExecResult, File, Guest, Language, RunOptions,
+    };
 
     impl<Impl: Guest> Guest for DurableExec<Impl> {
         type Session = Impl::Session;
 
         fn run(
             lang: Language,
-            snippet: String,
             modules: Vec<File>,
-            stdin: Option<String>,
-            args: Vec<String>,
-            env: Vec<(String, String)>,
-            constraints: Option<Limits>,
+            snippet: String,
+            options: RunOptions,
         ) -> Result<ExecResult, Error> {
-            Impl::run(lang, snippet, modules, stdin, args, env, constraints)
+            Impl::run(lang, modules, snippet, options)
         }
     }
 }
@@ -47,7 +46,7 @@ mod passthrough_impl {
 mod durable_impl {
     use crate::durability::{DurableExec, SessionSnapshot};
     use crate::golem::exec::executor::{
-        Error, ExecResult, File, Guest, GuestSession, Language, Limits,
+        Error, ExecResult, File, Guest, GuestSession, Language, RunOptions,
     };
     use golem_rust::bindings::golem::durability::durability::DurableFunctionType;
     use golem_rust::durability::Durability;
@@ -62,12 +61,9 @@ mod durable_impl {
 
         fn run(
             lang: Language,
-            snippet: String,
             modules: Vec<File>,
-            stdin: Option<String>,
-            args: Vec<String>,
-            env: Vec<(String, String)>,
-            constraints: Option<Limits>,
+            snippet: String,
+            options: RunOptions,
         ) -> Result<ExecResult, Error> {
             let durability = Durability::<ExecResult, Error>::new(
                 "golem_exec",
@@ -78,23 +74,17 @@ mod durable_impl {
                 let result = with_persistence_level(PersistenceLevel::PersistNothing, || {
                     Impl::run(
                         lang.clone(),
-                        snippet.clone(),
                         modules.clone(),
-                        stdin.clone(),
-                        args.clone(),
-                        env.clone(),
-                        constraints,
+                        snippet.clone(),
+                        options.clone(),
                     )
                 });
                 durability.persist_serializable(
                     RunInput {
                         language: lang,
                         modules: modules.iter().map(|f| f.name.clone()).collect(),
                         snippet,
-                        args,
-                        stdin,
-                        env,
-                        constraints,
+                        options,
                     },
                     result.clone(),
                 );
@@ -124,14 +114,7 @@ mod durable_impl {
             self.inner.upload(file)
         }
 
-        fn run(
-            &self,
-            snippet: String,
-            args: Vec<String>,
-            stdin: Option<String>,
-            env: Vec<(String, String)>,
-            constraints: Option<Limits>,
-        ) -> Result<ExecResult, Error> {
+        fn run(&self, snippet: String, options: RunOptions) -> Result<ExecResult, Error> {
             let durability = Durability::<SessionRunResult<Impl::Snapshot>, UnusedError>::new(
                 "golem_exec",
                 "session_run",
@@ -141,17 +124,14 @@ mod durable_impl {
                 language: self.lang.clone(),
                 modules: self.module_names.clone(),
                 snippet: snippet.clone(),
-                args: args.clone(),
-                stdin: stdin.clone(),
-                env: env.clone(),
-                constraints,
+                options: options.clone(),
             };
             if Impl::supports_snapshot(&self.inner) {
                 // We can take a snapshot of the session and restore it during replay without
                 // actually running the snippet.
                 if durability.is_live() {
                     let result = with_persistence_level(PersistenceLevel::PersistNothing, || {
-                        self.inner.run(snippet, args, stdin, env, constraints)
+                        self.inner.run(snippet, options)
                     });
                     let snapshot = Impl::take_snapshot(&self.inner);
                     let result = SessionRunResult {
@@ -172,7 +152,7 @@ mod durable_impl {
                 // in both live and replay modes.
                 //
                 // We still persist a custom oplog entry to increase oplog readability
-                let result = self.inner.run(snippet, args, stdin, env, constraints);
+                let result = self.inner.run(snippet, options);
                 let result = SessionRunResult {
                     result,
                     snapshot: None,
@@ -205,10 +185,7 @@ mod durable_impl {
         language: Language,
         modules: Vec<String>,
         snippet: String,
-        args: Vec<String>,
-        stdin: Option<String>,
-        env: Vec<(String, String)>,
-        constraints: Option<Limits>,
+        options: RunOptions,
     }
 
     #[derive(Debug, Clone)]

exec/exec/src/javascript/mod.rs

@@ -1,7 +1,7 @@
 mod builtin;
 
 use crate::durability::{EmptySnapshot, SessionSnapshot};
-use crate::golem::exec::executor::{Error, ExecResult, File, Language, Limits};
+use crate::golem::exec::executor::{Error, ExecResult, File, Language, RunOptions};
 use crate::golem::exec::types::{LanguageKind, StageResult};
 use crate::{get_contents_as_string, stage_result_failure};
 use futures::TryFutureExt;
@@ -26,15 +26,12 @@ pub struct JavascriptComponent;
 impl JavascriptComponent {
     pub fn run(
         lang: Language,
-        snippet: String,
         files: Vec<File>,
-        stdin: Option<String>,
-        args: Vec<String>,
-        env: Vec<(String, String)>,
-        constraints: Option<Limits>,
+        snippet: String,
+        options: RunOptions,
     ) -> Result<ExecResult, Error> {
         let session = JavaScriptSession::new(lang, files);
-        session.run(snippet, args, stdin, env, constraints)
+        session.run(snippet, options)
     }
 }
 
@@ -127,18 +124,11 @@ impl JavaScriptSession {
         }
     }
 
-    pub fn run(
-        &self,
-        snippet: String,
-        args: Vec<String>,
-        stdin: Option<String>,
-        env: Vec<(String, String)>,
-        constraints: Option<Limits>,
-    ) -> Result<ExecResult, Error> {
+    pub fn run(&self, snippet: String, options: RunOptions) -> Result<ExecResult, Error> {
         ensure_language_is_supported(&self.lang)?;
         self.ensure_initialized()?;
 
-        block_on(async { self.run_async(snippet, args, stdin, env, constraints).await })
+        block_on(async { self.run_async(snippet, options).await })
     }
 
     fn ensure_initialized(&self) -> Result<(), Error> {
@@ -188,26 +178,26 @@ impl JavaScriptSession {
     }
 
     #[allow(clippy::await_holding_refcell_ref)]
-    async fn run_async(
-        &self,
-        snippet: String,
-        args: Vec<String>,
-        stdin: Option<String>,
-        env: Vec<(String, String)>,
-        constraints: Option<Limits>,
-    ) -> Result<ExecResult, Error> {
+    async fn run_async(&self, snippet: String, options: RunOptions) -> Result<ExecResult, Error> {
         let maybe_state = self.state.borrow();
         let state = maybe_state.as_ref().unwrap();
         let start = Instant::now();
 
-        if let Some(constraints) = constraints {
+        if let Some(constraints) = options.constraints {
             if let Some(memory_bytes) = constraints.memory_bytes {
                 state.rt.set_memory_limit(memory_bytes as usize).await;
             }
         }
 
         let abort_state = async_with!(state.ctx => |ctx| {
-           set_globals(ctx.clone(), stdin, args, env, state.cwd.clone(), constraints.and_then(|c| c.file_size_bytes) ).map_err(js_engine_error)?;
+           set_globals(
+                ctx.clone(),
+                options.stdin,
+                options.args.unwrap_or_default(),
+                options.env.unwrap_or_default(),
+                state.cwd.clone(),
+                options.constraints.and_then(|c| c.file_size_bytes),
+            ).map_err(js_engine_error)?;
             builtin::timeout::init_abort(ctx)
         })
         .await?;
@@ -229,7 +219,7 @@ impl JavaScriptSession {
                 })
                 .await
         };
-        let result = if let Some(timeout_ms) = constraints.and_then(|c| c.time_ms) {
+        let result = if let Some(timeout_ms) = options.constraints.and_then(|c| c.time_ms) {
             future
                 .timeout(Duration::from_millis(timeout_ms))
                 .map_err(|err| match err.kind() {

exec/exec/src/python/mod.rs

@@ -1,5 +1,5 @@
 use crate::durability::{EmptySnapshot, SessionSnapshot};
-use crate::golem::exec::executor::{Error, ExecResult, File, Language, Limits};
+use crate::golem::exec::executor::{Error, ExecResult, File, Language, RunOptions};
 use crate::golem::exec::types::{LanguageKind, StageResult};
 use crate::{get_contents_as_string, io_error, stage_result_failure};
 use indoc::indoc;
@@ -33,15 +33,12 @@ pub struct PythonComponent;
 impl PythonComponent {
     pub fn run(
         lang: Language,
-        snippet: String,
         files: Vec<File>,
-        stdin: Option<String>,
-        args: Vec<String>,
-        env: Vec<(String, String)>,
-        constraints: Option<Limits>,
+        snippet: String,
+        options: RunOptions,
     ) -> Result<ExecResult, Error> {
         let session = PythonSession::new(lang, files);
-        session.run(snippet, args, stdin, env, constraints)
+        session.run(snippet, options)
     }
 }
 
@@ -124,14 +121,7 @@ impl PythonSession {
         }
     }
 
-    pub fn run(
-        &self,
-        snippet: String,
-        args: Vec<String>,
-        stdin: Option<String>,
-        env: Vec<(String, String)>,
-        _constraints: Option<Limits>,
-    ) -> Result<ExecResult, Error> {
+    pub fn run(&self, snippet: String, options: RunOptions) -> Result<ExecResult, Error> {
         self.ensure_initialized()?;
         ensure_language_is_supported(&self.lang)?;
 
@@ -149,11 +139,13 @@ impl PythonSession {
             let scope = vm.new_scope_with_builtins();
             scope.globals.set_item(
                 "__external_stdin",
-                vm.new_pyobj(stdin.unwrap_or_default()),
+                vm.new_pyobj(options.stdin.unwrap_or_default()),
                 vm,
             )?;
 
-            let env_pairs = env
+            let env_pairs = options
+                .env
+                .unwrap_or_default()
                 .iter()
                 .map(|(k, v)| vm.new_pyobj((k, v)))
                 .collect::<Vec<_>>();
@@ -163,7 +155,14 @@ impl PythonSession {
 
             scope.globals.set_item(
                 "__argv",
-                vm.new_pyobj(args.iter().map(|s| vm.new_pyobj(s)).collect::<Vec<_>>()),
+                vm.new_pyobj(
+                    options
+                        .args
+                        .unwrap_or_default()
+                        .iter()
+                        .map(|s| vm.new_pyobj(s))
+                        .collect::<Vec<_>>(),
+                ),
                 vm,
             )?;