More exposed settings for worker timeout and active state

CHANGELOG.md

@@ -1,8 +1,20 @@
 # Unreleased
 
+- `new` now takes `listener_name` and `connection_factory_name` as its first two 
+  arguments, created once by the caller with `process.new_name`. This replaces 
+  the previous behaviour of generating these names internally on every 
+  `start` and `start_unix` call, which could exhaust the atom table under 
+  supervised restarts
+- Resolve the connection factory supervisor once per acceptor instead of on 
+  every accepted connection
+- Fix connection handler not applying user's selector on continue.
+- `get_server_info` now takes the listener's `Subject` rather than its `Name`
+- Replace `ServerInfo` and `ConnectionInfo` with a single `SocketAddress` type
 - support in-memory `PEM` and `DER` certificates for TLS
 - support mTLS
 - Support unix sockets
+- Support custom connection shutdown timeout
+- Support updating active state on continue
 
 # v9.0.1
 

examples/echo_server/src/echo_server.gleam

@@ -8,32 +8,38 @@ import logging
 
 pub fn main() {
   let listener_name = process.new_name("glisten_listener")
+  let connection_factory_name = process.new_name("glisten_connection_factory")
 
   logging.configure()
   logging.set_level(logging.Debug)
 
   let assert Ok(_server) =
-    glisten.new(fn(_conn) { #(Nil, None) }, fn(state, msg, conn) {
-      let assert Ok(info) = glisten.get_connection_info(conn)
-      logging.log(
-        logging.Info,
-        "Client connected at "
-          <> glisten.ip_address_to_string(info.ip_address)
-          <> " at port "
-          <> int.to_string(info.port),
-      )
+    glisten.new(
+      listener_name,
+      connection_factory_name,
+      fn(_conn) { #(Nil, None) },
+      fn(state, msg, conn) {
+        let assert Ok(glisten.TcpSocketAddress(port:, ip_address:)) =
+          glisten.get_connection_info(conn)
+        logging.log(
+          logging.Info,
+          "Client connected at "
+            <> glisten.ip_address_to_string(ip_address)
+            <> " at port "
+            <> int.to_string(port),
+        )
 
-      let assert Packet(msg) = msg
-      let assert Ok(_) = glisten.send(conn, bytes_tree.from_bit_array(msg))
-      glisten.continue(state)
-    })
+        let assert Packet(msg) = msg
+        let assert Ok(_) = glisten.send(conn, bytes_tree.from_bit_array(msg))
+        glisten.continue(state)
+      },
+    )
     |> glisten.bind("localhost")
     |> glisten.with_ipv6
-    |> glisten.with_listener_name(listener_name)
     |> glisten.start(0)
 
-  let assert glisten.TcpServerInfo(port:, ip_address:) =
-    glisten.get_server_info(listener_name, 5000)
+  let assert glisten.TcpSocketAddress(port:, ip_address:) =
+    glisten.get_server_info(process.named_subject(listener_name), 5000)
 
   io.println(
     "Listening on "

examples/echo_ssl/src/echo_server.gleam

@@ -8,30 +8,36 @@ import logging
 
 pub fn main() {
   let listener_name = process.new_name("glisten_listener")
+  let connection_factory_name = process.new_name("glisten_connection_factory")
 
   logging.configure()
   logging.set_level(logging.Debug)
 
   let assert Ok(_server) =
-    glisten.new(fn(_conn) { #(Nil, None) }, fn(state, msg, conn) {
-      let assert Ok(info) = glisten.get_connection_info(conn)
-      logging.log(
-        logging.Info,
-        "Client connected at "
-          <> glisten.ip_address_to_string(info.ip_address)
-          <> " at port "
-          <> int.to_string(info.port),
-      )
-      let assert Packet(msg) = msg
-      let assert Ok(_) = glisten.send(conn, bytes_tree.from_bit_array(msg))
-      glisten.continue(state)
-    })
+    glisten.new(
+      listener_name,
+      connection_factory_name,
+      fn(_conn) { #(Nil, None) },
+      fn(state, msg, conn) {
+        let assert Ok(glisten.TcpSocketAddress(port:, ip_address:)) =
+          glisten.get_connection_info(conn)
+        logging.log(
+          logging.Info,
+          "Client connected at "
+            <> glisten.ip_address_to_string(ip_address)
+            <> " at port "
+            <> int.to_string(port),
+        )
+        let assert Packet(msg) = msg
+        let assert Ok(_) = glisten.send(conn, bytes_tree.from_bit_array(msg))
+        glisten.continue(state)
+      },
+    )
     |> glisten.with_tls(certfile: "localhost.crt", keyfile: "localhost.key")
-    |> glisten.with_listener_name(listener_name)
     |> glisten.start(0)
 
-  let assert glisten.TcpServerInfo(port, ip_address) =
-    glisten.get_server_info(listener_name, 5000)
+  let assert glisten.TcpSocketAddress(port, ip_address) =
+    glisten.get_server_info(process.named_subject(listener_name), 5000)
 
   io.println(
     "Listening on "

examples/echo_unix/src/echo_server.gleam

@@ -7,24 +7,29 @@ import logging
 
 pub fn main() {
   let listener_name = process.new_name("glisten_listener")
+  let connection_factory_name = process.new_name("glisten_connection_factory")
 
   logging.configure()
   logging.set_level(logging.Debug)
 
   let assert Ok(_server) =
-    glisten.new(fn(_conn) { #(Nil, None) }, fn(state, msg, conn) {
-      logging.log(logging.Info, "Client connected via unix socket")
+    glisten.new(
+      listener_name,
+      connection_factory_name,
+      fn(_conn) { #(Nil, None) },
+      fn(state, msg, conn) {
+        logging.log(logging.Info, "Client connected via unix socket")
 
-      let assert Packet(msg) = msg
-      let assert Ok(_) = glisten.send(conn, bytes_tree.from_bit_array(msg))
-      glisten.continue(state)
-    })
+        let assert Packet(msg) = msg
+        let assert Ok(_) = glisten.send(conn, bytes_tree.from_bit_array(msg))
+        glisten.continue(state)
+      },
+    )
     |> glisten.with_ipv6
-    |> glisten.with_listener_name(listener_name)
     |> glisten.start_unix("/tmp/test.sock")
 
-  let assert glisten.UnixServerInfo(path:) =
-    glisten.get_server_info(listener_name, 5000)
+  let assert glisten.UnixSocketAddress(path:) =
+    glisten.get_server_info(process.named_subject(listener_name), 5000)
 
   io.println("Listening on " <> path)