1.2.0 - more options for commands, and shell running

Author: manuel-rubio

lib/hemdal/config/command.ex

@@ -4,14 +4,20 @@ defmodule Hemdal.Config.Command do
   each alert. The data used is:
 
   - `name` the name of the script.
-  - `type` the type of the script could be `line` or `script`.
+  - `type` the type of the script could be `line`, `shell` or `script`.
     The first one let us define a command in a single line,
     the last one let us define a script, a multi-line code which will be
     copied and executed in the host, and the last one let us run a command
     interacting with a process for providing information in runtime.
+    The type `shell` is different to the others because it has no command
+    to run and it should be `interactive`, indeed it configures interactive
+    by default as `true`.
   - `interactive` specify if the command is handled in an interactive way
     (default: false).
   - `output` specify if the output should be stored (default: true).
+  - `idle_timeout` specify the time between interactions that the interactive
+    execution will be kept open in milliseconds (default: 60_000).
+  - `decode` says if we should decode (JSON) the output or not (default: true).
   - `command` as the command line to be executed. It could be only one line
     or a multi-line script.
   """
@@ -21,6 +27,8 @@ defmodule Hemdal.Config.Command do
     field(:type, :string)
     field(:interactive, :boolean, default: false)
     field(:output, :boolean, default: true)
-    field(:command, :string)
+    field(:idle_timeout, :integer, default: :timer.minutes(1))
+    field(:decode, :boolean, default: true)
+    field(:command, :string, default: nil)
   end
 end

lib/hemdal/host.ex

@@ -417,7 +417,7 @@ defmodule Hemdal.Host do
   defp run_in_background(caller, cmd, args, send_result, %__MODULE__{host: %_{module: mod} = host}) do
     mod.transaction(host, fn handler ->
       with {:ok, errorlevel, output} <- exec_cmd(handler, mod, caller, cmd, args),
-           {:ok, %{"status" => status} = data} <- decode(output) do
+           {:ok, %{"status" => status} = data} <- decode(output, errorlevel, cmd.decode) do
         Logger.debug("command exit(#{errorlevel}) output: #{inspect(data)}")
         run_result(data, errorlevel, status)
       else
@@ -430,16 +430,38 @@ defmodule Hemdal.Host do
     :ok
   end
 
-  defp decode(output) do
+  defp decode(nil, 0, _), do: {:ok, %{"status" => "OK", "errorlevel" => 0}}
+
+  defp decode(nil, errorlevel, _) do
+    {:error, %{"status" => "UNKNOWN", "errorlevel" => errorlevel}}
+  end
+
+  defp decode(output, 0, false) when is_binary(output) do
+    {:ok, %{"status" => "OK", "message" => output}}
+  end
+
+  defp decode(output, 0, false) do
+    {:ok, %{"status" => "OK", "message" => "#{inspect(output)}"}}
+  end
+
+  defp decode(output, errorlevel, false) when is_binary(output) do
+    {:ok, %{"status" => "OK", "message" => output, "errorlevel" => errorlevel}}
+  end
+
+  defp decode(output, errorlevel, false) do
+    {:ok, %{"status" => "OK", "message" => "#{inspect(output)}", "errorlevel" => errorlevel}}
+  end
+
+  defp decode(output, errorlevel, true) do
     case Jason.decode(output) do
       {:ok, [status, message]} ->
-        {:ok, %{"status" => status, "message" => message}}
+        {:ok, %{"status" => status, "message" => message, "errorlevel" => errorlevel}}
 
       {:ok, status} when is_binary(status) ->
-        {:ok, %{"status" => status}}
+        {:ok, %{"status" => status, "errorlevel" => errorlevel}}
 
       {:error, %Jason.DecodeError{data: error}} ->
-        {:error, %{"message" => error, "status" => "UNKNOWN"}}
+        {:error, %{"message" => error, "status" => "UNKNOWN", "errorlevel" => errorlevel}}
 
       other_resp ->
         other_resp
@@ -453,12 +475,18 @@ defmodule Hemdal.Host do
     |> String.pad_leading(7, "0")
   end
 
+  defp exec_cmd(handler, mod, caller, %Command{type: "shell"} = cmd, _args) do
+    opts = [output: cmd.output, timeout: cmd.idle_timeout, command: cmd.command]
+    mod.shell(handler, caller, opts)
+  end
+
   defp exec_cmd(handler, mod, _caller, %Command{type: "line", command: command, interactive: false}, _args) do
     mod.exec(handler, command)
   end
 
-  defp exec_cmd(handler, mod, caller, %Command{type: "line", command: command}, _args) do
-    mod.exec_interactive(handler, command, caller)
+  defp exec_cmd(handler, mod, caller, %Command{type: "line", command: command} = cmd, _args) do
+    opts = [output: cmd.output, timeout: cmd.idle_timeout]
+    mod.exec_interactive(handler, command, caller, opts)
   end
 
   defp exec_cmd(handler, mod, _caller, %Command{type: "script", command: script, interactive: false}, args) do
@@ -479,7 +507,7 @@ defmodule Hemdal.Host do
     end
   end
 
-  defp exec_cmd(handler, mod, caller, %Command{type: "script", command: script}, args) do
+  defp exec_cmd(handler, mod, caller, %Command{type: "script", command: script} = command, args) do
     tmp_file = Path.join([@default_temporal_dir, random_string()])
 
     sh =
@@ -490,7 +518,8 @@ defmodule Hemdal.Host do
 
     mod.write_file(handler, tmp_file, script)
     cmd = Enum.join([sh, tmp_file | args], " ")
-    mod.exec_interactive(handler, cmd, caller)
+    opts = [output: command.output, timeout: command.idle_timeout]
+    mod.exec_interactive(handler, cmd, caller, opts)
   end
 
   @typedoc """
