adding custom port in cli opt-in

Author: seun-ja

crates/trigger-http/src/lib.rs

@@ -50,6 +50,10 @@ pub struct CliArgs {
     /// The path to the certificate key to use for https, if this is not set, normal http will be used. The key should be in PKCS#8 format
     #[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>,
 }
 
 impl CliArgs {
@@ -73,6 +77,8 @@ 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>,
 }
 
 impl<F: RuntimeFactors> Trigger<F> for HttpTrigger {
@@ -82,7 +88,8 @@ impl<F: RuntimeFactors> Trigger<F> for HttpTrigger {
     type InstanceState = ();
 
     fn new(cli_args: Self::CliArgs, app: &spin_app::App) -> anyhow::Result<Self> {
-        Self::new(app, cli_args.address, cli_args.into_tls_config())
+        let port = cli_args.port;
+        Self::new(app, cli_args.address, cli_args.into_tls_config(), port)
     }
 
     async fn run(self, trigger_app: TriggerApp<F>) -> anyhow::Result<()> {
@@ -104,12 +111,14 @@ impl HttpTrigger {
         app: &spin_app::App,
         listen_addr: SocketAddr,
         tls_config: Option<TlsConfig>,
+        port: Option<u16>,
     ) -> anyhow::Result<Self> {
         Self::validate_app(app)?;
 
         Ok(Self {
             listen_addr,
             tls_config,
+            port,
         })
     }
 
@@ -121,8 +130,9 @@ impl HttpTrigger {
         let Self {
             listen_addr,
             tls_config,
+            port,
         } = self;
-        let server = Arc::new(HttpServer::new(listen_addr, tls_config, trigger_app)?);
+        let server = Arc::new(HttpServer::new(listen_addr, tls_config, port, trigger_app)?);
         Ok(server)
     }
 

crates/trigger-http/src/server.rs

@@ -1,4 +1,10 @@
-use std::{collections::HashMap, future::Future, io::IsTerminal, net::SocketAddr, sync::Arc};
+use std::{
+    collections::HashMap,
+    future::Future,
+    io::{ErrorKind, IsTerminal},
+    net::SocketAddr,
+    sync::Arc,
+};
 
 use anyhow::{bail, Context};
 use http::{
@@ -47,6 +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>,
     /// Request router.
     router: Router,
     /// The app being triggered.
@@ -62,6 +70,7 @@ impl<F: RuntimeFactors> HttpServer<F> {
     pub fn new(
         listen_addr: SocketAddr,
         tls_config: Option<TlsConfig>,
+        port: Option<u16>,
         trigger_app: TriggerApp<F>,
     ) -> anyhow::Result<Self> {
         // This needs to be a vec before building the router to handle duplicate routes
@@ -129,6 +138,7 @@ impl<F: RuntimeFactors> HttpServer<F> {
         Ok(Self {
             listen_addr,
             tls_config,
+            port,
             router,
             trigger_app,
             component_trigger_configs,
@@ -138,16 +148,31 @@ impl<F: RuntimeFactors> HttpServer<F> {
 
     /// Serve incoming requests over the provided [`TcpListener`].
     pub async fn serve(self: Arc<Self>) -> anyhow::Result<()> {
-        let listener = TcpListener::bind(self.listen_addr).await.with_context(|| {
-            format!(
-                "Unable to listen on {listen_addr}",
-                listen_addr = self.listen_addr
-            )
-        })?;
+        let listener: anyhow::Result<TcpListener> = match TcpListener::bind(self.listen_addr).await
+        {
+            Ok(listener) => Ok(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
+                        )
+                    })?;
+
+                    Ok(listener)
+                } else {
+                    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)?;
+    let trigger = HttpTrigger::new(&app, "127.0.0.1:80".parse().unwrap(), None, None)?;
     let mut builder = TriggerAppBuilder::<_, FactorsBuilder>::new(trigger);
     let trigger_app = builder
         .build(