defmodule Nerves.Env do
@moduledoc """
Contains package info for Nerves dependencies
The Nerves Env is used to load information from dependencies that
contain a nerves.exs config file in the root of the dependency
path. Nerves loads this config because it needs access to information
about Nerves compile time dependencies before any code is compiled.
"""
alias Nerves.{Artifact, Package}
@doc """
Starts the Nerves environment agent and loads package information.
If the Nerves.Env is already started, the function returns
`{:error, {:already_started, pid}}` with the pid of that process
"""
@spec start() :: Agent.on_start()
def start() do
set_source_date_epoch()
Agent.start_link(fn -> load_packages() end, name: __MODULE__)
end
@doc """
Stop the Nerves environment agent.
"""
@spec stop() :: :ok | :not_running
def stop() do
if Process.whereis(__MODULE__) do
Agent.stop(__MODULE__)
else
:not_running
end
end
@doc """
Check if the env compilers are disabled
"""
@spec enabled?() :: boolean
def enabled?() do
System.get_env("NERVES_ENV_DISABLED") == nil
end
@doc """
Enable the Nerves Env compilers
"""
@spec enable() :: :ok
def enable() do
System.delete_env("NERVES_ENV_DISABLED")
end
@doc """
Disable the Nerves Env compilers
"""
@spec disable() :: :ok
def disable() do
System.put_env("NERVES_ENV_DISABLED", "1")
end
@doc """
Check if the Nerves.Env is loaded
"""
@spec loaded?() :: boolean
def loaded?() do
System.get_env("NERVES_ENV_BOOTSTRAP") != nil
end
@doc """
The download location for artifact downloads.
Placing an artifact tar in this location will bypass the need for it to
be downloaded.
"""
@spec download_dir() :: path :: String.t()
def download_dir() do
(System.get_env("NERVES_DL_DIR") || Path.join(data_dir(), "dl"))
|> Path.expand()
end
@doc """
The location for storing global nerves data.
The base directory is normally set by the `XDG_DATA_HOME`
environment variable (i.e. `$XDG_DATA_HOME/nerves/`).
If `XDG_DATA_HOME` is unset, the user's home directory
is used (i.e. `$HOME/.nerves`).
"""
@spec data_dir() :: path :: String.t()
def data_dir() do
case System.get_env("XDG_DATA_HOME") do
directory when is_binary(directory) -> Path.join(directory, "nerves")
nil -> Path.expand("~/.nerves")
end
end
@doc """
Re evaluates the mix file under a different target.
This allows you to start in one target, like host, but then
switch to a different target.
"""
@spec change_target(String.t()) :: :ok
def change_target(target) do
System.put_env("MIX_TARGET", target)
:init.restart()
:timer.sleep(:infinity)
end
@doc """
Cleans the artifacts for the package build_runners of all specified packages.
"""
@spec clean([Nerves.Package.t()]) :: :ok
def clean(pkgs) do
Enum.each(pkgs, &Artifact.clean/1)
end
@doc """
Ensures that an application which contains a Nerves package config has
been loaded into the environment agent.
## Options
* `app` - The atom of the app to load
* `path` - Optional path for the app
"""
@spec ensure_loaded(app :: atom, path :: String.t() | nil) ::
{:ok, Nerves.Package.t()} | {:error, term}
def ensure_loaded(app, path \\ nil) do
path = path || File.cwd!()
if nerves_package?({app, path}) do
packages = Agent.get(__MODULE__, & &1)
case Enum.find(packages, &(&1.app == app)) do
nil ->
%Package{} = package = Package.load_config({app, path})
Agent.update(__MODULE__, fn packages ->
[package | packages]
end)
{:ok, package}
package ->
{:ok, package}
end
else
{:error, "Nerves package config for #{inspect(app)} was not found at #{path}"}
end
end
@doc """
Returns the architecture for the host system.
## Example return values
"x86_64"
"arm"
"""
@spec host_arch() :: String.t()
def host_arch() do
case System.get_env("HOST_ARCH") do
nil ->
:erlang.system_info(:system_architecture)
|> to_string
|> parse_arch
host_arch ->
host_arch
end
end
@doc false
@spec parse_arch(String.t() | [String.t()]) :: String.t()
def parse_arch(arch) when is_binary(arch) do
arch
|> String.split("-")
|> parse_arch
end
@doc false
def parse_arch(arch) when is_list(arch) do
arch = List.first(arch)
case arch do
<<"win", _rest::binary>> -> "x86_64"
<<"arm", _rest::binary>> -> "arm"
"aarch64" -> "aarch64"
"x86_64" -> "x86_64"
_anything_else -> "x86_64"
end
end
@doc """
Returns the os for the host system.
## Example return values
"win"
"linux"
"darwin"
"""
@spec host_os() :: String.t()
def host_os() do
case System.get_env("HOST_OS") do
nil ->
:erlang.system_info(:system_architecture)
|> to_string
|> parse_platform
host_os ->
host_os
end
end
@doc false
@spec parse_platform(String.t() | [String.t()]) :: String.t()
def parse_platform(platform) when is_binary(platform) do
platform
|> String.split("-")
|> parse_platform
end
@doc false
def parse_platform(platform) when is_list(platform) do
case platform do
[<<"win", _tail::binary>> | _] ->
"win"
[_, _, "linux" | _] ->
"linux"
[_, _, <<"darwin", _tail::binary>> | _] ->
"darwin"
_ ->
Mix.raise("Could not determine your host platform from system: #{platform}")
end
end
@doc """
Lists all Nerves packages loaded in the Nerves environment.
"""
@spec packages() :: [Nerves.Package.t()]
def packages() do
Agent.get(__MODULE__, & &1) || Mix.raise("Nerves packages are not loaded")
end
@doc """
Gets a package by app name.
"""
@spec package(name :: atom) :: Nerves.Package.t() | nil
def package(name) do
packages()
|> Enum.filter(&(&1.app == name))
|> List.first()
end
@doc """
Lists packages by package type.
"""
@spec packages_by_type(type :: atom(), [Nerves.Package.t()] | nil) :: [Nerves.Package.t()]
def packages_by_type(type, packages \\ nil) do
(packages || packages())
|> Enum.filter(&(&1.type === type))
end
@doc """
The path to where firmware build files are stored
This can be overridden in a Mix project by setting the `:images_path` key.
images_path: "/some/other/location"
Defaults to (build_path)/nerves/images
"""
@spec images_path(keyword) :: String.t()
def images_path(config \\ mix_config()) do
(config[:images_path] || Path.join([Mix.Project.build_path(), "nerves", "images"]))
|> Path.expand()
end
@doc """
The path to the firmware file
"""
@spec firmware_path(keyword) :: String.t()
def firmware_path(config \\ mix_config()) do
config
|> images_path()
|> Path.join("#{config[:app]}.fw")
end
@doc """
Helper function for returning the system type package
"""
@spec system() :: Nerves.Package.t() | nil
def system() do
system =
packages_by_type(:system)
|> List.first()
system
end
@doc """
Helper function for returning the system_platform type package
"""
@spec system_platform() :: module()
def system_platform() do
system().platform
end
@doc """
Helper function for returning the toolchain type package
"""
@spec toolchain() :: Nerves.Package.t() | nil
def toolchain() do
toolchain =
packages_by_type(:toolchain)
|> List.first()
toolchain
end
@doc """
Helper function for returning the toolchain_platform type package
"""
@spec toolchain_platform() :: atom()
def toolchain_platform() do
toolchain().platform
end
@doc """
Export environment variables used by Elixir, Erlang, C/C++ and other tools
so that they use Nerves toolchain parameters and not the host's.
For a comprehensive list of environment variables, see the documentation
for the package defining system_platform.
"""
@spec bootstrap() :: :ok
def bootstrap() do
nerves_system_path = system_path()
nerves_toolchain_path = toolchain_path()
packages = Nerves.Env.packages()
[
{"NERVES_SYSTEM", nerves_system_path},
{"NERVES_TOOLCHAIN", nerves_toolchain_path},
{"NERVES_APP", File.cwd!()}
]
|> Enum.each(fn {k, v} ->
cond do
v == nil ->
Mix.shell().info("#{k} is unset")
File.dir?(v) != true ->
with "NERVES_SYSTEM" <- k,
%{app: app, dep: :path} <- system() do
Mix.shell().info([
:yellow,
"""
Local Nerves system detected but is not compiled:
#{app}
""",
:reset
])
# Since this is a local system, let this be set
# so that the compilation check later on can handle if
# it should be compiled or not
System.put_env(k, v)
else
_err ->
Mix.shell().error("""
#{k} is set to a path which does not exist:
#{v}
Try running `mix deps.get` to see if this resolves the issue by
downloading the missing artifact.
""")
exit({:shutdown, 1})
end
true ->
System.put_env(k, v)
end
end)
if nerves_system_path != nil and File.dir?(nerves_system_path) do
# Bootstrap the build platform
platform = Nerves.Env.system().platform
pkg =
Nerves.Env.packages_by_type(:system_platform)
|> List.first()
platform.bootstrap(pkg)
end
# Export nerves package env variables
Enum.each(packages, &export_package_env/1)
# Bootstrap all other packages who define a platform
toolchain_package = Nerves.Env.toolchain()
system_package = Nerves.Env.system()
packages
|> Enum.reject(&(&1 == toolchain_package or &1 == system_package or &1.platform == nil))
|> Enum.each(fn
%{platform: platform} = pkg ->
platform.bootstrap(pkg)
_ ->
:noop
end)
System.put_env("NERVES_ENV_BOOTSTRAP", "1")
end
@doc false
@spec toolchain_path() :: String.t() | nil
def toolchain_path() do
case Nerves.Env.toolchain() do
nil ->
nil
toolchain ->
Nerves.Artifact.dir(toolchain)
end
end
@doc false
@spec system_path() :: String.t() | nil
def system_path() do
case Nerves.Env.system() do
nil ->
nil
system ->
Nerves.Artifact.dir(system)
end
end
@doc false
@spec source_date_epoch() :: {:ok, String.t() | nil} | {:error, String.t()}
def source_date_epoch() do
(System.get_env("SOURCE_DATE_EPOCH") || Application.get_env(:nerves, :source_date_epoch))
|> validate_source_date_epoch()
end
@spec export_package_env(Package.t()) :: :ok
def export_package_env(%Package{env: env}) do
env
|> process_target_gcc_flags()
|> System.put_env()
end
defp process_target_gcc_flags(%{"TARGET_GCC_FLAGS" => flags} = env) do
env
|> Map.put("CFLAGS", flags <> " " <> System.get_env("CFLAGS", ""))
|> Map.put("CXXFLAGS", flags <> " " <> System.get_env("CXXFLAGS", ""))
end
defp process_target_gcc_flags(env), do: env
defp set_source_date_epoch() do
case source_date_epoch() do
{:ok, nil} -> :ok
{:ok, sde} -> System.put_env("SOURCE_DATE_EPOCH", sde)
{:error, error} -> Mix.raise(error)
end
end
defp validate_source_date_epoch(nil), do: {:ok, nil}
defp validate_source_date_epoch(sde) when is_integer(sde), do: {:ok, Integer.to_string(sde)}
defp validate_source_date_epoch(""), do: {:error, "SOURCE_DATE_EPOCH cannot be empty"}
defp validate_source_date_epoch(sde) when is_binary(sde) do
case Integer.parse(sde) do
{_sde, _rem} ->
{:ok, sde}
:error ->
{:error, "SOURCE_DATE_EPOCH should be a positive integer, received: #{inspect(sde)}"}
end
end
@doc false
defp load_packages() do
Mix.Project.deps_paths()
|> Map.put(Mix.Project.config()[:app], File.cwd!())
|> Enum.filter(&nerves_package?/1)
|> Enum.map(&Package.load_config/1)
|> validate_packages
end
@doc false
defp validate_packages(packages) do
Enum.each([:system, :toolchain], fn type ->
packages_by_type(type, packages)
|> validate_one(type)
end)
packages
end
@doc false
defp validate_one(packages, type) when length(packages) > 1 do
packages = Enum.map(packages, &Map.get(&1, :app))
Mix.raise("""
Your mix project cannot contain more than one #{type} for the target.
Your dependencies for the target contain the following #{type}s:
#{Enum.join(packages, ~s/ /)}
""")
end
@doc false
defp validate_one(packages, _type), do: packages
@doc false
defp nerves_package?({app, path}) do
package_config =
Package.config(app, path)
|> Keyword.get(:nerves_package)
package_config != nil
rescue
_e ->
File.exists?(Package.config_path(path))
end
defp mix_config() do
Mix.Project.config()
end
end