Hey there!
This probably has a very easy answer, but I’m already too many hours into this and need some help. In this scenario, we have several separated git repositories, one being a library to provide configuration values and the others are applications that use the mentioned lib.
The library used to be a plain stateless module and this has been working well for years. Recently, we had to change this library to include some caching and different data sources, which caused a GenServer to be added. It means that it ceased to be a simple bunch of functions and now requires to be fully loaded and started to be used.
One peculiarity, being a config provider, this library is usually invoked from start/2 callbacks of the other Applications, hence it has to be up and running before the other applications have their start/2 functions called.
The (greatly simplified) structure is as follows:
Library: mix.exs
defmodule Foo.Config.MixProject do
use Mix.Project
def project do
[
app: :foo_config,
version: "2.0.0",
elixir: "~> 1.10",
deps: [{:jason, "~> 1.2"}],
]
end
def application do
[
extra_applications: [:logger],
mods: {Foo.Config.Application, []},
]
end
end
Library: lib/application.ex
defmodule Foo.Config.Application do
@moduledoc false
use Application
@impl true
def start(_type, _args) do
children = [Foo.Config.Server]
opts = [strategy: :one_for_one, name: Foo.Config.Supervisor]
Supervisor.start_link children, opts
end
end
Library: lib/config.ex
defmodule Foo.Config do
alias Foo.Config.Server
def get_config(key_path) when is_binary(key_path) do
GenServer.call Server.name, {:get_config, key_path}
end
end
Library: lib/server.ex
defmodule Foo.Config.Server do
use GenServer
require Logger
@server_name {:global, __MODULE__}
def name, do: @server_name
def start_link(_opts) do
GenServer.start_link __MODULE__, [], name: @server_name
end
def child_spec(_args) do
%{
id: Foo.Config.Server,
start: {Foo.Config.Server, :start_link, [nil]},
}
end
@impl GenServer
def init(_opts) do
# Some operations to load initial state, potentially expensive
{:ok, %{config: initial_state}}
end
@impl GenServer
def handle_call({:get_config, key_path}, _from, %{config: data} = state)
when is_binary(key_path) and is_map(data)
do
# Uses private functions to calculate the value to be returned
{:reply, value, state}
end
end
Application: mix.exs
defmodule Bar.MixProject do
use Mix.Project
def project do
[
app: :bar,
version: "2.1.0",
elixir: "~> 1.10",
start_permanent: Mix.env() == :prod,
deps: deps(),
test_paths: test_paths(Mix.env),
releases: [
bar: [
include_executables_for: [:unix]
]
]
]
end
def application do
[
extra_applications: [
:logger,
# We tried to add the library here, but didn't help
:foo_config,
],
mod: mods(Mix.env),
]
end
defp mods(:unit), do: []
defp mods(_all), do: {Bar.Application, []}
defp test_paths(:integration), do: ["test/integration"]
defp test_paths(:unit), do: ["test/unit"]
defp test_paths(_), do: []
defp deps do
[
{:argon2_elixir, "~> 2.3"},
{:joken, "~> 2.2"},
{:mongodb_driver, "~> 0.7"},
{:plug_cowboy, "~> 2.2"},
{
:foo_config,
git: "git@github.com:my-company/foo-config.git",
tag: "v2.0.0",
},
]
end
end
Application: lib/bar/application.ex
defmodule Bar.Application do
use Application
# We tried to use `require` here, but no effect
require Foo.Config
import Foo.Config, only: [
get_config: 1,
get_secret: 1,
]
require Logger
def start(_type, _args) do
# We also tried the lines here, but no luck:
# {:ok, _} = Application.ensure_all_started :foo_config
# Process.sleep 5000
{:ok, port} = get_config "port"
{:ok, db_url} = get_config "uri"
{:ok, db_user} = get_config "username"
{:ok, db_pass} = get_config "password"
children = [
{Plug.Cowboy, [
scheme: :http,
plug: Bar.Router,
options: [ip: {0, 0, 0, 0}, port: port],
]},
{Mongo, [
name: :db,
appname: "Bar",
url: db_url,
username: db_user,
password: db_pass,
# More config here, obtained through `get_config/1`
]},
]
opts = [name: Bar.Supervisor, strategy: :one_for_one]
Logger.info "Starting Bar.Supervisor"
Supervisor.start_link children, opts
end
end
Application: many other files, such as router.ex
defmodule Foo.Router do
use Plug.Router
# Lots of magic here
end
Compilation runs just fine, but trying to run the application always results in the following error (extracted from docker-compose logs). The CMD for this container during development is mix do deps.get, run --no-halt and bar start for the release in production:
app_1 | ** (Mix) Could not start application bar: exited in: Bar.Application.start(:normal, [])
app_1 | ** (EXIT) exited in: GenServer.call({:global, Foo.Config.Server}, {:get_config, "port"}, 5000)
app_1 | ** (EXIT) no process: the process is not alive or there's no process currently associated with the given name, possibly because its application isn't started
What am I missing here? Suggestions about project structure are also welcome, I just really need to keep the config provider as an independent library because many different applications (deployed as independent Erlang nodes and containers) are using the same logic.
Thanks in advance! Live long and prosper \\//_
