chore: further optimisations

Author: Seggys116

crates/urt-executor/src/config.rs

@@ -319,6 +319,7 @@ pub struct ExecutorConfig {
     pub inactive_threshold: u64,   // seconds
     pub maintenance_interval: u64, // seconds
     pub autoscale: bool,
+    pub eager_runtime_readiness: bool,
     pub max_concurrent_executions: Option<usize>,
     pub max_concurrent_runtime_creates: Option<usize>,
     pub execution_queue_wait_ms: u64,
@@ -420,6 +421,9 @@ impl ExecutorConfig {
             autoscale: env_urt_or_opr("AUTOSCALE")
                 .map(|v| parse_bool_flag(&v))
                 .unwrap_or(false),
+            eager_runtime_readiness: env_urt_or_opr("EAGER_RUNTIME_READINESS")
+                .map(|v| parse_bool_flag(&v))
+                .unwrap_or(false),
             max_concurrent_executions: env_urt_or_opr("MAX_CONCURRENT_EXECUTIONS")
                 .and_then(|v| v.parse::<usize>().ok())
                 .filter(|v| *v > 0),

crates/urt-executor/src/main.rs

@@ -81,6 +81,10 @@ async fn async_main() -> Result<(), Box<dyn std::error::Error>> {
     info!("  Host: {}:{}", config.host, config.port);
     info!("  Keep-alive: {}", config.keep_alive);
     info!("  Autoscale: {}", config.autoscale);
+    info!(
+        "  Eager runtime readiness: {}",
+        config.eager_runtime_readiness
+    );
     info!("  Metrics endpoint: {}", config.metrics_enabled);
     info!("  Auto runtime: {}", config.auto_runtime);
     info!("  Min CPUs: {}", config.min_cpus);

crates/urt-executor/src/routes/runtimes.rs

@@ -502,7 +502,9 @@ pub async fn create_runtime(
     validate_image_name(&resolved_image)?;
 
     let full_name = format!("{}-{}", state.config.hostname, req.runtime_id);
-    reconcile_existing_runtime_id(&state, &req.runtime_id, &full_name).await?;
+    if state.registry.exists(&full_name).await {
+        reconcile_existing_runtime_id(&state, &req.runtime_id, &full_name).await?;
+    }
 
     // Check if image is allowed
     if !state.config.is_runtime_allowed(&resolved_image) {
@@ -1051,25 +1053,27 @@ pub async fn create_runtime(
 
         info!("Cleaned up runtime {} after build", req.runtime_id);
     } else {
-        let port_timeout_secs = u64::from(req.timeout.clamp(1, 30));
-        if let Err(error) =
-            wait_for_runtime_port(&full_name, 3000, Duration::from_secs(port_timeout_secs)).await
-        {
-            error!(
-                "Runtime {} failed port readiness: {}",
-                req.runtime_id, error
-            );
-            state.docker.remove_container(&full_name, true).await.ok();
-            tokio::fs::remove_dir_all(&tmp_folder).await.ok();
-            state.registry.remove(&full_name).await;
-            return Err(ExecutorError::RuntimeFailed(
-                "Runtime port readiness check timed out".to_string(),
-            ));
-        }
-
         let mut updated_runtime = runtime.clone();
+        if state.config.eager_runtime_readiness {
+            let port_timeout_secs = u64::from(req.timeout.clamp(1, 30));
+            if let Err(error) =
+                wait_for_runtime_port(&full_name, 3000, Duration::from_secs(port_timeout_secs))
+                    .await
+            {
+                error!(
+                    "Runtime {} failed port readiness: {}",
+                    req.runtime_id, error
+                );
+                state.docker.remove_container(&full_name, true).await.ok();
+                tokio::fs::remove_dir_all(&tmp_folder).await.ok();
+                state.registry.remove(&full_name).await;
+                return Err(ExecutorError::RuntimeFailed(
+                    "Runtime port readiness check timed out".to_string(),
+                ));
+            }
+            updated_runtime.set_listening();
+        }
         updated_runtime.mark_running("running");
-        updated_runtime.set_listening();
         state.registry.update(updated_runtime).await.ok();
     }
 

crates/urt-executor/src/runtime/protocol.rs

@@ -12,15 +12,34 @@ use smallvec::SmallVec;
 use std::collections::HashMap;
 use std::fmt::Write;
 use std::path::Path;
+#[cfg(not(test))]
+use std::sync::OnceLock;
 use std::time::Duration;
 use tracing::debug;
 
 /// Maximum log file size (5MB, matching executor-main)
 const MAX_LOG_SIZE: usize = 5 * 1024 * 1024;
 const MAX_BUILD_LOG_SIZE: usize = 1_000_000;
-const LOG_FILE_WAIT_TIMEOUT: Duration = Duration::from_secs(1);
 const LOG_FILE_WAIT_INTERVAL: Duration = Duration::from_millis(25);
 
+#[cfg(not(test))]
+fn log_file_wait_timeout() -> Duration {
+    static TIMEOUT: OnceLock<Duration> = OnceLock::new();
+    *TIMEOUT.get_or_init(|| {
+        let millis = std::env::var("URT_LOG_FILE_WAIT_MS")
+            .ok()
+            .or_else(|| std::env::var("OPR_EXECUTOR_LOG_FILE_WAIT_MS").ok())
+            .and_then(|value| value.parse::<u64>().ok())
+            .unwrap_or(0);
+        Duration::from_millis(millis)
+    })
+}
+
+#[cfg(test)]
+fn log_file_wait_timeout() -> Duration {
+    Duration::from_secs(1)
+}
+
 /// Request to execute a function
 #[derive(Debug, Clone)]
 pub struct ExecuteRequest {
@@ -308,11 +327,7 @@ impl RuntimeProtocol for V5Protocol {
 }
 
 pub fn runtime_network_host(runtime: &Runtime) -> &str {
-    if runtime.hostname.trim().is_empty() {
-        &runtime.name
-    } else {
-        &runtime.hostname
-    }
+    &runtime.name
 }
 
 /// Read log files from disk and clean up (matching executor-main behavior)
@@ -345,7 +360,12 @@ async fn read_log_files(runtime_name: &str, file_id: &str) -> (String, String) {
 }
 
 async fn wait_for_log_file(path: &Path) {
-    let deadline = tokio::time::Instant::now() + LOG_FILE_WAIT_TIMEOUT;
+    let timeout = log_file_wait_timeout();
+    if timeout.is_zero() {
+        return;
+    }
+
+    let deadline = tokio::time::Instant::now() + timeout;
 
     loop {
         if tokio::fs::try_exists(path).await.unwrap_or(false)
@@ -493,7 +513,7 @@ mod tests {
     }
 
     #[test]
-    fn test_runtime_network_host_prefers_hostname() {
+    fn test_runtime_network_host_uses_container_name_even_when_hostname_exists() {
         let runtime = Runtime {
             version: "v5".to_string(),
             created: 0.0,
@@ -509,12 +529,9 @@ mod tests {
             authorization_header: "Basic dummy".to_string(),
         };
 
-        assert_eq!(
-            runtime_network_host(&runtime),
-            "1ca14d56857971dfad412b32f66e6466"
-        );
+        assert_eq!(runtime_network_host(&runtime), "exc1-myruntime123");
         let url = build_runtime_url(runtime_network_host(&runtime), 3000, "/");
-        assert_eq!(url, "http://1ca14d56857971dfad412b32f66e6466:3000/");
+        assert_eq!(url, "http://exc1-myruntime123:3000/");
     }
 
     #[test]

crates/urt-executor/tests/e2e.rs

@@ -119,6 +119,7 @@ fn test_config(network: String) -> ExecutorConfig {
         inactive_threshold: 300,
         maintenance_interval: 3600,
         autoscale: false,
+        eager_runtime_readiness: false,
         max_concurrent_executions: None,
         max_concurrent_runtime_creates: None,
         execution_queue_wait_ms: 2_000,

crates/urt-executor/tests/integration.rs

@@ -40,6 +40,7 @@ fn test_config() -> ExecutorConfig {
         inactive_threshold: 60,
         maintenance_interval: 3600,
         autoscale: false,
+        eager_runtime_readiness: false,
         max_concurrent_executions: None,
         max_concurrent_runtime_creates: None,
         execution_queue_wait_ms: 2_000,