feat: implemented hot swap

justfile

@@ -0,0 +1,19 @@
+PACKAGE:="realtime_chat"
+BASE:="build/erlang-shipment"
+
+build:
+ gleam export erlang-shipment
+
+start:
+ erl \
+ -sname worker \
+ -pa {{BASE}}/*/ebin \
+ -eval "{{PACKAGE}}@@main:run({{PACKAGE}})" \
+ -noshell
+
+update: build
+ erl \
+ -sname shell \
+ -pa {{BASE}}/*/ebin \
+ -eval "gleam@io:debug(updater:trigger_update(worker@{{`hostname`}})), halt()" \
+ -noshell

pkgx.yaml

@@ -1 +1 @@
-dependencies: gleam@1 erlang.org@27
+dependencies: gleam@1 erlang.org@27 just@1

src/handler.gleam

@@ -0,0 +1,141 @@
+import gleam/bit_array
+import gleam/bytes_builder
+import gleam/erlang/process
+import gleam/function
+import gleam/http
+import gleam/http/request.{type Request}
+import gleam/http/response
+import gleam/io
+import gleam/otp/actor
+import gleam/result
+import gleam/string
+import gleam/string_builder
+import mist.{type Connection}
+import pubsub.{Message, Subscribe, Unsubscribe}
+import simplifile
+
+/// Create a new HTTP response with the given status code and body.
+fn new_response(status: Int, body: String) {
+ response.new(status)
+ |> response.set_body(body |> bytes_builder.from_string |> mist.Bytes)
+}
+
+// Define some common responses.
+fn bad_request(error: String) {
+ new_response(400, "Bad request: " <> error)
+}
+
+fn not_found() {
+ new_response(404, "Not found")
+}
+
+fn internal_error() {
+ new_response(500, "Internal server error")
+}
+
+pub fn handle(pubsub, request: Request(Connection)) {
+ // Basic router matching the request method and path of the request.
+ let result = case request.method, request.path {
+ // On 'GET /', read the index.html file and return it.
+ http.Get, "/" -> {
+ use index <- result.try(
+ simplifile.read("src/index.html")
+ |> result.replace_error("Could not read index.html"),
+ )
+ new_response(200, index) |> Ok
+ }
+
+ // On 'POST /post', read the body and send it to the pubsub.
+ http.Post, "/post" -> {
+ let result = {
+ // Read the first 128 bytes of the request.
+ use request <- result.try(
+ request
+ |> mist.read_body(128)
+ // Ignore potential `ReadError` and replace it with `Nil`, so
+ // that the `Result` type does not clash with the one from
+ // `bit_array.to_string`.
+ |> result.replace_error("Could not read request body"),
+ )
+ // Transform the bytes into a string.
+ use message <- result.try(
+ request.body
+ |> bit_array.to_string
+ |> result.replace_error("Could not convert request body to string"),
+ )
+
+ // Send the message to the pubsub.
+ process.send(pubsub, Message(message |> string.reverse))
+
+ // Respond with a success message.
+ new_response(200, "Submitted: " <> message) |> Ok
+ }
+
+ case result {
+ Ok(response) -> response |> Ok
+ Error(error) -> error |> bad_request |> Ok
+ }
+ }
+
+ // On 'GET /sse', start a Server-Sent Events (SSE) connection.
+ // The SSE loop runs in a separate process, we will use the pubsub
+ // to send and receive messages.
+ http.Get, "/sse" ->
+ mist.server_sent_events(
+ request,
+ response.new(200),
+ // Initialization function of the SSE loop.
+ init: fn() {
+ // Create a new subject for the client to receive messages.
+ let client = process.new_subject()
+
+ // Send this new client to the pubsub.
+ process.send(pubsub, Subscribe(client))
+
+ // Define on what messages the SSE loop function should run:
+ // on every message send to the `client` subject.
+ let selector =
+ process.new_selector()
+ |> process.selecting(client, function.identity)
+
+ // Start the loop with the client as state and a selector
+ // pointing to the client subject.
+ actor.Ready(client, selector)
+ },
+ // This loop function is called every time the `client` subject
+ // defined above receives a message.
+ // The first parameter is the incoming message, the second is the
+ // SSE connection, and the third is the loop state, which, in this
+ // case is always the client subject.
+ loop: fn(message, connection, client) {
+ // Forward the message to the web client.
+ case
+ mist.send_event(
+ connection,
+ message |> string_builder.from_string |> mist.event,
+ )
+ {
+ // If it succeeds, continue the process.
+ Ok(_) -> actor.continue(client)
+ // If it fails, disconnect the client and stop the process.
+ Error(_) -> {
+ process.send(pubsub, Unsubscribe(client))
+ actor.Stop(process.Normal)
+ }
+ }
+ },
+ )
+ |> Ok
+
+ // In case of any other request, return a 404.
+ _, _ -> not_found() |> Ok
+ }
+
+ case result {
+ Ok(response) -> response
+ Error(error) -> {
+ io.println_error(error)
+ internal_error()
+ }
+ }
+}

src/pubsub.gleam

@@ -0,0 +1,47 @@
+import gleam/erlang/process.{type Subject}
+import gleam/io
+import gleam/list
+import gleam/otp/actor
+
+/// Message types for the pubsub actor.
+///
+/// The pubsub actor manages the clients listening for messages and
+/// forwards messages to all connected clients.
+pub type PubSubMessage {
+ /// A new client has connected and wants to receive messages.
+ Subscribe(Subject(String))
+ /// A client has disconnected and should no longer receive messages.
+ Unsubscribe(Subject(String))
+ /// A message to forward to all connected clients.
+ Message(String)
+}
+
+/// This is the pubsub loop function, which receives messages and produces
+/// a new state. The pubsub runs in a separate process.
+///
+/// In Gleam, variables are immutable, so we rely on the Actor model to manage
+/// state. In this case, the state is a list of connected clients.
+pub fn pubsub_loop(message: PubSubMessage, clients: List(Subject(String))) {
+ case message {
+ // When the pubsub receives a Subscribe message with a client in it,
+ // continue running the actor loop with the client added to the state.
+ Subscribe(client) -> {
+ io.println("+ New client connected")
+ [client, ..clients] |> actor.continue
+ }
+ // When the pubsub receives a Unsubscribe message with a client in it,
+ // produce a new state with the client removed and continue running.
+ Unsubscribe(client) -> {
+ io.println("- A client disconnected")
+ clients
+ |> list.filter(fn(c) { c != client })
+ |> actor.continue
+ }
+ // Finally, when the pubsub receives a Message, forward it to clients.
+ Message(message) -> {
+ io.println("> Forwarding message to clients: " <> message)
+ clients |> list.each(process.send(_, message))
+ clients |> actor.continue
+ }
+ }
+}