If you’re using an umbrella I found it useful to create an application that is responsible for bootstrapping the actual app. This allows you to setup things before starting your actual “core”.
As an example, on the umbrella mix.exs I have the following release:
defmodule YourApp.MixProject do
use Mix.Project
def project do
[
apps_path: "apps",
version: "1.0.0",
start_permanent: Mix.env() == :prod,
deps: deps(),
releases: [
your_release_name: [
applications: [
bootstrap: :permanent, #this is so that when releasing it starts this app which in turn will run its logic
server: :load #this is the actual core application, we set it to only load its modules but not start the supervision tree
],
include_executables_for: [:unix]
]
]
]
end
#other things.... like deps etc
end
Then the bootstrap
app is a simple app with a supervision tree, it has a bootstrap.ex
which is a gen_server to be started from the supervision tree, eg:
defmodule Bootstrap do
@moduledoc """
This starts mnesia and etc and once ok starts the web interface
"""
use GenServer, shutdown: 50_000
require Logger
@mnesia_tables_attrs %{
categories: [:slug, :title, :description, :image, :id, :struct]
}
@mnesia_tables Enum.reduce(@mnesia_tables_attrs, [], fn({table, _}, acc) ->
[table | acc]
end) |> :lists.reverse
def start_link(_) do
GenServer.start_link(__MODULE__, nil, name: __MODULE__)
end
def init(_) do
System.cmd("epmd", ["-daemon"])
#random_uuid = (:crypto.strong_rand_bytes(4) |> Base.encode16())
#name = :"#{random_uuid}@#{:net_adm.localhost()}"
#:net_kernel.start([name])
case :mnesia.start() do
:ok ->
Enum.each(@mnesia_tables_attrs, fn({table, attributes}) ->
:mnesia.create_table(table, [attributes: attributes])
end)
case :mnesia.wait_for_tables(@mnesia_tables, 5_000) do
:ok ->
Logger.warn("Mnesia tables loaded")
{:ok, :started, {:continue, :ensure_all_started}}
{:timeout, tables} ->
Logger.error("Mnesia Unable to load tables: #{inspect tables} - shutting down...")
:init.stop()
end
error -> :init.stop()
end
end
def handle_continue(:ensure_all_started, state) do
Logger.info("Starting server")
{:ok, _started_apps} = :application.ensure_all_started(:server, :permanent)
{:noreply, :started}
end
def copy_hex_cache(_, _, _) do
File.cp_r!(Path.expand("~/.hex"), File.cwd!() <> "/hex")
:ok
end
def delete_hex_cache(_, _, _) do
File.rm_rf!(File.cwd!() <> "/hex")
:ok
end
end
Then it’s application file includes:
defmodule Bootstrap.Application do
@moduledoc false
use Application
def start(_type, _args) do
children = [
{Bootstrap, []}
]
opts = [strategy: :one_for_one, name: Bootstrap.Supervisor]
Supervisor.start_link(children, opts)
end
end
And it has a task in all similar to the phx.server task:
defmodule Mix.Tasks.Bootstrap do
use Mix.Task
def run(_) do
Application.put_env(:phoenix, :serve_endpoints, true, persistent: true)
{:ok, _} = Application.ensure_all_started(:bootstrap)
Mix.Tasks.Run.run run_args() ++ ["--no-start"]
end
defp run_args do
if iex_running?(), do: [], else: ["--no-halt"]
end
defp iex_running? do
Code.ensure_loaded?(IEx) and IEx.started?
end
end
This task is to be run when in dev, so that you can do iex -S mix bootstrap
In my case I do Ecto migrations when I need manually, but there’s nothing preventing you from adding a step to run migrations as well as part of the bootstrap
gen_server. Any other things you need to do before starting your actual core, can be done here too if needed. When running the release it will start the bootstrap app (you don’t run the task) and that start your actual app.
I have found this a good way of structuring the startup of an application.