Fix baseUri should provide correct value for ANY_ADDRESS. (#563)

chronos/apps/http/httpserver.nim

@@ -252,47 +252,42 @@ proc new*(
        dualstack = DualStackType.Auto,
        middlewares: openArray[HttpServerMiddlewareRef] = []
      ): HttpResult[HttpServerRef] =
-
+  let
-  let serverUri =
+    serverInstance =
-    if len(serverUri.hostname) > 0:
-      serverUri
-    else:
       try:
-        parseUri("http://" & $address & "/")
+        createStreamServer(address, flags = socketFlags, bufferSize = bufferSize,
-      except TransportAddressError as exc:
+                           backlog = backlogSize, dualstack = dualstack)
+      except TransportOsError as exc:
         return err(exc.msg)
-
+    serverUri =
-  let serverInstance =
+      if len(serverUri.hostname) > 0:
-    try:
+        serverUri
-      createStreamServer(address, flags = socketFlags, bufferSize = bufferSize,
+      else:
-                         backlog = backlogSize, dualstack = dualstack)
+        parseUri("http://" & $serverInstance.localAddress() & "/")
-    except TransportOsError as exc:
+    res = HttpServerRef(
-      return err(exc.msg)
+      address: serverInstance.localAddress(),
-
+      instance: serverInstance,
-  var res = HttpServerRef(
+      processCallback: processCallback,
-    address: serverInstance.localAddress(),
+      createConnCallback: createConnection,
-    instance: serverInstance,
+      baseUri: serverUri,
-    processCallback: processCallback,
+      serverIdent: serverIdent,
-    createConnCallback: createConnection,
+      flags: serverFlags,
-    baseUri: serverUri,
+      socketFlags: socketFlags,
-    serverIdent: serverIdent,
+      maxConnections: maxConnections,
-    flags: serverFlags,
+      bufferSize: bufferSize,
-    socketFlags: socketFlags,
+      backlogSize: backlogSize,
-    maxConnections: maxConnections,
+      headersTimeout: httpHeadersTimeout,
-    bufferSize: bufferSize,
+      maxHeadersSize: maxHeadersSize,
-    backlogSize: backlogSize,
+      maxRequestBodySize: maxRequestBodySize,
-    headersTimeout: httpHeadersTimeout,
+      # semaphore:
-    maxHeadersSize: maxHeadersSize,
+      #   if maxConnections > 0:
-    maxRequestBodySize: maxRequestBodySize,
+      #     newAsyncSemaphore(maxConnections)
-    # semaphore:
+      #   else:
-    #   if maxConnections > 0:
+      #     nil
-    #     newAsyncSemaphore(maxConnections)
+      lifetime: newFuture[void]("http.server.lifetime"),
-    #   else:
+      connections: initOrderedTable[string, HttpConnectionHolderRef](),
-    #     nil
+      middlewares: prepareMiddlewares(processCallback, middlewares)
-    lifetime: newFuture[void]("http.server.lifetime"),
+    )
-    connections: initOrderedTable[string, HttpConnectionHolderRef](),
-    middlewares: prepareMiddlewares(processCallback, middlewares)
-  )
   ok(res)
 
 proc new*(

chronos/apps/http/shttpserver.nim

@@ -98,52 +98,47 @@ proc new*(htype: typedesc[SecureHttpServerRef],
           maxRequestBodySize: int = 1_048_576,
           dualstack = DualStackType.Auto
          ): HttpResult[SecureHttpServerRef] =
-
   doAssert(not(isNil(tlsPrivateKey)), "TLS private key must not be nil!")
   doAssert(not(isNil(tlsCertificate)), "TLS certificate must not be nil!")
-
+  let
-  let serverUri =
+    serverInstance =
-    if len(serverUri.hostname) > 0:
-      serverUri
-    else:
       try:
-        parseUri("https://" & $address & "/")
+        createStreamServer(address, flags = socketFlags,
-      except TransportAddressError as exc:
+                           bufferSize = bufferSize,
+                           backlog = backlogSize, dualstack = dualstack)
+      except TransportOsError as exc:
         return err(exc.msg)
-
+    serverUri =
-  let serverInstance =
+      if len(serverUri.hostname) > 0:
-    try:
+        serverUri
-      createStreamServer(address, flags = socketFlags, bufferSize = bufferSize,
+      else:
-                         backlog = backlogSize, dualstack = dualstack)
+        parseUri("https://" & $serverInstance.localAddress() & "/")
-    except TransportOsError as exc:
+    res = SecureHttpServerRef(
-      return err(exc.msg)
+      address: serverInstance.localAddress(),
-
+      instance: serverInstance,
-  let res = SecureHttpServerRef(
+      processCallback: processCallback,
-    address: address,
+      createConnCallback: createSecConnection,
-    instance: serverInstance,
+      baseUri: serverUri,
-    processCallback: processCallback,
+      serverIdent: serverIdent,
-    createConnCallback: createSecConnection,
+      flags: serverFlags + {HttpServerFlags.Secure},
-    baseUri: serverUri,
+      socketFlags: socketFlags,
-    serverIdent: serverIdent,
+      maxConnections: maxConnections,
-    flags: serverFlags + {HttpServerFlags.Secure},
+      bufferSize: bufferSize,
-    socketFlags: socketFlags,
+      backlogSize: backlogSize,
-    maxConnections: maxConnections,
+      headersTimeout: httpHeadersTimeout,
-    bufferSize: bufferSize,
+      maxHeadersSize: maxHeadersSize,
-    backlogSize: backlogSize,
+      maxRequestBodySize: maxRequestBodySize,
-    headersTimeout: httpHeadersTimeout,
+      # semaphore:
-    maxHeadersSize: maxHeadersSize,
+      #   if maxConnections > 0:
-    maxRequestBodySize: maxRequestBodySize,
+      #     newAsyncSemaphore(maxConnections)
-    # semaphore:
+      #   else:
-    #   if maxConnections > 0:
+      #     nil
-    #     newAsyncSemaphore(maxConnections)
+      lifetime: newFuture[void]("http.server.lifetime"),
-    #   else:
+      connections: initOrderedTable[string, HttpConnectionHolderRef](),
-    #     nil
+      tlsCertificate: tlsCertificate,
-    lifetime: newFuture[void]("http.server.lifetime"),
+      tlsPrivateKey: tlsPrivateKey,
-    connections: initOrderedTable[string, HttpConnectionHolderRef](),
+      secureFlags: secureFlags
-    tlsCertificate: tlsCertificate,
+    )
-    tlsPrivateKey: tlsPrivateKey,
-    secureFlags: secureFlags
-  )
   ok(res)
 
 proc new*(htype: typedesc[SecureHttpServerRef],

tests/testhttpserver.nim

@@ -1790,3 +1790,40 @@ suite "HTTP server testing suite":
 
     await server.stop()
     await server.closeWait()
+
+  asyncTest "HTTP server - baseUri value test":
+    proc process(r: RequestFence): Future[HttpResponseRef] {.
+         async: (raises: [CancelledError]).} =
+      defaultResponse()
+
+    let
+      expectUri2 = "http://www.chronos-test.com/"
+      address = initTAddress("127.0.0.1:0")
+      socketFlags = {ServerFlags.TcpNoDelay, ServerFlags.ReuseAddr}
+      res1 = HttpServerRef.new(address, process,
+                               socketFlags = socketFlags)
+      res2 = HttpServerRef.new(address, process,
+                               socketFlags = socketFlags,
+                               serverUri = parseUri(expectUri2))
+    check:
+      res1.isOk == true
+      res2.isOk == true
+
+    let
+      server1 = res1.get()
+      server2 = res2.get()
+
+    try:
+      server1.start()
+      server2.start()
+      let
+        localAddress = server1.instance.localAddress()
+        expectUri1 = "http://127.0.0.1:" & $localAddress.port & "/"
+      check:
+        server1.baseUri == parseUri(expectUri1)
+        server2.baseUri == parseUri(expectUri2)
+    finally:
+      await server1.stop()
+      await server1.closeWait()
+      await server2.stop()
+      await server2.closeWait()

tests/testshttpserver.nim

@@ -186,3 +186,49 @@ suite "Secure HTTP server testing suite":
       return serverRes and data == "EXCEPTION"
 
     check waitFor(testHTTPS2(initTAddress("127.0.0.1:30080"))) == true
+
+  asyncTest "HTTPS server - baseUri value test":
+    proc process(r: RequestFence): Future[HttpResponseRef] {.
+         async: (raises: [CancelledError]).} =
+      defaultResponse()
+
+    let
+      expectUri2 = "https://www.chronos-test.com/"
+      address = initTAddress("127.0.0.1:0")
+      socketFlags = {ServerFlags.TcpNoDelay, ServerFlags.ReuseAddr}
+      serverFlags = {Secure}
+      secureKey = TLSPrivateKey.init(HttpsSelfSignedRsaKey)
+      secureCert = TLSCertificate.init(HttpsSelfSignedRsaCert)
+      res1 = SecureHttpServerRef.new(address, process,
+                                     socketFlags = socketFlags,
+                                     serverFlags = serverFlags,
+                                     tlsPrivateKey = secureKey,
+                                     tlsCertificate = secureCert)
+      res2 = SecureHttpServerRef.new(address, process,
+                                     socketFlags = socketFlags,
+                                     serverFlags = serverFlags,
+                                     serverUri = parseUri(expectUri2),
+                                     tlsPrivateKey = secureKey,
+                                     tlsCertificate = secureCert)
+    check:
+      res1.isOk == true
+      res2.isOk == true
+
+    let
+      server1 = res1.get()
+      server2 = res2.get()
+
+    try:
+      server1.start()
+      server2.start()
+      let
+        localAddress = server1.instance.localAddress()
+        expectUri1 = "https://127.0.0.1:" & $localAddress.port & "/"
+      check:
+        server1.baseUri == parseUri(expectUri1)
+        server2.baseUri == parseUri(expectUri2)
+    finally:
+      await server1.stop()
+      await server1.closeWait()
+      await server2.stop()
+      await server2.closeWait()