Add default timeout to elixir_code_server and unify all call points

Author: José Valim

lib/elixir/lib/code.ex

@@ -20,7 +20,7 @@ defmodule Code do
   Returns all the loaded files.
   """
   def loaded_files do
-    server_call :loaded
+    :elixir_code_server.call :loaded
   end
 
   @doc """
@@ -30,7 +30,7 @@ defmodule Code do
   allowing it to be required again.
   """
   def unload_files(files) do
-    server_cast { :unload_files, files }
+    :elixir_code_server.cast { :unload_files, files }
   end
 
   @doc """
@@ -198,9 +198,9 @@ defmodule Code do
   """
   def load_file(file, relative_to // nil) when is_binary(file) do
     file = find_file(file, relative_to)
-    server_call { :acquire, file }
+    :elixir_code_server.call { :acquire, file }
     loaded = :elixir_compiler.file file
-    server_cast { :loaded, file }
+    :elixir_code_server.cast { :loaded, file }
     loaded
   end
 
@@ -220,14 +220,14 @@ defmodule Code do
   def require_file(file, relative_to // nil) when is_binary(file) do
     file = find_file(file, relative_to)
 
-    case server_call({ :acquire, file }) do
+    case :elixir_code_server.call({ :acquire, file }) do
       :loaded  ->
         nil
       { :queued, ref }  ->
         receive do { :elixir_code_server, ^ref, :loaded } -> nil end
       :proceed ->
         loaded = :elixir_compiler.file file
-        server_cast { :loaded, file }
+        :elixir_code_server.cast { :loaded, file }
         loaded
     end
   end
@@ -237,7 +237,7 @@ defmodule Code do
   Check compiler_options/1 for more information.
   """
   def compiler_options do
-    server_call :compiler_options
+    :elixir_code_server.call :compiler_options
   end
 
   @doc """
@@ -256,7 +256,7 @@ defmodule Code do
 
   """
   def compiler_options(opts) do
-    server_call { :compiler_options, opts }
+    :elixir_code_server.cast { :compiler_options, opts }
   end
 
   @doc """
@@ -377,12 +377,4 @@ defmodule Code do
       raise LoadError, file: file
     end
   end
-
-  defp server_call(args) do
-    :gen_server.call(:elixir_code_server, args)
-  end
-
-  defp server_cast(args) do
-    :gen_server.cast(:elixir_code_server, args)
-  end
 end

lib/elixir/lib/kernel/cli.ex

@@ -12,19 +12,19 @@ defmodule Kernel.CLI do
     argv = lc arg inlist argv, do: list_to_binary(arg)
 
     { config, argv } = process_argv(argv, Kernel.CLI.Config.new)
-    :gen_server.call(:elixir_code_server, { :argv, argv })
+    :elixir_code_server.cast({ :argv, argv })
 
     run fn ->
       Enum.map Enum.reverse(config.commands), process_command(&1, config)
-      :gen_server.cast(:elixir_code_server, :finished)
+      :elixir_code_server.cast(:finished)
     end, config.halt
   end
 
   @doc """
-  Wait until the CLI finishes procesing options.
+  Wait until the CLI finishes processing options.
   """
   def wait_until_finished do
-    case :gen_server.call(:elixir_code_server, { :wait_until_finished, self }) do
+    case :elixir_code_server.call({ :wait_until_finished, self }) do
       :wait ->
         receive do
           { :elixir_code_server, :finished } -> :ok
@@ -74,7 +74,7 @@ defmodule Kernel.CLI do
   ## Private
 
   defp at_exit(status) do
-    hooks = :gen_server.call(:elixir_code_server, :flush_at_exit)
+    hooks = :elixir_code_server.call(:flush_at_exit)
 
     lc hook inlist hooks do
       try do

lib/elixir/lib/system.ex

@@ -55,7 +55,7 @@ defmodule System do
   """
   @spec argv() :: [String.t]
   def argv do
-    :gen_server.call(:elixir_code_server, :argv)
+    :elixir_code_server.call :argv
   end
 
   @doc """
@@ -155,7 +155,7 @@ defmodule System do
   as argument.
   """
   def at_exit(fun) when is_function(fun, 1) do
