Allow using remote or rpc with compile_env

Signed-off-by: José Valim <[email protected]>

Author: esse

lib/elixir/lib/config/provider.ex

@@ -110,7 +110,8 @@ defmodule Config.Provider do
     :config_path,
     extra_config: [],
     prune_after_boot: false,
-    reboot_after_config: true
+    reboot_after_config: true,
+    validate_compile_env: false
   ]
 
   @doc """
@@ -165,54 +166,74 @@ defmodule Config.Provider do
     # before we go around running Elixir code.
     {:ok, _} = :application.ensure_all_started(:elixir)
 
-    case :application.get_env(app, key) do
-      {:ok, %Config.Provider{} = provider} ->
-        path = resolve_config_path!(provider.config_path)
-        validate_no_cyclic_boot!(path)
-        loaded_applications = :application.loaded_applications()
-        original_config = read_config!(path)
+    # The key we store if the system already booted
+    booted_key = :"#{key}_booted"
 
-        config =
-          original_config
-          |> Config.__merge__(provider.extra_config)
-          |> run_providers(provider)
+    case :application.get_env(app, booted_key) do
+      {:ok, {:booted, path}} ->
+        path && File.rm(path)
 
-        if provider.reboot_after_config do
-          config
-          |> Config.__merge__([{app, [{key, booted_key(provider, path)}]}])
-          |> write_config!(path)
+        with {:ok, %Config.Provider{} = provider} <- :application.get_env(app, key) do
+          maybe_validate_compile_env(provider)
+        end
 
-          restart_fun.()
-        else
-          for {app, _, _} <- loaded_applications, config[app] != original_config[app] do
-            abort("""
-            Cannot configure #{inspect(app)} because :reboot_after_config has been set \
-            to false and #{inspect(app)} has already been loaded, meaning any further \
-            configuration won't have an effect.
+        :booted
 
-            The configuration for #{inspect(app)} before config providers was:
+      _ ->
+        case :application.get_env(app, key) do
+          {:ok, %Config.Provider{} = provider} ->
+            path = resolve_config_path!(provider.config_path)
+            reboot_config = [{app, [{booted_key, booted_value(provider, path)}]}]
+            boot_providers(path, provider, reboot_config, restart_fun)
+
+          _ ->
+            :skip
+        end
+    end
+  end
 
-            #{inspect(original_config[app])}
+  defp boot_providers(path, provider, reboot_config, restart_fun) do
+    validate_no_cyclic_boot!(path)
+    loaded_applications = :application.loaded_applications()
+    original_config = read_config!(path)
 
-            The configuration for #{inspect(app)} after config providers was:
+    config =
+      original_config
+      |> Config.__merge__(provider.extra_config)
+      |> run_providers(provider)
 
-            #{inspect(config[app])}
-            """)
-          end
+    if provider.reboot_after_config do
+      config
+      |> Config.__merge__(reboot_config)
+      |> write_config!(path)
 
-          _ = Application.put_all_env(config, persistent: true)
-          :ok
-        end
+      restart_fun.()
+    else
+      for {app, _, _} <- loaded_applications, config[app] != original_config[app] do
+        abort("""
+        Cannot configure #{inspect(app)} because :reboot_after_config has been set \
+        to false and #{inspect(app)} has already been loaded, meaning any further \
+        configuration won't have an effect.
 
-      {:ok, {:booted, path}} ->
-        File.rm(path)
-        :booted
+        The configuration for #{inspect(app)} before config providers was:
 
-      {:ok, :booted} ->
-        :booted
+        #{inspect(original_config[app])}
 
