Current section

Files

Jump to
phoenix lib phoenix code_reloader server.ex
Raw

lib/phoenix/code_reloader/server.ex

defmodule Phoenix.CodeReloader.Server do
@moduledoc false
use GenServer
require Logger
alias Phoenix.CodeReloader.Proxy
def start_link() do
GenServer.start_link(__MODULE__, false, name: __MODULE__)
end
def check_symlinks do
GenServer.call(__MODULE__, :check_symlinks, :infinity)
end
def reload!(endpoint) do
GenServer.call(__MODULE__, {:reload!, endpoint}, :infinity)
end
## Callbacks
def init(false) do
{:ok, false}
end
def handle_call(:check_symlinks, _from, checked?) do
if not checked? and Code.ensure_loaded?(Mix.Project) and not Mix.Project.umbrella? do
priv_path = "#{Mix.Project.app_path}/priv"
case :file.read_link(priv_path) do
{:ok, _} ->
:ok
{:error, _} ->
if can_symlink?() do
File.rm_rf(priv_path)
Mix.Project.build_structure
else
Logger.warn "Phoenix is unable to create symlinks. Phoenix' code reloader will run " <>
"considerably faster if symlinks are allowed." <> os_symlink(:os.type)
end
end
end
{:reply, :ok, true}
end
def handle_call({:reload!, endpoint}, from, state) do
compilers = endpoint.config(:reloadable_compilers)
reloadable_apps = endpoint.config(:reloadable_apps) || default_reloadable_apps()
backup = load_backup(endpoint)
froms = all_waiting([from], endpoint)
{res, out} =
proxy_io(fn ->
try do
mix_compile(Code.ensure_loaded(Mix.Task), compilers, reloadable_apps)
catch
:exit, {:shutdown, 1} ->
:error
kind, reason ->
IO.puts Exception.format(kind, reason, System.stacktrace)
:error
end
end)
reply =
case res do
:ok ->
:ok
:error ->
write_backup(backup)
{:error, out}
end
Enum.each(froms, &GenServer.reply(&1, reply))
{:noreply, state}
end
defp default_reloadable_apps() do
if Mix.Project.umbrella? do
Enum.map(Mix.Dep.Umbrella.cached, &(&1.app))
else
[Mix.Project.config()[:app]]
end
end
def handle_info(_, state) do
{:noreply, state}
end
defp os_symlink({:win32, _}),
do: " On Windows, the lack of symlinks may even cause empty assets to be served. " <>
"Luckily, you can address this issue by starting your Windows terminal at least " <>
"once with \"Run as Administrator\" and then running your Phoenix application."
defp os_symlink(_),
do: ""
defp can_symlink?() do
build_path = Mix.Project.build_path()
symlink = Path.join(Path.dirname(build_path), "__phoenix__")
case File.ln_s(build_path, symlink) do
:ok ->
File.rm_rf(symlink)
true
{:error, :eexist} ->
File.rm_rf(symlink)
true
{:error, _} ->
false
end
end
defp load_backup(mod) do
mod
|> :code.which()
|> read_backup()
end
defp read_backup(path) when is_list(path) do
case File.read(path) do
{:ok, binary} -> {:ok, path, binary}
_ -> :error
end
end
defp read_backup(_path), do: :error
defp write_backup({:ok, path, file}), do: File.write!(path, file)
defp write_backup(:error), do: :ok
defp all_waiting(acc, endpoint) do
receive do
{:"$gen_call", from, {:reload!, ^endpoint}} -> all_waiting([from | acc], endpoint)
after
0 -> acc
end
end
defp mix_compile({:module, Mix.Task}, compilers, apps_to_reload) do
mix_compile_deps(Mix.Dep.cached, apps_to_reload, compilers)
mix_compile_project(Mix.Project.config()[:app], apps_to_reload, compilers)
end
defp mix_compile({:error, _reason}, _, _) do
raise "the Code Reloader is enabled but Mix is not available. If you want to " <>
"use the Code Reloader in production or inside an escript, you must add " <>
":mix to your applications list. Otherwise, you must disable code reloading " <>
"in such environments"
end
defp mix_compile_deps(deps, apps_to_reload, compilers) do
for dep <- deps, dep.app in apps_to_reload do
Mix.Dep.in_dependency dep, fn _ ->
mix_compile_unless_stale_config(compilers)
end
end
:ok
end
defp mix_compile_project(nil, _, _), do: :ok
defp mix_compile_project(app, apps_to_reload, compilers) do
if app in apps_to_reload do
mix_compile_unless_stale_config(compilers)
end
:ok
end
defp mix_compile_unless_stale_config(compilers) do
manifests = Mix.Tasks.Compile.Elixir.manifests
configs = Mix.Project.config_files
case Mix.Utils.extract_stale(configs, manifests) do
[] ->
mix_compile(compilers)
files ->
raise """
could not compile application: #{Mix.Project.config[:app]}.
You must restart your server after changing the following config or lib files:
* #{Enum.map_join(files, "\n * ", &Path.relative_to_cwd/1)}
"""
end
end
defp mix_compile(compilers) do
all = Mix.Project.config[:compilers] || Mix.compilers
compilers =
for compiler <- compilers, compiler in all do
Mix.Task.reenable("compile.#{compiler}")
compiler
end
# We call build_structure mostly for Windows so new
# assets in priv are copied to the build directory.
Mix.Project.build_structure
results = Enum.map(compilers, &Mix.Task.run("compile.#{&1}", []))
# Results are either {:ok, _} | {:error, _}, {:noop, _} or
# :ok | :error | :noop. So we use proplists to do the unwraping.
cond do
:proplists.get_value(:error, results, false) ->
exit({:shutdown, 1})
:proplists.get_value(:ok, results, false) && consolidate_protocols?() ->
Mix.Task.reenable("compile.protocols")
Mix.Task.run("compile.protocols", [])
:ok
true ->
:ok
end
end
defp consolidate_protocols? do
Mix.Project.config[:consolidate_protocols]
end
defp proxy_io(fun) do
original_gl = Process.group_leader
{:ok, proxy_gl} = Proxy.start()
Process.group_leader(self(), proxy_gl)
try do
{fun.(), Proxy.stop(proxy_gl)}
after
Process.group_leader(self(), original_gl)
Process.exit(proxy_gl, :kill)
end
end
end