approach revamp using --find-free-port flag

Signed-off-by: Aminu 'Seun Joshua <[email protected]>

Author: seun-ja

crates/trigger-http/src/lib.rs

@@ -51,9 +51,8 @@ pub struct CliArgs {
     #[clap(long, env = "SPIN_TLS_KEY", requires = "tls-cert")]
     pub tls_key: Option<PathBuf>,
 
-    /// The port to listen on
-    #[clap(long = "port", env = "SPIN_HTTP_LISTEN_PORT")]
-    pub port: Option<u16>,
+    #[clap(long = "find-free-port")]
+    pub find_free_port: bool,
 }
 
 impl CliArgs {
@@ -77,8 +76,7 @@ pub struct HttpTrigger {
     /// If the port is set to 0, the actual address will be determined by the OS.
     listen_addr: SocketAddr,
     tls_config: Option<TlsConfig>,
-    /// Optional port to listen on
-    port: Option<u16>,
+    find_free_port: bool,
 }
 
 impl<F: RuntimeFactors> Trigger<F> for HttpTrigger {
@@ -88,8 +86,14 @@ impl<F: RuntimeFactors> Trigger<F> for HttpTrigger {
     type InstanceState = ();
 
     fn new(cli_args: Self::CliArgs, app: &spin_app::App) -> anyhow::Result<Self> {
-        let port = cli_args.port;
-        Self::new(app, cli_args.address, cli_args.into_tls_config(), port)
+        let find_free_port = cli_args.find_free_port;
+
+        Self::new(
+            app,
+            cli_args.address,
+            cli_args.into_tls_config(),
+            find_free_port,
+        )
     }
 
     async fn run(self, trigger_app: TriggerApp<F>) -> anyhow::Result<()> {
@@ -111,14 +115,14 @@ impl HttpTrigger {
         app: &spin_app::App,
         listen_addr: SocketAddr,
         tls_config: Option<TlsConfig>,
-        port: Option<u16>,
+        find_free_port: bool,
     ) -> anyhow::Result<Self> {
         Self::validate_app(app)?;
 
         Ok(Self {
             listen_addr,
             tls_config,
-            port,
+            find_free_port,
         })
     }
 
@@ -130,9 +134,14 @@ impl HttpTrigger {
         let Self {
             listen_addr,
             tls_config,
-            port,
+            find_free_port,
         } = self;
-        let server = Arc::new(HttpServer::new(listen_addr, tls_config, port, trigger_app)?);
+        let server = Arc::new(HttpServer::new(
+            listen_addr,
+            tls_config,
+            find_free_port,
+            trigger_app,
+        )?);
         Ok(server)
     }
 

crates/trigger-http/src/server.rs

@@ -53,8 +53,8 @@ pub struct HttpServer<F: RuntimeFactors> {
     listen_addr: SocketAddr,
     /// The TLS configuration for the server.
     tls_config: Option<TlsConfig>,
-    /// Optional custom port the server is listening on.
-    port: Option<u16>,
+    /// Whether to find a free port if the specified port is already in use.
+    find_free_port: bool,
     /// Request router.
     router: Router,
     /// The app being triggered.
@@ -70,7 +70,7 @@ impl<F: RuntimeFactors> HttpServer<F> {
     pub fn new(
         listen_addr: SocketAddr,
         tls_config: Option<TlsConfig>,
-        port: Option<u16>,
+        find_free_port: bool,
         trigger_app: TriggerApp<F>,
     ) -> anyhow::Result<Self> {
         // This needs to be a vec before building the router to handle duplicate routes
@@ -138,7 +138,7 @@ impl<F: RuntimeFactors> HttpServer<F> {
         Ok(Self {
             listen_addr,
             tls_config,
-            port,
+            find_free_port,
             router,
             trigger_app,
             component_trigger_configs,
@@ -148,31 +148,47 @@ impl<F: RuntimeFactors> HttpServer<F> {
 
     /// Serve incoming requests over the provided [`TcpListener`].
     pub async fn serve(self: Arc<Self>) -> anyhow::Result<()> {
-        let listener: anyhow::Result<TcpListener> = match TcpListener::bind(self.listen_addr).await
-        {
-            Ok(listener) => Ok(listener),
+        let listener: TcpListener = match TcpListener::bind(self.listen_addr).await {
+            Ok(listener) => listener,
             Err(err) => {
-                if err.kind() == ErrorKind::AddrInUse {
-                    let mut addr = self.listen_addr;
-                    addr.set_port(self.port.unwrap_or(0));
-                    let listener = TcpListener::bind(addr).await.with_context(|| {
-                        format!(
-                            "Unable to listen on {listen_addr}",
-                            listen_addr = self.listen_addr
-                        )
-                    })?;
+                if self.find_free_port && err.kind() == ErrorKind::AddrInUse {
+                    let mut found_listener = None;
+                    for _ in 1..=9 {
+                        let mut addr = self.listen_addr;
+                        addr.set_port(addr.port() + 1);
+
+                        match TcpListener::bind(addr).await {
+                            Ok(listener) => {
+                                found_listener = Some(listener);
+                                break;
+                            }
+                            Err(err) => {
+                                if err.kind() == ErrorKind::AddrInUse {
+                                    continue;
+                                }
+                                return Err(anyhow::anyhow!("Unable to listen on {}", addr));
+                            }
+                        }
+                    }
 
-                    Ok(listener)
+                    match found_listener {
+                        Some(listener) => listener,
+                        None => {
+                            return Err(anyhow::anyhow!(
+                                "All retries failed. Unable to bind to a free port"
+                            ));
+                        }
+                    }
                 } else {
-                    Err(anyhow::anyhow!("Unable to listen on {}", self.listen_addr))
+                    return Err(anyhow::anyhow!("Unable to listen on {}", self.listen_addr));
                 }
             }
         };
 
         if let Some(tls_config) = self.tls_config.clone() {
-            self.serve_https(listener?, tls_config).await?;
+            self.serve_https(listener, tls_config).await?;
         } else {
-            self.serve_http(listener?).await?;
+            self.serve_http(listener).await?;
         }
         Ok(())
     }

tests/testing-framework/src/runtimes/in_process_spin.rs

@@ -104,7 +104,7 @@ async fn initialize_trigger(
     .await?;
 
     let app = spin_app::App::new("my-app", locked_app);
-    let trigger = HttpTrigger::new(&app, "127.0.0.1:80".parse().unwrap(), None, None)?;
+    let trigger = HttpTrigger::new(&app, "127.0.0.1:80".parse().unwrap(), None, true)?;
     let mut builder = TriggerAppBuilder::<_, FactorsBuilder>::new(trigger);
     let trigger_app = builder
         .build(