@@ -552,13 +581,31 @@ defmodule Hemdal.Host do
   """
   @callback exec(handler(), command()) :: {:ok, errorlevel(), output()} | {:error, reason()}
 
+  @typedoc """
+  The options for `exec_interactive/4` and `shell/2` let us define if we want to
+  accumulate the output (it's usually not desirable for shell sessions) and the
+  timeout for idle. It means the time it wait between interactions to close the
+  communication.
+  """
+  @type exec_mod_opts() :: [
+          output: boolean(),
+          timeout: timeout()
+        ]
+
   @doc """
   Exec an interactive command implemented by the module where it's
   implemented. The `c:exec_interactive/3` command is getting a handler from the
   transaction and the command to be executed as a string.
   """
-  @callback exec_interactive(handler(), command(), pid()) ::
-              {:ok, errorlevel(), output()} | {:error, reason()}
+  @callback exec_interactive(handler(), command(), pid(), exec_mod_opts()) ::
+              {:ok, pid()} | {:ok, errorlevel(), output()} | {:error, reason()}
+
+  @doc """
+  Start a shell and connect to it. The shell usually has specific features that let
+  us to do more than in normal or usual exec commands.
+  """
+  @callback shell(handler(), pid(), exec_mod_opts()) ::
+              {:ok, pid()} | {:ok, errorlevel(), output()} | {:error, reason()}
 
   @doc """
   Write a file in the remote (or local) host. It's intended to write the

lib/hemdal/host/local.ex

@@ -8,6 +8,8 @@ defmodule Hemdal.Host.Local do
   """
   use Hemdal.Host
 
+  @default_idle_timeout :timer.minutes(1)
+
   @impl Hemdal.Host
   @doc """
   Run locally a command. It's using `System.shell/2` for achieving that.
@@ -18,33 +20,51 @@ defmodule Hemdal.Host.Local do
   end
 
   @impl Hemdal.Host
-  def exec_interactive(_opts, command, caller) when is_pid(caller) do
+  def exec_interactive(_opts, command, caller, opts) when is_pid(caller) do
     port = Port.open({:spawn, command}, [:binary])
     send(caller, {:start, self()})
-    get_and_send_all(port, caller, "")
+    output = if(opts[:output], do: "")
+    opts = [{:echo, false} | opts]
+    get_and_send_all(port, caller, output, opts)
+  end
+
+  @impl Hemdal.Host
+  def shell(_opts, caller, opts) when is_pid(caller) do
+    port = Port.open({:spawn, opts[:command]}, [:binary])
+    send(caller, {:start, self()})
+    output = if(opts[:output], do: "")
+    opts = [{:echo, true} | opts]
+    get_and_send_all(port, caller, output, opts)
   end
 
-  defp get_and_send_all(port, pid, output) do
+  defp get_and_send_all(port, caller, output, opts) do
     receive do
       {:data, data} ->
         send(port, {self(), {:command, data}})
-        get_and_send_all(port, pid, output)
 
-      :close ->
-        send(port, {self(), :close})
-        get_and_send_all(port, pid, output)
+        if opts[:echo] do
+          send(caller, {:continue, data})
+          get_and_send_all(port, caller, output <> data, opts)
+        else
+          get_and_send_all(port, caller, output, opts)
+        end
 
       {^port, {:data, data}} ->
-        send(pid, {:continue, data})
-        get_and_send_all(port, pid, output <> data)
+        send(caller, {:continue, data})
+        output = if(output, do: output <> data)
+        get_and_send_all(port, caller, output, opts)
+
+      :close ->
+        send(port, {self(), :close})
+        get_and_send_all(port, caller, output, opts)
 
       {^port, :closed} ->
-        send(pid, :closed)
+        send(caller, :closed)
         {:ok, 0, output}
     after
-      60_000 ->
+      opts[:timeout] || @default_idle_timeout ->
         Port.close(port)
-        send(pid, :closed)
+        send(caller, :closed)
         {:ok, 127, output}
     end
   end

mix.exs

@@ -1,7 +1,7 @@
 defmodule Hemdal.MixProject do
   use Mix.Project
 
-  @version "1.1.0"
+  @version "1.2.0"
 
   def project do
     [

test/hemdal/host_test.exs

@@ -237,4 +237,37 @@ defmodule Hemdal.HostTest do
 
     assert_receive {:ok, %{"message" => "hello world!"}}, 5_000
   end
+
+  test "run shell" do
+    assert :ok = Hemdal.Host.reload_all()
+    assert [host_id, _] = Hemdal.Host.get_all()
+
+    echo = %Hemdal.Config.Command{
+      name: "hello world!",
+      type: "shell",
+      interactive: true,
+      command: "cat"
+    }
+
+    assert {:ok, runner} = Hemdal.Host.exec_background(host_id, echo)
+    assert is_pid(runner)
+
+    assert_receive {:start, worker}
+    assert is_pid(worker)
+    refute runner != worker
+
+    send(worker, {:data, ~s|{"status": "OK",\n|})
+    assert_receive {:continue, ~s|{"status": "OK",\n|}
+    send(worker, {:data, ~s| "message": "hello world!"}\n|})
+    assert_receive {:continue, ~s| "message": "hello world!"}\n|}
+    send(worker, {:data, <<4>>})
+    assert_receive {:continue, "\x04"}
+    assert_receive {:continue, ~s|{"status": "OK",\n "message": "hello world!"}\n\x04|}
+    send(worker, :close)
+    assert_receive :closed
+
+    message = ~s|{"status": "OK",\n "message": "hello world!"}\n\x04|
+    received_message = message <> message
+    assert_receive {:error, %{"message" => ^received_message}}, 5_000
+  end
 end