mist

A mist server is initialized using a Builder pattern. You start with mist.new, configure it using various methods like bind, port, and with_ipv6, and finally call mist.start with a handler function. The handler function receives a Request(Connection) and must return a Response(ResponseData).

import mist
import gleam/http/request.{type Request}
import gleam/http/response.{type Response}
import mist.{type Connection, type ResponseData}

pub fn main() {
  let assert Ok(_) =
    fn(req: Request(Connection)) -> Response(ResponseData) {
      // Your routing logic here
      response.new(200) |> response.set_body(mist.Bytes(bytes_tree.new()))
    }
    |> mist.new()
    |> mist.bind("localhost")
    |> mist.port(4000)
    |> mist.start()

  // Keep the process alive
  process.sleep_forever()
}

To add complete to your Gleam project, use the gleam add command.

gleam add complete

If you are working within the complete example directory, you can use the following Gleam commands to manage development:

• gleam run: Executes the project.
• gleam test: Runs the project's test suite.
• gleam shell: Opens an Erlang shell for interactive development.

gleam run   # Run the project
gleam test  # Run the tests
gleam shell # Run an Erlang shell

To use over_http2 in your Gleam project, add it via the Gleam CLI using the following command:

gleam add over_http2@1

If you are working directly within the eventz example repository, you can use the following Gleam commands to manage development:

• gleam run: Executes the project.
• gleam test: Runs the test suite.
• gleam shell: Opens an Erlang shell for interactive development.

gleam run   # Run the project
gleam test  # Run the tests
gleam shell # Run an Erlang shell

If you are working within the over_http2 example repository, you can use the standard Gleam commands to execute the project or run its test suite.

gleam run   # Run the project
gleam test  # Run the tests

To use mist in a new Gleam project, create a new project and add the necessary dependencies using gleam add. You will typically need mist, logging, gleam_erlang, and gleam_http for a complete web server setup.

$ gleam new <your_project>
$ cd <your_project>
$ gleam add mist logging gleam_erlang gleam_http

mist.send_file provides an easy way to serve static files. It returns a Result containing the file data (as a Response body) or an error. You can specify an offset and a limit for partial file serving.

// Example file serving
mist.send_file(file_path, offset: 0, limit: None)
  |> result.map(fn(file) {
    response.new(200)
    |> response.set_body(file)
  })

For large request bodies, use mist.stream(req) to get a consume function. This function allows you to pull chunks of data from the request incrementally, preventing high memory usage.

case mist.stream(req) {
  Ok(consume) -> {
    // consume(size) returns Result(mist.Chunk, mist.ReadError)
    // mist.Chunk(data, next_consume_fn)
  }
  Error(_reason) -> { /* handle error */ }
}

Use mist.chunked to stream a response to the client in chunks. This function takes the request, a base response, an initialization function that spawns the chunk producer, and a handler that manages the chunking lifecycle.

Inside the handler, use mist.send_chunk(connection, bit_array) to send data and mist.chunk_continue(state) to proceed. Use mist.chunk_stop() to finish the response.