Add fallback when specifing user for docker commands and cp scripts to scripts_dir

Author: mchristou

crates/orchestrator/src/network/node.rs

@@ -10,7 +10,10 @@ use anyhow::anyhow;
 use fancy_regex::Regex;
 use glob_match::glob_match;
 use prom_metrics_parser::MetricMap;
-use provider::DynNode;
+use provider::{
+    types::{ExecutionResult, RunScriptOptions},
+    DynNode,
+};
 use serde::{Deserialize, Serialize, Serializer};
 use subxt::{backend::rpc::RpcClient, OnlineClient};
 use support::net::{skip_err_while_waiting, wait_ws_ready};
@@ -281,8 +284,8 @@ impl NetworkNode {
     /// Returns `Ok(stdout)` on success, or `Err((exit_status, stderr))` on failure.
     pub async fn run_script(
         &self,
-        options: provider::types::RunScriptOptions,
-    ) -> Result<provider::types::ExecutionResult, anyhow::Error> {
+        options: RunScriptOptions,
+    ) -> Result<ExecutionResult, anyhow::Error> {
         self.inner
             .run_script(options)
             .await

crates/provider/src/docker/client.rs

@@ -311,28 +311,31 @@ impl DockerClient {
     where
         S: Into<String> + std::fmt::Debug + Send + Clone,
     {
-        let mut cmd = self.client_command();
-        cmd.arg("exec");
-
-        if let Some(env) = env {
-            for env_var in env {
-                cmd.args(["-e", &format!("{}={}", env_var.0.into(), env_var.1.into())]);
-            }
-        }
+        // Try with specified user first
+        let result = self
+            .exec_with_user(name, command.clone(), env.clone(), as_user.clone())
+            .await?;
 
-        if let Some(user) = as_user {
-            cmd.args(["-u", user.into().as_ref()]);
+        // If command failed and we specified a user, retry without user
+        if result.is_err() && as_user.is_some() {
+            trace!("Command failed with user, retrying without user specification");
+            return self.exec_with_user(name, command, env, None).await;
         }
 
-        cmd.arg(name);
-
-        cmd.args(
-            command
-                .clone()
-                .into_iter()
-                .map(|s| <S as Into<String>>::into(s)),
-        );
+        Ok(result)
+    }
 
+    async fn exec_with_user<S>(
+        &self,
+        name: &str,
+        command: Vec<S>,
+        env: Option<Vec<(S, S)>>,
+        as_user: Option<S>,
+    ) -> Result<ExecutionResult>
+    where
+        S: Into<String> + std::fmt::Debug + Send + Clone,
+    {
+        let mut cmd = self.build_exec_command(name, command.clone(), env, as_user);
         trace!("cmd is : {:?}", cmd);
 
         let result = cmd.output().await.map_err(|err| {
@@ -357,6 +360,35 @@ impl DockerClient {
         Ok(Ok(String::from_utf8_lossy(&result.stdout).to_string()))
     }
 
+    fn build_exec_command<S>(
+        &self,
+        name: &str,
+        command: Vec<S>,
+        env: Option<Vec<(S, S)>>,
+        as_user: Option<S>,
+    ) -> Command
+    where
+        S: Into<String> + std::fmt::Debug + Send + Clone,
+    {
+        let mut cmd = self.client_command();
+        cmd.arg("exec");
+
+        if let Some(env) = env {
+            for env_var in env {
+                cmd.args(["-e", &format!("{}={}", env_var.0.into(), env_var.1.into())]);
+            }
+        }
+
+        if let Some(user) = as_user {
+            cmd.args(["-u", user.into().as_ref()]);
+        }
+
+        cmd.arg(name);
+        cmd.args(command.into_iter().map(|s| <S as Into<String>>::into(s)));
+
+        cmd
+    }
+
     pub async fn container_cp(
         &self,
         name: &str,

crates/provider/src/docker/node.rs

@@ -372,7 +372,7 @@ where
                 &self.container_name,
                 vec!["mkdir", "-p", &remote_dir.to_string_lossy()],
                 None,
-                None,
+                Some("root"),
             )
             .await
             .map_err(|err| {
@@ -511,7 +511,7 @@ where
             ))
             .to_string_lossy();
 
-        let remote_script_path = PathBuf::from(format!("/tmp/{file_name}"));
+        let remote_script_path = self.scripts_dir.join(Path::new(file_name.as_ref()));
 
         // Upload the script to the container and make it executable
         self.send_file(&options.local_script_path, &remote_script_path, "0755")