Recommendation for dumb simple http server?

GoLang has a http server built into it’s stdlib.
Elixir has Phoenix/Cowboy.

Suppose I am looking for a dumb simple http server where:

  1. I need it to serve static files
  2. if I need to do any routing, I’ll parse the http URL myself

What is recommended?

I am looking for a minimal http server where it has the basics and I can understand all the features fully.

The most barebones may be this Erlang -- HTTP server

As for recommended, considering you’re using Elixir, I’d say Plug v1.12.1 — Documentation with GitHub - elixir-plug/plug_cowboy: Plug adapter for the Cowboy web server, but that escapes your requirements I’m afraid.

Depends on how much time you want to spend on it and how deep into the rabbit hole you want to go I guess. Unless you want to know how exactly does cowboy work, plug is super simple.

2 Likes

What do you consider basics?

Just these:

Just an idea, but if you don’t need to do any special processing, wouldn’t using nginx or caddy be more than enough for you?

3 Likes

I am looking for small, programmable components. Nginx/Caddy are harder to program compared to builtin Elixir/Erlang libs.

You might want to check out bandit as an alternative to Cowboy. It should be simpler to understand although it is much less battle tested.

2 Likes

I like elli (GitHub - elli-lib/elli: Simple, robust and performant Erlang web server) which I’ve used in erlang many times. It is OK to use from elixir as well. In my opinion it is very easy to understand. The implementation is very readable (if you read erlang).

It just does the basics though and you must be prepared to add some middleware or write your own if you need more functionality.

To get started (well, you should read the README.md from their github and follow any links. One of the best things as well is to look in the source for the example callback. I find it is the best place to look to see what is possible):

in mix.exs add {:elli, "~> 3.3.0"} to dependencies.

Write a simple call back module to handle your requests:

defmodule YourApp.ElliHandler do
  @behaviour :elli_handler
  @staticpath "/some/good/path"
  @impl :elli_handler
  @doc """
  The handle/2 function is one of the callbacks.
  It takes the request and returns a response.
  
  It can serve static files via sendfile by just
  returning {:ok, [], {:file, filename}}
  """
  def handle(req, _args) do
    # Split up the method and path and delegate to other functions
    # which uses pattern matching to match on the path. The path
    # is a list of parts of the url split by "/"
    handle(:elli_request.method(req), :elli_request.path(req), req)
  end

  @doc """
  If the paths is /static/<filename>. Serve the file if it exists
  TODO: fix content-type
  """
  defp handle(:'GET', ["static", filename], _req) do
    path = File.join(@staticpath, filename)
    if File.exists(path) do
      {:ok, [], {:file, path}}
    else
      {404, [], "Not Found"}
    end
  end
  defp handle(:'GET', ["dynamic", "user", id], _req) do
    {:ok, [{"Content-Type", "plain/text"}], "User is #{id}"}
  end
  defp handle(_, _, _req) do
    {404, [], "Not Found"}
  end

  @impl :elli_handler
  @doc """
  Will be called during many events of the request cycle. Can be used to hook in to many things
  or not be used at all.
  """
  def handle_event(_event, _data, _args) do
    :ok
  end
end

And hook it up in your supervision tree:

  @impl true
  def start(_type, _args) do
    children = [
      %{
        id: :elli,
        start: {:elli, :start_link, [ [ callback: YourApp.ElliHandler, port: 3000  ]]}
      }
    ]
    opts = [strategy: :one_for_one, name: YourApp.Supervisor]
    Supervisor.start_link(children, opts)
  end
5 Likes

Single file Phoenix server: phoenix.exs · GitHub.

2 Likes

Interesting blog post I ran across: