Merge branch 'hello_command'

# Conflicts:
#	lib/mongo/mongo_db_connection.ex

Author: zookzook

lib/mongo.ex

@@ -1504,7 +1504,7 @@ defmodule Mongo do
           {:ok, BSON.document() | nil} | {:error, Mongo.Error.t()}
   def exec_command_session(session, cmd, opts) do
     with {:ok, conn, new_cmd} <- Session.bind_session(session, cmd),
-         {:ok, _cmd, response} <- DBConnection.execute(conn, %Query{action: :command}, [new_cmd], defaults(opts)),
+         {:ok, _cmd, response} <- DBConnection.execute(conn, %Query{action: {:command, new_cmd}}, [], defaults(opts)),
          :ok <- Session.update_session(session, response, opts),
          {:ok, {_flags, doc}} <- check_for_error(response, cmd, opts) do
       {:ok, doc}
@@ -1518,7 +1518,19 @@ defmodule Mongo do
   @spec exec_command(GenServer.server(), BSON.document(), Keyword.t()) ::
           {:ok, {any(), BSON.document()} | nil} | {:error, Mongo.Error.t()}
   def exec_command(conn, cmd, opts) do
-    with {:ok, _cmd, response} <- DBConnection.execute(conn, %Query{action: :command}, [cmd], defaults(opts)) do
+    with {:ok, _cmd, response} <- DBConnection.execute(conn, %Query{action: {:command, cmd}}, [], defaults(opts)) do
+      check_for_error(response, cmd, opts)
+    end
+  end
+
+  def exec_hello(conn, opts) do
+    with {:ok, _cmd, response} <- DBConnection.execute(conn, %Query{action: {:exec_hello, []}}, [], defaults(opts)) do
+      check_for_error(response, [hello: 1], opts)
+    end
+  end
+
+  def exec_hello(conn, cmd, opts) do
+    with {:ok, _cmd, response} <- DBConnection.execute(conn, %Query{action: {:exec_hello, cmd}}, [], defaults(opts)) do
       check_for_error(response, cmd, opts)
     end
   end
@@ -1536,7 +1548,7 @@ defmodule Mongo do
   end
 
   def exec_more_to_come(conn, opts) do
-    with {:ok, _cmd, response} <- DBConnection.execute(conn, %Query{action: :command}, [:more_to_come], defaults(opts)) do
+    with {:ok, _cmd, response} <- DBConnection.execute(conn, %Query{action: :more_to_come}, [], defaults(opts)) do
       check_for_error(response, [:more_to_come], opts)
     end
   end

lib/mongo/event_handler.ex

@@ -24,13 +24,13 @@ defmodule Mongo.EventHandler do
 
   def listen(opts) do
     receive do
-      {:broadcast, :commands, %{command_name: cmd} = message} when cmd != :isMaster ->
+      {:broadcast, :commands, %{command_name: cmd} = message} when cmd != :isMaster and cmd != :hello ->
         Logger.info("Received command: " <> inspect(message))
         listen(opts)
 
-      {:broadcast, :commands, is_master} ->
-        case opts[:is_master] do
-          true -> Logger.info("Received is master:" <> inspect(is_master))
+      {:broadcast, :commands, hello} ->
+        case opts[:is_master] || opts[:hello] do
+          true -> Logger.info("Received hello:" <> inspect(hello))
           _ -> []
         end
 

lib/mongo/mongo_db_connection.ex

@@ -95,10 +95,10 @@ defmodule Mongo.MongoDBConnection do
   end
 
   @impl true
-  def handle_execute(%Mongo.Query{action: action} = query, params, opts, original_state) do
+  def handle_execute(%Mongo.Query{action: action} = query, _params, opts, original_state) do
     tmp_state = %{original_state | database: Keyword.get(opts, :database, original_state.database)}
 
-    with {:ok, reply, tmp_state} <- execute_action(action, params, opts, tmp_state) do
+    with {:ok, reply, tmp_state} <- send_command(action, opts, tmp_state) do
       {:ok, query, reply, Map.put(tmp_state, :database, original_state.database)}
     end
   end
@@ -264,7 +264,7 @@ defmodule Mongo.MongoDBConnection do
   ##
   # Executes a hello or the legacy hello command
   ##
-  defp execute_action({:exec_hello, cmd}, _params, opts, %{use_op_msg: true} = state) do
+  defp send_command({:exec_hello, cmd}, opts, %{use_op_msg: true} = state) do
     db = opts[:database] || state.database
     timeout = Keyword.get(opts, :timeout, state.timeout)
     flags = Keyword.get(opts, :flags, 0x0)
@@ -297,7 +297,7 @@ defmodule Mongo.MongoDBConnection do
   ##
   # Executes a more to come command
   ##
-  defp execute_action(:command, [:more_to_come], opts, %{use_op_msg: true} = state) do
+  defp send_command(:more_to_come, opts, %{use_op_msg: true} = state) do
     event = %MoreToComeEvent{command: :more_to_come, command_name: opts[:command_name] || :more_to_come}
 
     timeout = Keyword.get(opts, :timeout, state.timeout)
@@ -313,7 +313,7 @@ defmodule Mongo.MongoDBConnection do
     end
   end
 
-  defp execute_action(:command, [cmd], opts, %{use_op_msg: true} = state) do
+  defp send_command({:command, cmd}, opts, %{use_op_msg: true} = state) do
     {command_name, data} = provide_cmd_data(cmd)
     db = opts[:database] || state.database
     cmd = cmd ++ ["$db": db]
@@ -350,7 +350,7 @@ defmodule Mongo.MongoDBConnection do
     end
   end
 
-  defp execute_action(:command, [cmd], opts, state) do
+  defp send_command({:command, cmd}, opts, state) do
     [{command_name, _} | _] = cmd
 
     event = %CommandStartedEvent{
@@ -376,7 +376,7 @@ defmodule Mongo.MongoDBConnection do
     end
   end
 
-  defp execute_action(:error, _query, _opts, state) do
+  defp send_command(:error, _opts, state) do
     exception = Mongo.Error.exception("Test-case")
     {:disconnect, exception, state}
   end

lib/mongo/monitor.ex

@@ -5,7 +5,7 @@ defmodule Mongo.Monitor do
   If the network connection is working, then the monitor process reports this and the topology process starts the
   connection pool. Per server we get 1 + pool size connections to each server.
 
-  After waiting for `heartbeat_frequency_ms` milliseconds, the monitor process calls `isMaster` command and
+  After waiting for `heartbeat_frequency_ms` milliseconds, the monitor process calls `hello` command and
   reports the result to the topology process.
 
   The result of the hello command is mapped the `ServerDescription` structure and sent to the topology process, which

lib/mongo/streaming_hello_monitor.ex

@@ -78,7 +78,7 @@ defmodule Mongo.StreamingHelloMonitor do
   end
 
   @doc """
-  Time to update the topology. Calling `isMaster` and updating the server description
+  Time to update the topology. Calling `hello` and updating the server description
   """
   def handle_cast(:update, state) do
     handle_info(:update, state)