Proxy for expensive API requests (#736)

* Proxy for expensive API requests

When doing complicated refactors, the language server will often spam
remote_control with a ton of operations when the refactor is going on.
These operations will slow down both the editor and remote_control so
that it's not particularly usable. In order to mitigate this, certain
operations, like project compilation, can be buffered and completed when
the refactor has completed.

This PR implements a proxy module that buffers these complicated
operations, and monitors the calling process. When that process exits,
the buffered operations are emitted in remote_control, allowing them to
complete without disrupting the refactor.

In testing, I found two deadlocks. The first was that the build server
was using RemoteControl.call to invoke itself rather than
`GenServer.call`. This created an additional lock, and was
unnecessary, because it's running locally.

The second was more insidious. The proxy module made a bunch of
separate calls to other modules, which in turn woud call
`Build.with_lock`, which would then be run inside the proxy's
process. This would cause fairly frequent locks in the proxy process.
Moving these calls into tasks, fixes things, but creates the need for
an additional `draining` state of the proxy, which it enteres if there
are in-flight requests when `start_buffering` is called.

---------

Co-authored-by: Zach Allaun <[email protected]>

apps/remote_control/lib/lexical/remote_control.ex

@@ -6,12 +6,62 @@ defmodule Lexical.RemoteControl do
   """
 
   alias Lexical.Project
+  alias Lexical.RemoteControl
+  alias Lexical.RemoteControl.Api.Proxy
+  alias Lexical.RemoteControl.CodeAction
+  alias Lexical.RemoteControl.CodeIntelligence
   alias Lexical.RemoteControl.ProjectNode
+
   require Logger
 
   @excluded_apps [:patch, :nimble_parsec]
   @allowed_apps [:remote_control | Mix.Project.deps_apps()] -- @excluded_apps
 
+  defdelegate schedule_compile(force?), to: Proxy
+
+  defdelegate compile_document(document), to: Proxy
+
+  defdelegate format(document), to: Proxy
+
+  defdelegate reindex, to: Proxy
+
+  defdelegate index_running?, to: Proxy
+
+  defdelegate broadcast(message), to: Proxy
+
+  defdelegate expand_alias(segments_or_module, analysis, position), to: RemoteControl.Analyzer
+
+  defdelegate list_modules, to: :code, as: :all_available
+
+  defdelegate code_actions(document, range, diagnostics, kinds), to: CodeAction, as: :for_range
+
+  defdelegate complete(env), to: RemoteControl.Completion, as: :elixir_sense_expand
+
+  defdelegate complete_struct_fields(analysis, position),
+    to: RemoteControl.Completion,
+    as: :struct_fields
+
+  defdelegate definition(document, position), to: CodeIntelligence.Definition
+
+  defdelegate references(analysis, position, include_definitions?),
+    to: CodeIntelligence.References
+
+  defdelegate modules_with_prefix(prefix), to: RemoteControl.Modules, as: :with_prefix
+
+  defdelegate modules_with_prefix(prefix, predicate), to: RemoteControl.Modules, as: :with_prefix
+
+  defdelegate docs(module, opts \\ []), to: CodeIntelligence.Docs, as: :for_module
+
+  defdelegate register_listener(listener_pid, message_types), to: RemoteControl.Dispatch
+
+  defdelegate resolve_entity(analysis, position), to: CodeIntelligence.Entity, as: :resolve
+
+  defdelegate struct_definitions, to: CodeIntelligence.Structs, as: :for_project
+
+  defdelegate document_symbols(document), to: CodeIntelligence.Symbols, as: :for_document
+
+  defdelegate workspace_symbols(query), to: CodeIntelligence.Symbols, as: :for_workspace
+
   def start_link(%Project{} = project) do
     :ok = ensure_epmd_started()
     start_net_kernel(project)
@@ -49,15 +99,15 @@ defmodule Lexical.RemoteControl do
     |> :erpc.call(m, f, a)
   end
 
-  defp start_net_kernel(%Project{} = project) do
-    :net_kernel.start([manager_node_name(project)])
-  end
-
   def manager_node_name(%Project{} = project) do
     :"manager-#{Project.name(project)}-#{Project.entropy(project)}@127.0.0.1"
   end
 
-  def ensure_apps_started(node, app_names) do
+  defp start_net_kernel(%Project{} = project) do
+    :net_kernel.start([manager_node_name(project)])
+  end
+
+  defp ensure_apps_started(node, app_names) do
     Enum.reduce_while(app_names, :ok, fn app_name, _ ->
       case :rpc.call(node, :application, :ensure_all_started, [app_name]) do
         {:ok, _} -> {:cont, :ok}
@@ -66,7 +116,7 @@ defmodule Lexical.RemoteControl do
     end)
   end
 
-  def glob_paths do
+  defp glob_paths do
     for entry <- :code.get_path(),
         entry_string = List.to_string(entry),
         entry_string != ".",

apps/remote_control/lib/lexical/remote_control/api.ex

@@ -6,36 +6,37 @@ defmodule Lexical.RemoteControl.Api do
   alias Lexical.Document.Range
   alias Lexical.Project
   alias Lexical.RemoteControl
-  alias Lexical.RemoteControl.Build
-  alias Lexical.RemoteControl.CodeAction
   alias Lexical.RemoteControl.CodeIntelligence
-  alias Lexical.RemoteControl.CodeMod
-  alias Lexical.RemoteControl.Commands
 
   require Logger
 
-  defdelegate schedule_compile(project, force?), to: Build
-  defdelegate compile_document(project, document), to: Build
+  def schedule_compile(%Project{} = project, force?) do
+    RemoteControl.call(project, RemoteControl, :schedule_compile, [force?])
+  end
+
+  def compile_document(%Project{} = project, %Document{} = document) do
+    RemoteControl.call(project, RemoteControl, :compile_document, [document])
+  end
 
   def expand_alias(
         %Project{} = project,
         segments_or_module,
         %Analysis{} = analysis,
         %Position{} = position
       ) do
-    RemoteControl.call(project, RemoteControl.Analyzer, :expand_alias, [
+    RemoteControl.call(project, RemoteControl, :expand_alias, [
       segments_or_module,
       analysis,
       position
     ])
   end
 
   def list_modules(%Project{} = project) do
-    RemoteControl.call(project, :code, :all_available)
+    RemoteControl.call(project, RemoteControl, :list_modules)
   end
 
   def format(%Project{} = project, %Document{} = document) do
-    RemoteControl.call(project, CodeMod.Format, :edits, [document])
+    RemoteControl.call(project, RemoteControl, :format, [document])
   end
 
   def code_actions(
@@ -45,26 +46,28 @@ defmodule Lexical.RemoteControl.Api do
         diagnostics,
         kinds
       ) do
-    RemoteControl.call(project, CodeAction, :for_range, [document, range, diagnostics, kinds])
+    RemoteControl.call(project, RemoteControl, :code_actions, [
+      document,
+      range,
+      diagnostics,
+      kinds
+    ])
   end
 
   def complete(%Project{} = project, %Env{} = env) do
     Logger.info("Completion for #{inspect(env.position)}")
-    RemoteControl.call(project, RemoteControl.Completion, :elixir_sense_expand, [env])
+    RemoteControl.call(project, RemoteControl, :complete, [env])
   end
 
   def complete_struct_fields(%Project{} = project, %Analysis{} = analysis, %Position{} = position) do
-    RemoteControl.call(project, RemoteControl.Completion, :struct_fields, [
+    RemoteControl.call(project, RemoteControl, :complete_struct_fields, [
       analysis,
       position
     ])
   end
 
   def definition(%Project{} = project, %Document{} = document, %Position{} = position) do
-    RemoteControl.call(project, CodeIntelligence.Definition, :definition, [
-      document,
-      position
-    ])
+    RemoteControl.call(project, RemoteControl, :definition, [document, position])
   end
 
   def references(
@@ -73,7 +76,7 @@ defmodule Lexical.RemoteControl.Api do
         %Position{} = position,
         include_definitions?
       ) do
-    RemoteControl.call(project, CodeIntelligence.References, :references, [
+    RemoteControl.call(project, RemoteControl, :references, [
       analysis,
       position,
       include_definitions?
@@ -82,52 +85,52 @@ defmodule Lexical.RemoteControl.Api do
 
   def modules_with_prefix(%Project{} = project, prefix)
       when is_binary(prefix) or is_atom(prefix) do
-    RemoteControl.call(project, RemoteControl.Modules, :with_prefix, [prefix])
+    RemoteControl.call(project, RemoteControl, :modules_with_prefix, [prefix])
   end
 
   def modules_with_prefix(%Project{} = project, prefix, predicate)
       when is_binary(prefix) or is_atom(prefix) do
-    RemoteControl.call(project, RemoteControl.Modules, :with_prefix, [prefix, predicate])
+    RemoteControl.call(project, RemoteControl, :modules_with_prefix, [prefix, predicate])
   end
 
   @spec docs(Project.t(), module()) :: {:ok, CodeIntelligence.Docs.t()} | {:error, any()}
   def docs(%Project{} = project, module, opts \\ []) when is_atom(module) do
-    RemoteControl.call(project, CodeIntelligence.Docs, :for_module, [module, opts])
+    RemoteControl.call(project, RemoteControl, :docs, [module, opts])
   end
 
   def register_listener(%Project{} = project, listener_pid, message_types)
       when is_pid(listener_pid) and is_list(message_types) do
-    RemoteControl.call(project, RemoteControl.Dispatch, :register_listener, [
+    RemoteControl.call(project, RemoteControl, :register_listener, [
       listener_pid,
       message_types
     ])
   end
 
   def broadcast(%Project{} = project, message) do
-    RemoteControl.call(project, RemoteControl.Dispatch, :broadcast, [message])
+    RemoteControl.call(project, RemoteControl, :broadcast, [message])
   end
 
   def reindex(%Project{} = project) do
-    RemoteControl.call(project, Commands.Reindex, :perform, [])
+    RemoteControl.call(project, RemoteControl, :reindex, [])
   end
 
   def index_running?(%Project{} = project) do
-    RemoteControl.call(project, Commands.Reindex, :running?, [])
+    RemoteControl.call(project, RemoteControl, :index_running?, [])
   end
 
   def resolve_entity(%Project{} = project, %Analysis{} = analysis, %Position{} = position) do
-    RemoteControl.call(project, CodeIntelligence.Entity, :resolve, [analysis, position])
+    RemoteControl.call(project, RemoteControl, :resolve_entity, [analysis, position])
   end
 
   def struct_definitions(%Project{} = project) do
-    RemoteControl.call(project, CodeIntelligence.Structs, :for_project, [])
+    RemoteControl.call(project, RemoteControl, :struct_definitions, [])
   end
 
   def document_symbols(%Project{} = project, %Document{} = document) do
-    RemoteControl.call(project, CodeIntelligence.Symbols, :for_document, [document])
+    RemoteControl.call(project, RemoteControl, :document_symbols, [document])
   end
 
   def workspace_symbols(%Project{} = project, query) do
-    RemoteControl.call(project, CodeIntelligence.Symbols, :for_workspace, [query])
+    RemoteControl.call(project, RemoteControl, :workspace_symbols, [query])
   end
 end