Unfortunately, the on_load callback won’t work in this case because the module itself is not loaded when the callback is run, so I can’t query using the module. I suppose I need to use something like after_load, but I don’t think it exists. Will take a look at some of the other suggestions in this thread.
Thanks for the pointer tho, I see it being useful in some other cases 
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.
Thanks for the suggestions everyone! I looked at all of them and this reply as well: Change my mind: Migrations in a start phase - #2 by benwilson512.
I finally decided to use a Genserver like @axelson suggested, but ran it directly in my application supervision tree. Since I need to populate :persistent_term with DB rows, I need the Repo running. I could always start the repo process in another application that my main application depends on, but just running a temporary Genserver after the Repo process starts in the main application was simpler. Also, the Genserver’s blocking init fn returns :ignore once it populates :persistent_term, so it exits normally without entering the msg receive loop. Works well for my use case