defmodule Runbox.Slave do
@moduledoc """
Utilities for starting a slave node with a scenario release and communicating
with the node.
"""
alias Runbox.Utils.Path, as: PathUtils
@doc """
Starts a slave node.
The `release_dir` is a directory with scenario release.
If `app_env` is set, given app environment variables are set on slave.
"""
@spec start(String.t(), [{Application.app(), [{Application.key(), Application.value()}]}]) ::
{:ok, node()} | {:error, term()}
def start(release_dir, app_env \\ []) do
host = slave_host() |> to_charlist()
slave_name = UUID.uuid4() |> to_charlist()
args =
[
"-setcookie #{Node.get_cookie()}",
~s(-boot "#{boot_file(release_dir)}"),
~s(-boot_var RELEASE_LIB "#{release_lib(release_dir)}"),
~s(-config "#{config_file(release_dir)}"),
"-mode interactive",
"-runbox mode slave",
"-hidden",
erl_opt_runbox_scenario_config_dir(),
erl_opt_logger_console(),
erl_opt_runbox_altworx_root()
]
|> Enum.join(" ")
|> to_charlist()
link_to = self()
# The progname has to be stated explicitly, otherwise it can be wrongly set
# to the name of the release script.
progname = ~c"erl"
case :slave.start(host, slave_name, args, link_to, progname) do
{:ok, slave} ->
with :ok <- check_runbox_started(slave),
:ok <- check_runbox_scenario_app_configured(slave),
:ok <- put_app_env(slave, app_env) do
{:ok, slave}
else
{:error, _} = error ->
:ok = :slave.stop(slave)
error
end
{:error, _} = error ->
error
end
end
@doc """
Spawns a slave and executes the `fun`.
`fun` recives the slave node as a parameter. The slave is terminated after
the `fun` finishes.
"""
@spec with_slave(String.t(), (node() -> result)) :: {:ok, result} | {:error, term}
when result: any()
def with_slave(release_dir, fun) do
with {:ok, slave} <- start(release_dir) do
try do
{:ok, fun.(slave)}
after
:ok = :slave.stop(slave)
end
end
end
@doc """
Calls a function on the slave.
Calls MFA on the `slave`. See `:erpc.call/4` for details.
"""
@spec call(node(), module(), atom(), list()) :: term()
def call(slave, m, f, a) do
:erpc.call(slave, m, f, a)
end
defp check_runbox_started(slave) do
apps = call(slave, Application, :started_applications, [])
if Enum.any?(apps, &match?({:runbox, _, _}, &1)) do
:ok
else
{:error, :runbox_not_running_on_slave}
end
end
defp check_runbox_scenario_app_configured(slave) do
case call(slave, Application, :fetch_env, [:runbox, :scenario_app]) do
{:ok, _} -> :ok
:error -> {:error, {:runbox_misconfigured, "Missing app config key :scenario_app"}}
end
end
defp put_app_env(slave, app_env) do
if app_env == [], do: :ok, else: call(slave, Application, :put_all_env, [app_env])
end
defp release_lib(release_dir) do
Path.join([release_dir, "lib"])
end
defp boot_file(release_dir) do
Path.join([release_dir, "releases", release_version(release_dir), "start"])
end
defp config_file(release_dir) do
Path.join([release_dir, "releases", release_version(release_dir), "sys"])
end
defp release_version(release_dir) do
data_file = Path.join([release_dir, "releases", "start_erl.data"])
[_, release_version] =
data_file
|> File.read!()
|> String.split(" ")
release_version
end
defp slave_host, do: this_host()
# The name of the host has to be derived from the node name. If taken from
# `:inet.gethostname`, it does not work inside docker.
defp this_host do
[_name, host] =
node()
|> Atom.to_string()
|> String.split("@")
host
end
defp erl_opt_runbox_scenario_config_dir do
scenario_config_dir = Application.fetch_env!(:runbox, :scenario_config_dir)
~s(-runbox scenario_config_dir "#{erl_format_term(scenario_config_dir)}")
end
defp erl_opt_logger_console do
case Application.fetch_env(:logger, :console) do
{:ok, conf} -> ~s(-logger console "#{erl_format_term(conf)}")
:error -> ""
end
end
defp erl_opt_runbox_altworx_root do
env_var = PathUtils.altworx_root_env_var()
altworx_root = PathUtils.get_altworx_root()
~s(-runbox #{erl_format_term(env_var)} "#{erl_format_term(altworx_root)}")
end
defp erl_format_term(term) do
IO.chardata_to_string(:io_lib.format("~tw", [term]))
end
end