Improve handling for multi exec commands when unable to connect to the Redis server

lib/srh/http/command_handler.ex

@@ -95,26 +95,35 @@ defmodule Srh.Http.CommandHandler do
         # Borrow a client, then run all of the commands (wrapped in MULTI and EXEC)
         worker_pid = Client.borrow_worker(client_pid)
 
-        wrapped_command_array = [["MULTI"] | command_array]
-        do_dispatch_command_transaction_array(wrapped_command_array, worker_pid, responses)
-
-        # Now manually run the EXEC - this is what contains the information to form the response, not the above
-        result =
-          case ClientWorker.redis_command(worker_pid, ["EXEC"]) do
-            {:ok, res} ->
-              {
-                :ok,
-                res
-                |> Enum.map(&%{result: &1})
-              }
-
-            {:error, error} ->
-              decode_error(error)
-          end
-
-        Client.return_worker(client_pid, worker_pid)
-
-        result
+        # We are manually going to invoke the MULTI, because there might be a connection error to the Redis server.
+        # In that case, we don't want the error to be wound up in the array of errors,
+        # we instead want to return the error immediately.
+        case ClientWorker.redis_command(worker_pid, ["MULTI"]) do
+          {:ok, _} ->
+            do_dispatch_command_transaction_array(command_array, worker_pid, responses)
+
+            # Now manually run the EXEC - this is what contains the information to form the response, not the above
+            result =
+              case ClientWorker.redis_command(worker_pid, ["EXEC"]) do
+                {:ok, res} ->
+                  {
+                    :ok,
+                    res
+                    |> Enum.map(&%{result: &1})
+                  }
+
+                {:error, error} ->
+                  decode_error(error)
+              end
+
+            Client.return_worker(client_pid, worker_pid)
+
+            # Fire back the result here, because the initial Multi was successful
+            result
+
+          {:error, error} ->
+            decode_error(error)
+        end
 
       {:error, msg} ->
         {:server_error, msg}

lib/srh/http/request_validator.ex

@@ -34,7 +34,6 @@ defmodule Srh.Http.RequestValidator do
   defp do_validate_encoding_header([first_item | rest]) do
     case first_item do
       "base64" -> {:ok, true}
-
       _ -> do_validate_encoding_header(rest)
     end
   end

lib/srh/http/result_encoder.ex

@@ -1,5 +1,4 @@
 defmodule Srh.Http.ResultEncoder do
-
   # Authentication errors don't get encoded, we need to skip over those
   def encode_response({:not_authorized, message}) do
     {:not_authorized, message}
@@ -27,12 +26,16 @@ defmodule Srh.Http.ResultEncoder do
   ## RESULT LIST ENCODING ##
 
   defp encode_response_list([current | rest], encoded_responses) do
-    encoded_current_entry = case current do
-      %{result: value} ->
-        %{result: encode_result_value(value)} # Encode the value
-      %{error: error_message} ->
-        %{error: error_message} # We don't encode errors
-    end
+    encoded_current_entry =
+      case current do
+        %{result: value} ->
+          # Encode the value
+          %{result: encode_result_value(value)}
+
+        %{error: error_message} ->
+          # We don't encode errors
+          %{error: error_message}
+      end
 
     encode_response_list(rest, [encoded_current_entry | encoded_responses])
   end

lib/srh/redis/client_registry.ex

@@ -48,10 +48,9 @@ defmodule Srh.Redis.ClientRegistry do
           {:ok, pid},
           %{
             state_update
-          |
-            currently_borrowed_pids:
-              [pid | state_update.currently_borrowed_pids]
-              |> Enum.uniq()
+            | currently_borrowed_pids:
+                [pid | state_update.currently_borrowed_pids]
+                |> Enum.uniq()
           }
         }
     end
@@ -73,10 +72,9 @@ defmodule Srh.Redis.ClientRegistry do
       :noreply,
       %{
         state
-      |
-        worker_pids:
-          [pid | state.worker_pids]
-          |> Enum.uniq()
+        | worker_pids:
+            [pid | state.worker_pids]
+            |> Enum.uniq()
       }
     }
   end