Is it possible to start a Phoenix Server manually?

It looks like I’ll have to use the init/2 callback on an Endpoint: Phoenix.Endpoint — Phoenix v1.8.8

Although I’m not sure how I’ll handle the restart and increment logic with that yet

Okay, here is what I ended up with:

Instead of adding MyApp.Endpoint directly to my supervision tree I am adding this LsppWeb.PhoenixPortSupervisor that uses DynamicSupervisor to start up my Phoenix Endpoint, incrementing the port if it fails to startup initially.

defmodule LsppWeb.PhoenixPortSupervisor do
  @moduledoc """
  Starts up Phoenix, but controls the port with application configuration,
  increments the port until Phoenix starts up successfully.
  """
  use GenServer

  def start_link(_, name \\ __MODULE__) do
    GenServer.start_link(__MODULE__, nil, name: name)
  end

  def init(_) do
    initial_port = initial_port()

    start_phoenix(initial_port, initial_port)
  end

  defp start_phoenix(initial_port, port) when port - initial_port < 15 do
    set_port(port)

    DynamicSupervisor.start_child(LsppWeb.DynamicSupervisor, LsppWebWeb.Endpoint)
    |> interpret_results()
    |> case do
      {:ok, _} -> {:ok, []}
      {:error, :eaddrinuse} -> start_phoenix(initial_port, port + 1)
    end
  end

  defp start_phoenix(_, _) do
    {:error, :ports_exhausted}
  end

  def get_port, do: Application.get_env(:lspp_web, :phoenix_port)

  defp set_port(port) do
    Application.put_env(:lspp_web, :phoenix_port, port)
  end

  defp interpret_results({:ok, pid}), do: {:ok, pid}

  defp interpret_results({:error, error}) do
    case error do
      {:shutdown,
       {:failed_to_start_child, {:ranch_listener_sup, LsppWebWeb.Endpoint.HTTP},
        {:shutdown,
         {:failed_to_start_child, :ranch_acceptors_sup,
          {:listen_error, LsppWebWeb.Endpoint.HTTP, :eaddrinuse}}}}} ->
        {:error, :eaddrinuse}
    end
  end

  defp initial_port do
    cond do
      port = System.get_env("PORT") ->
        String.to_integer(port)

      config = Application.get_env(:lspp_web, LsppWebWeb.Endpoint) ->
        get_in(config, [:http, :port])

      true ->
        raise "Port not set"
    end
  end
end

Then in LsppWeb.Endpoint I define an init/2 callback:

  def init(supervisor, config) do
    port = LsppWeb.PhoenixPortSupervisor.get_port()
    config = put_in(config[:http], [:inet6, {:port, port}])

    {:ok, config}
  end

Any feedback or critique is welcome. The ugliest part of the code right now is how I shuttle the new port through the application environment. I suppose since LsppWeb.PhoenixPortSupervisor is a GenServer maybe that could be handled with a GenServer.call, but then I would need another GenServer/process since currently LsppWeb.PhoenixPortSupervisor doesn’t finish it’s startup until my LsppWeb.Endpoint has finished.

Might be not what you want, but just in case, you can try setting the port to 0 in your config, then cowboy would ask ranch would ask gen tcp would ask OS for a random available port (gen_tcp — OTP 29.0.2 (kernel 11.0.2)).

If Port == 0, the underlying OS assigns an available port number, useinet:port/1 to retrieve it.

You can then fetch the port by using something like :ranch.get_port(YourAppWeb.Endpoint.HTTP). If you are not sure what module name plug decided to use for you cowboy server, try runing :ets.i(:ranch_server) in iex.

Ah that is interesting, didn’t know about that option. But for this case I’d prefer to know what ports the server would possibly be running on.

You can probably also use :gen_tcp.listen/2 to check if the port is taken, and only after that start the phoenix app. It would probably simplify the logic a bit (no need for dynamic supervisors, just a function that runs before the application starts).

def find_port(port) do
  case :gen_tcp.listen(port, []) do
    {:ok, socket} ->
      :gen_tcp.close(socket)
      port
    {:error, :eaddrinuse} ->
      find_port(port + 1)
  end
end

Hmm, that does seem like it would clean up a bunch. Especially my crazy error checking pattern match. I’ll ty it out