1.0.4 - interactive commands

Author: manuel-rubio

config/config.exs

@@ -0,0 +1,7 @@
+import Config
+
+if config_env() == :dev do
+  config :hemdal, :config_module, Hemdal.Config.Backend.Env
+
+  config :hemdal, Hemdal.Config, []
+end

lib/hemdal/config/alert.ex

@@ -44,10 +44,11 @@ defmodule Hemdal.Config.Alert do
       each alert. The data used is:
 
       - `name` the name of the script.
-      - `type` the type of the script could be `line` or `script`. The first
-        one let us define a command in a single line and the last one let us
-        define a script, a multi-line code which will be copied and executed
-        in the host.
+      - `type` the type of the script could be `line`, `script` or
+        `interactive`. 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.
       - `command` as the command line to be executed. It could be only one line
         or a multi-line script.
       """

lib/hemdal/event/log.ex

@@ -57,11 +57,11 @@ defmodule Hemdal.Event.Log do
   end
 
   defp get_message(event, :ok, :ok) do
-    "sucessful run #{event.alert.name} on #{event.alert.host.name}"
+    "successful run #{event.alert.name} on #{event.alert.host.name}"
   end
 
   defp get_message(event, :ok, :warn) do
-    "sucessful again run #{event.alert.name} on #{event.alert.host.name} after #{event.fail_duration || "unknown"} sec"
+    "successful again run #{event.alert.name} on #{event.alert.host.name} after #{event.fail_duration || "unknown"} sec"
   end
 
   defp get_message(event, :ok, :error) do

lib/hemdal/host.ex

@@ -398,6 +398,10 @@ defmodule Hemdal.Host do
     end
   end
 
+  defp exec_cmd(handler, mod, %Command{type: "interactive", command: command}, [pid]) do
+    mod.exec_interactive(handler, command, pid)
+  end
+
   @typedoc """
   Handler is used by the backend implementation of the host, it could be
   whatever depending on the needs of the backend implementation. For
@@ -452,11 +456,19 @@ defmodule Hemdal.Host do
 
   @doc """
   Exec a command using the method implemented by the module where it's
-  implemented. The `exec/2` command is getting a handler from the transaction
+  implemented. The `c:exec/2` command is getting a handler from the transaction
   and the command to be executed as a string.
   """
   @callback exec(handler(), command()) :: {:ok, errorlevel(), output()} | {:error, reason()}
 
+  @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()}
+
   @doc """
   Write a file in the remote (or local) host. It's intended to write the
   scripts which will be needed to be executed after that with `exec/2`.
@@ -466,7 +478,7 @@ defmodule Hemdal.Host do
 
   @doc """
   Remove a file which was created with `write_file/3` when the execution of
-  the script was finalised.
+  the script was finalized.
   """
   @callback delete(handler(), tpm_file :: charlist()) :: :ok | {:error, reason()}
 

lib/hemdal/host/local.ex

@@ -17,6 +17,38 @@ defmodule Hemdal.Host.Local do
     {:ok, errorlevel, output}
   end
 
+  @impl Hemdal.Host
+  def exec_interactive(_opts, command, pid) do
+    port = Port.open({:spawn, command}, [:binary])
+    send(pid, {:start, self()})
+    get_and_send_all(port, pid, "")
+  end
+
+  defp get_and_send_all(port, pid, output) 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)
+
+      {^port, {:data, data}} ->
+        send(pid, {:continue, data})
+        get_and_send_all(port, pid, output <> data)
+
+      {^port, :closed} ->
+        send(pid, :closed)
+        {:ok, 0, output}
+    after
+      60_000 ->
+        Port.close(port)
+        send(pid, :closed)
+        {:ok, 127, output}
+    end
+  end
+
   @impl Hemdal.Host
   @doc """
   Write a file locally, the file is intended to be located in a temporal

mix.exs

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

test/hemdal/host_test.exs

@@ -95,4 +95,45 @@ defmodule Hemdal.HostTest do
       78eb75f9-2ac7-434c-a1a2-330b23c89982
     ] == Hemdal.Host.get_all()
   end
+
+  test "run shell command" do
+    assert :ok = Hemdal.Host.reload_all()
+    assert [host_id, _] = Hemdal.Host.get_all()
+
+    echo = %Hemdal.Config.Alert.Command{
+      name: "hello world!",
+      type: "line",
+      command: ~s|echo '{"status": "OK", "message": "hello world!"}'|
+    }
+
+    assert {:ok, %{"message" => "hello world!"}} = Hemdal.Host.exec(host_id, echo, [])
+  end
+
+  test "run interactive shell command" do
+    assert :ok = Hemdal.Host.reload_all()
+    assert [host_id, _] = Hemdal.Host.get_all()
+
+    echo = %Hemdal.Config.Alert.Command{
+      name: "hello world!",
+      type: "interactive",
+      command: "cat"
+    }
+
+    pid =
+      spawn_link(fn ->
+        pid =
+          receive do
+            {:start, pid} -> pid
+          end
+
+        send(pid, {:data, ~s|{"status": "OK",\n|})
+        assert_receive {:continue, ~s|{"status": "OK",\n|}
+        send(pid, {:data, ~s| "message": "hello world!"}\n|})
+        assert_receive {:continue, ~s| "message": "hello world!"}\n|}
+        send(pid, :close)
+        assert_receive :closed
+      end)
+
+    assert {:ok, %{"message" => "hello world!"}} = Hemdal.Host.exec(host_id, echo, [pid])
+  end
 end