Raxx

Interface for HTTP webservers, frameworks and clients.

• Install from hex.pm
• Documentation available on hexdoc

Getting started

HTTP is an exchange where a client send a request to a server and expects a response. At its simplest this can be viewed as follows

Simple client server exchange.

           request -->
Client ============================================ Server
                                   <-- response

Simple server

The HomePage server implements the simplest HTTP message exchange. The complete response is constructed from the request.

defmodule HomePage do
  use Raxx.Server

  @impl Raxx.Server
  def handle_request(%{method: :GET, path: []}, _state) do
    response(:ok)
    |> set_header("content-type", "text/plain")
    |> set_body("Hello, World!")
  end
end

• A request’s path is split into segments, so the root “/“ becomes [].

Running a server

To start a web service a Raxx compatable server is needed. For example Ace.

server = HomePage
initial_state = %{}
options = [port: 8080, cleartext: true]

{:ok, pid} = Ace.HTTP.Service.start_link({server, initial_state}, options)

Visit http://localhost:8080.

Stateful server

The LongPoll server is stateful. After receving a complete request this server has to wait for extra input before sending a response to the client.

defmodule LongPoll do
  use Raxx.Server

  @impl Raxx.Server
  def handle_request(%{method: :GET, path: ["slow"]}, state) do
    Process.send_after(self(), :reply, 30_000)

    {[], state}
  end

  @impl Raxx.Server
  def handle_info(:reply, _state) do
    response(:ok)
    |> set_header("content-type", "text/plain")
    |> set_body("Hello, Thanks for waiting.")
  end
end

• A long lived server needs to return two tings; the message parts to send in, this case nothing []; and the new state of the server, in this case no change state.
• The initial_state is configured when the server is started.

Streaming

Any client server exchange is actually a stream of information in either direction. Raxx.Server provides callbacks to proccess parts of a stream as they are received.

Detailed view of client server exchange.

           tail | data(1+) | head(request) -->
Client ============================================ Server
           <-- head(response) | data(1+) | tail

• The body of a request or a response, is the combination of all data parts sent.

Server streaming

The SubscribeToMessages server streams its response, The server will send the head of the response upon receiving the request. Data is sent to the client, as part of the body, when it becomes available. The response is completed when the chatroom sends a :closed message.

defmodule SubscribeToMessages do
  use Raxx.Server

  @impl Raxx.Server
  def handle_head(%{method: :GET, path: ["messages"]}, state) do
    {:ok, _} = ChatRoom.join()
    outbound = [response(:ok)
    |> set_header("content-type", "text/plain")
    |> set_body(true)]

    {outbound, state}
  end

  @impl Raxx.Server
  def handle_info({ChatRoom, data}, config) do
    outbound = [data(data)]

    {outbound, config}
  end

  def handle_info({ChatRoom, :closed}, config) do
    outbound = [tail()]

    {outbound, config}
  end
end

• Using set_body(true) marks that the response has a body that it is not yet known.
• A stream must have a tail to complete, metadata added here will be sent as trailers.

Client streaming

The Upload server writes data to a file as it is received. Only once the complete request has been received is a response sent.

defmodule Upload do
  use Raxx.Server

  @impl Raxx.Server
  def handle_head(%{method: :PUT, path: ["upload"] body: true}, _state) do
    {:ok, io_device} = File.open("my/path")
    {[], {:file, device}}
  end

  @impl Raxx.Server
  def handle_data(data, state = {:file, device}) do
    IO.write(device, data)
    {[], state}
  end

  @impl Raxx.Server
  def handle_tail(_trailers, state) do
    response(:see_other)
    |> set_header("location", "/")
  end
end

• A body may arrive split by packets, chunks or frames. handle_data will be invoked as each part arrives. An application should never assume how a body will be broken into data parts.

Routing

the Raxx.Router can be used to match requests to specific server modules.

defmodule MyApp do
  use Raxx.Server

  use Raxx.Router, [
    {%{method: :GET, path: []}, HomePage},
    {%{method: :GET, path: ["slow"]}, LongPoll},
    {%{method: :GET, path: ["messages"]}, SubscribeToMessages},
    {%{method: :PUT, path: ["upload"]}, Upload},
    {_, NotFoundPage}
  ]
end

Community

• elixir-lang slack channel
• FAQ

Testing

To work with Raxx locally Elixir 1.5 or greater must be installed.

git clone git@github.com:CrowdHailer/raxx.git
cd raxx

mix deps.get
mix test