-    server_call { :at_exit, fun }
+    :elixir_code_server.cast { :at_exit, fun }
   end
 
   @doc """
@@ -311,10 +311,6 @@ defmodule System do
 
   ## Helpers
 
-  defp server_call(args) do
-    :gen_server.call(:elixir_code_server, args)
-  end
-
   defp filter_stacktrace([{ Kernel, :raise, _, _ }|t]), do: t
   defp filter_stacktrace(t), do: t
 end

lib/elixir/src/elixir_code_server.erl

@@ -1,4 +1,5 @@
 -module(elixir_code_server).
+-export([call/1, cast/1]).
 -export([start_link/0, init/1, handle_call/3, handle_cast/2,
   handle_info/2, terminate/2, code_change/3]).
 -behavior(gen_server).
@@ -12,8 +13,19 @@
   waiting=[]
 }).
 
+call(Args) ->
+  gen_server:call(?MODULE, Args, get_timeout()).
+
+cast(Args) ->
+  gen_server:cast(?MODULE, Args).
+
+get_timeout() ->
+  30000.
+
+%% Callbacks
+
 start_link() ->
-  { ok, _ } = gen_server:start_link({local, elixir_code_server}, ?MODULE, [], []).
+  { ok, _ } = gen_server:start_link({local, ?MODULE}, ?MODULE, [], []).
 
 init(_args) ->
   { ok, #elixir_code_server{} }.
@@ -38,16 +50,6 @@ handle_call({ acquire, Path }, From, Config) ->
       { reply, proceed, Config#elixir_code_server{loaded=Queued} }
   end;
 
-handle_call({ at_exit, AtExit }, _From, Config) ->
-  { reply, ok, Config#elixir_code_server{at_exit=[AtExit|Config#elixir_code_server.at_exit]} };
-
-handle_call({ argv, Argv }, _From, Config) ->
-  { reply, ok, Config#elixir_code_server{argv=Argv} };
-
-handle_call({ compiler_options, Options }, _From, Config) ->
-  Final = orddict:merge(fun(_,_,V) -> V end, Config#elixir_code_server.compiler_options, Options),
-  { reply, ok, Config#elixir_code_server{compiler_options=Final} };
-
 handle_call(loaded, _From, Config) ->
   { reply, [F || { F, true } <- Config#elixir_code_server.loaded], Config };
 
@@ -75,6 +77,16 @@ handle_call(retrieve_module_name, _From, Config) ->
 handle_call(_Request, _From, Config) ->
   { reply, undef, Config }.
 
+handle_cast({ at_exit, AtExit }, Config) ->
+  { noreply, Config#elixir_code_server{at_exit=[AtExit|Config#elixir_code_server.at_exit]} };
+
+handle_cast({ argv, Argv }, Config) ->
+  { noreply, Config#elixir_code_server{argv=Argv} };
+
+handle_cast({ compiler_options, Options }, Config) ->
+  Final = orddict:merge(fun(_,_,V) -> V end, Config#elixir_code_server.compiler_options, Options),
+  { noreply, Config#elixir_code_server{compiler_options=Final} };
+
 handle_cast(finished, Config) ->
   Waiting = Config#elixir_code_server.waiting,
   [Pid ! { elixir_code_server, finished } || Pid <- lists:reverse(Waiting)],

lib/elixir/src/elixir_compiler.erl

@@ -17,7 +17,7 @@ get_opt(Key, Dict) ->
   end.
 
 get_opts() ->
-  gen_server:call(elixir_code_server, compiler_options).
+  elixir_code_server:call(compiler_options).
 
 %% Compiles the given string.
 
@@ -107,7 +107,7 @@ module(Forms, File, Options, Bootstrap, Callback) when
 
 core() ->
   application:start(elixir),
-  gen_server:call(elixir_code_server, { compiler_options, [{docs,false},{internal,true}] }),
+  elixir_code_server:cast({ compiler_options, [{docs,false},{internal,true}] }),
   [core_file(File) || File <- core_main()].
 
 %% HELPERS
@@ -139,10 +139,10 @@ module_form(Fun, Exprs, Line, File, Module, Vars) when
 %% Generate module names from code server.
 
 retrieve_module_name() ->
-  gen_server:call(elixir_code_server, retrieve_module_name).
+  elixir_code_server:call(retrieve_module_name).
 
 return_module_name(I) ->
-  gen_server:cast(elixir_code_server, { return_module_name, I }).
+  elixir_code_server:cast({ return_module_name, I }).
 
 %% Receives a module Binary and outputs it in the given path.
 

lib/ex_unit/lib/ex_unit/cli_formatter.ex

@@ -5,6 +5,7 @@ defmodule ExUnit.CLIFormatter do
   """
 
   @behaviour ExUnit.Formatter
+  @timeout 30_000
   use GenServer.Behaviour
 
   import Exception, only: [format_entry: 1]
@@ -18,7 +19,7 @@ defmodule ExUnit.CLIFormatter do
   end
 
   def suite_finished(id) do
-    :gen_server.call(id, :suite_finished)
+    :gen_server.call(id, :suite_finished, @timeout)
   end
 
   def case_started(_id, _test_case) do

lib/ex_unit/lib/ex_unit/server.ex

@@ -1,6 +1,7 @@
 defmodule ExUnit.Server do
   @moduledoc false
 
+  @timeout 30_000
   use GenServer.Behaviour
 
   defrecord Config, options: [], async_cases: [], sync_cases: [], after_spawn: []
@@ -30,15 +31,15 @@ defmodule ExUnit.Server do
   ## After run API
 
   def options do
-    :gen_server.call(__MODULE__, :options)
+    :gen_server.call(__MODULE__, :options, @timeout)
   end
 
   def cases do
-    :gen_server.call(__MODULE__, :cases)
+    :gen_server.call(__MODULE__, :cases, @timeout)
   end
 
   def run_after_spawn do
-    funs = :gen_server.call(__MODULE__, :after_spawn)
+    funs = :gen_server.call(__MODULE__, :after_spawn, @timeout)
     lc fun inlist funs, do: fun.()
   end
 

lib/mix/lib/mix/server.ex

@@ -12,7 +12,7 @@ defmodule Mix.Server do
   end
 
   def call(arg) do
-    :gen_server.call(__MODULE__, arg)
+    :gen_server.call(__MODULE__, arg, 30_000)
   end
 
   def cast(arg) do