-      _ ->
-        :skip
+        The configuration for #{inspect(app)} after config providers was:
+
+        #{inspect(config[app])}
+        """)
+      end
+
+      _ = Application.put_all_env(config, persistent: true)
+      maybe_validate_compile_env(provider)
+      :ok
+    end
+  end
+
+  defp maybe_validate_compile_env(provider) do
+    with [_ | _] = compile_env <- provider.validate_compile_env do
+      validate_compile_env(compile_env)
     end
   end
 
@@ -283,8 +304,8 @@ defmodule Config.Provider do
     Process.sleep(:infinity)
   end
 
-  defp booted_key(%{prune_after_boot: true}, path), do: {:booted, path}
-  defp booted_key(%{prune_after_boot: false}, _path), do: :booted
+  defp booted_value(%{prune_after_boot: true}, path), do: {:booted, path}
+  defp booted_value(%{prune_after_boot: false}, _path), do: {:booted, nil}
 
   defp validate_no_cyclic_boot!(path) do
     if System.get_env("ELIXIR_CONFIG_PROVIDER_BOOTED") do

lib/elixir/test/elixir/config/provider_test.exs

@@ -20,6 +20,7 @@ defmodule Config.ProviderTest do
 
     on_exit(fn ->
       Application.delete_env(@config_app, :config_providers)
+      Application.delete_env(@config_app, :config_providers_booted)
       System.delete_env(@env_var)
     end)
   end
@@ -79,7 +80,7 @@ defmodule Config.ProviderTest do
       init_and_assert_boot()
       config = consult(@sys_config)
       assert config[:my_app] == [key: :value]
-      assert config[@config_app] == [config_providers: :booted]
+      assert config[@config_app] == [config_providers_booted: {:booted, nil}]
     end
 
     @tag sys_config: [my_app: [encoding: {:"£", "£", '£'}]]
@@ -113,6 +114,18 @@ defmodule Config.ProviderTest do
       refute File.exists?(@sys_config)
     end
 
+    test "returns :booted if already booted and runs validate_compile_env" do
+      init_and_assert_boot(
+        prune_after_boot: true,
+        validate_compile_env: [{:elixir, [:unknown], {:ok, :value}}]
+      )
+
+      Application.put_all_env(Keyword.take(consult(@sys_config), [@config_app]))
+
+      assert capture_abort(fn -> boot() end) =~
+               "the application :elixir has a different value set for key :unknown"
+    end
+
     test "raises if booting twice in a row" do
       init_and_assert_boot()
 

lib/mix/lib/mix/release.ex

@@ -425,13 +425,29 @@ defmodule Mix.Release do
     opts = [
       extra_config: initial_config,
       prune_after_boot: prune_after_boot,
-      reboot_after_config: reboot?
+      reboot_after_config: reboot?,
+      validate_compile_env: validate_compile_env(release)
     ]
 
     init = Config.Provider.init(release.config_providers, config_path, opts)
     {Config.Reader.merge(sys_config, [elixir: [config_providers: init]] ++ extra_config), reboot?}
   end
 
+  defp validate_compile_env(release) do
+    with true <- Keyword.get(release.options, :validate_compile_env, true),
+         [_ | _] = compile_env <- compile_env(release) do
+      compile_env
+    else
+      _ -> false
+    end
+  end
+
+  defp compile_env(release) do
+    for {_, properties} <- release.applications,
+        triplet <- Keyword.get(properties, :compile_env, []),
+        do: triplet
+  end
+
   defp start_distribution(%{options: opts}) do
     reboot? = Keyword.get(opts, :reboot_system_after_config, true)
     early_distribution? = Keyword.get(opts, :start_distribution_during_config, false)
@@ -613,8 +629,7 @@ defmodule Mix.Release do
         &(not match?({:apply, {:application, :start_boot, [:stdlib, _]}}, &1))
       )
 
-    pre ++
-      [stdlib] ++ config_provider_apply(release) ++ validate_compile_env_apply(release) ++ post
+    pre ++ [stdlib] ++ config_provider_apply(release) ++ post
   end
 
   defp config_provider_apply(%{config_providers: []}),
@@ -623,21 +638,6 @@ defmodule Mix.Release do
   defp config_provider_apply(_),
     do: [{:apply, {Config.Provider, :boot, [:elixir, :config_providers]}}]
 
-  defp validate_compile_env_apply(release) do
-    with true <- Keyword.get(release.options, :validate_compile_env, true),
-         [_ | _] = compile_env <- compile_env(release) do
-      [{:apply, {Config.Provider, :validate_compile_env, [compile_env]}}]
-    else
-      _ -> []
-    end
-  end
-
-  defp compile_env(release) do
-    for {_, properties} <- release.applications,
-        triplet <- Keyword.get(properties, :compile_env, []),
-        do: triplet
-  end
-
   defp prepend_paths_to_script(instructions, []), do: instructions
 
   defp prepend_paths_to_script(instructions, prepend_paths) do

lib/mix/test/mix/tasks/release_test.exs

@@ -514,7 +514,18 @@ defmodule Mix.Tasks.ReleaseTest do
     in_fixture("release_test", fn ->
       config = [releases: [permanent1: [include_erts: false]]]
 
+      # We write the compile env to guarantee rpc still works
+      File.write!("lib/compile_env.ex", """
+      _ = Application.compile_env(:release_test, :static)
+      """)
+
       Mix.Project.in_project(:release_test, ".", config, fn _ ->
+        Mix.Task.run("loadconfig", [])
+
+        File.write!("config/releases.exs", """
+        import Config
+        """)
+
         root = Path.absname("_build/dev/rel/permanent1")
         Mix.Task.run("release")
         script = Path.join(root, "bin/permanent1")