lib/freedive/api/service/cli.ex

@@ -4,81 +4,68 @@ defmodule Freedive.Api.Service.Cli do
   """
   require Logger
   import Freedive.Api.Command
-  import Freedive.Api.Service.Icons
 
   @service_bin "/usr/sbin/service"
-  @skip_service_names ["DAEMON", "FILESYSTEMS", "LOGIN", "NETWORKING", "SERVERS"]
 
-  def list_services!() do
-    all_service_names = all_service_names()
-    enabled_service_names = enabled_service_names()
-
-    all_service_names
-    |> Enum.map(fn name -> service_details(name, Enum.member?(enabled_service_names, name)) end)
-    |> Enum.into(%{}, &{&1[:name], &1})
-  end
-
-  def service_command!(name, command, args \\ []) do
-    case service(name, command, args) do
-      {:ok, stdout} ->
-        {:ok, stdout |> String.trim()}
-
-      error ->
-        error
-    end
-  end
-
-  def all_service_names() do
+  def list_services() do
     case execute(@service_bin, ["-l"]) do
       {:ok, stdout} ->
+        service_names =
           stdout
           |> String.split("\n")
           |> Enum.map(&String.trim/1)
-        |> Enum.reject(&Enum.member?(@skip_service_names, &1))
+          |> Enum.reject(
+            &Enum.member?(["DAEMON", "FILESYSTEMS", "LOGIN", "NETWORKING", "SERVERS"], &1)
+          )
 
-      {:error, reason} ->
-        Logger.error("List services: #{reason}")
-        raise "Failed to list services."
-    end
-  end
-
-  def enabled_service_names() do
         case execute(@service_bin, ["-e"]) do
           {:ok, stdout} ->
+            enabled_service_names =
               stdout
               |> String.split("\n")
               |> Enum.map(&String.trim/1)
               |> Enum.map(&Path.basename/1)
+              |> Enum.into(%{}, &{&1, true})
 
-      {:error, reason} ->
-        Logger.error("List enabled services: #{reason}")
-        raise "Failed to list enabled services."
-    end
-  end
-
-  def service_details(name, enabled \\ nil) do
-    enabled = if(enabled != nil, do: enabled, else: service_is_enabled?(name))
-
+            services =
+              service_names
+              |> Enum.map(fn name ->
                 %{
                   name: name,
-      icon: icon_for_service(name),
-      enabled: enabled,
-      running: if(enabled, do: service_is_running?(name), else: nil),
-      description: if(enabled, do: service_description!(name), else: nil),
-      commands: if(enabled, do: service_commands!(name), else: nil),
-      log: [],
-      busy: false
+                  icon: "puzzle",
+                  enabled: Map.has_key?(enabled_service_names, name),
+                  running:
+                    if Map.has_key?(enabled_service_names, name) do
+                      service_is_running?(name)
+                    else
+                      nil
+                    end,
+                  description:
+                    if Map.has_key?(enabled_service_names, name) do
+                      case service_description(name) do
+                        {:ok, desc} -> desc
+                        _ -> nil
+                      end
+                    else
+                      nil
+                    end,
+                  commands: nil,
+                  rcvars: nil
                 }
+              end)
+              |> Enum.into(%{}, &{&1[:name], &1})
+
+            {:ok, services}
+
+          {:error, {stderr, _code}} ->
+            Logger.error("list_services enabled, log: #{inspect(stderr)}")
+            {:error, stderr}
         end
 
-  def refresh(service) do
-    name = service.name
-
-    %{
-      service
-      | running: service_is_running?(name),
-        enabled: service_is_enabled?(name)
-    }
+      {:error, {stderr, _code}} ->
+        Logger.error("list_services, log: #{inspect(stderr)}")
+        {:error, stderr}
+    end
   end
 
   def service_is_running?(name, args \\ []) do
@@ -101,44 +88,24 @@ defmodule Freedive.Api.Service.Cli do
     end
   end
 
-  def service_status!(name, args \\ []) do
-    case service(name, "onestatus", args) do
-      {:ok, stdout} ->
-        stdout |> String.trim()
-
-      error ->
-        error
-    end
-  end
-
-  def service_description!(name, args \\ []) do
+  def service_description(name, args \\ []) do
     case service(name, "onedescribe", args) do
       {:ok, stdout} ->
-        stdout |> String.trim()
+        stdout = String.trim(stdout)
+        {:ok, stdout}
 
-      error ->
-        error
+      {:error, {stderr, _code}} ->
+        {:error, stderr}
     end
   end
 
-  def service_commands!(name, args \\ []) do
-    case service(name, "oneextracommands", args) do
-      {:ok, stdout} ->
-        stdout |> String.split(" ") |> Enum.map(&String.trim/1) |> Enum.reject(&(&1 == ""))
-
-      error ->
-        error
-    end
-  end
-
-  defp service(name, command, args) do
-    case execute(@service_bin, [name, command] ++ args, doas: true) do
+  defp service(name, action, args) do
+    case execute(@service_bin, [name, action] ++ args, doas: true) do
       {:ok, stdout} ->
         # Logger.debug("service, log: #{inspect(stdout)}")
         {:ok, stdout}
 
       {:error, {stderr, code}} ->
-        # Logger.warning("service #{name} #{command}: #{String.trim(stderr)}")
         {:error, {stderr, code}}
     end
   end

lib/freedive/api/service/server.ex

@@ -5,50 +5,16 @@ defmodule Freedive.Api.Service do
   use GenServer
   require Logger
   import Freedive.Api.Service.Cli
-
-  @topic "system:service"
-  @events [
-    :command,
-    :refreshed,
-    :stdlog
-  ]
+  import Freedive.Api.Service.Icons
 
   def start_link(opts) do
     GenServer.start_link(__MODULE__, opts, name: __MODULE__)
   end
 
-  def topic do
-    @topic
-  end
-
-  def events do
-    @events
-  end
-
-  def subscribe do
-    Phoenix.PubSub.subscribe(Freedive.PubSub, @topic)
-  end
-
   def list() do
     GenServer.call(__MODULE__, {:list})
   end
 
-  def start(name) do
-    GenServer.cast(__MODULE__, {:command, name, "start"})
-  end
-
-  def stop(name) do
-    GenServer.cast(__MODULE__, {:command, name, "stop"})
-  end
-
-  def restart(name) do
-    GenServer.cast(__MODULE__, {:command, name, "restart"})
-  end
-
-  def command(name, command) do
-    GenServer.cast(__MODULE__, {:command, name, command})
-  end
-
   @impl true
   def init(opts) do
     state = %{opts: opts, services: []}
@@ -58,7 +24,13 @@ defmodule Freedive.Api.Service do
 
   @impl true
   def handle_continue(_opts, state) do
-    state = %{state | services: list_services!()}
+    {:ok, services} = list_services()
+    services = services
+      |> Enum.map(fn {name, service} ->
+        {name, Map.put(service, :icon, icon_for_service(name))}
+      end)
+      |> Enum.into(%{})
+    state = %{state | services: services}
     {:noreply, state}
   end
 
@@ -67,45 +39,4 @@ defmodule Freedive.Api.Service do
     services = state[:services]
     {:reply, services, state}
   end
-
-  @impl true
-  def handle_cast({:command, name, command}, state) do
-    broadcast(:command, %{name: name, command: command})
-    broadcast(:stdlog, %{name: name, log: std_to_log("# service #{name} #{command}")})
-
-    case service_command!(name, command) do
-      {:ok, result} ->
-        broadcast(:stdlog, %{name: name, log: std_to_log(result)})
-
-      {:error, {reason, _code}} ->
-        broadcast(:stdlog, %{name: name, log: std_to_log(reason)})
-    end
-
-    if command in ["start", "stop", "restart"] do
-      broadcast(:refreshed, service_details(name))
-    end
-
-    {:noreply, state}
-  end
-
-  def broadcast(event, payload) do
-    if event in @events do
-      Phoenix.PubSub.broadcast(
-        Freedive.PubSub,
-        @topic,
-        {event,
-         Map.merge(payload, %{
-           hostname: "unknown"
-         })}
-      )
-    else
-      Logger.error("Service.Server broadcast: unknown event: #{event}")
-    end
-  end
-
-  defp std_to_log(result) do
-    (result <> "\n")
-    |> String.split("\n")
-    |> Enum.map(&String.trim/1)
-  end
 end

lib/freedive_web/live/home_live.ex

@@ -13,10 +13,6 @@ defmodule FreediveWeb.HomeLive do
     """
   end
 
-  def on_mount_connected(socket) do
-    {:ok, socket}
-  end
-
   def items() do
     %{
       "services" => %{

lib/freedive_web/live/liliform_live.ex

@@ -6,8 +6,6 @@ defmodule FreediveWeb.LiliformLive do
   defmacro __using__(opts) do
     quote location: :keep, bind_quoted: [opts: opts] do
       use FreediveWeb, :live_view
-      require Logger
-
       @behaviour FreediveWeb.LiliformLive
       @filters_all [
         %{
@@ -38,13 +36,8 @@ defmodule FreediveWeb.LiliformLive do
 
         socket = assign(socket, :filters, @filters_all ++ filters)
         socket = assign(socket, :query, "")
-
-        if connected?(socket) do
-          apply(__MODULE__, :on_mount_connected, [socket])
-        else
         {:ok, socket}
       end
-      end
 
       def(handle_event("search", %{"value" => query}, socket)) do
         filtered_items =

lib/freedive_web/live/service_live.ex

@@ -1,7 +1,6 @@
 defmodule FreediveWeb.ServiceLive do
   use FreediveWeb.LiliformLive
   alias Freedive.Api.Service
-  require Logger
 
   def render(assigns) do
     ~H"""
@@ -15,12 +14,6 @@ defmodule FreediveWeb.ServiceLive do
     """
   end
 
-  def on_mount_connected(socket) do
-    Logger.warning("Mounting ServiceLive")
-    Service.subscribe()
-    {:ok, socket}
-  end
-
   def items() do
     Service.list()
   end
@@ -49,78 +42,6 @@ defmodule FreediveWeb.ServiceLive do
     end)
     |> Enum.into(%{}, fn {name, item} -> {name, item} end)
   end
-
-  def handle_event("action:" <> action, %{"name" => service_name}, socket)
-      when action in ["start", "stop", "restart"] do
-    case action do
-      "start" -> Service.start(service_name)
-      "stop" -> Service.stop(service_name)
-      "restart" -> Service.restart(service_name)
-    end
-
-    {:noreply, socket}
-  end
-
-  def handle_event("command:" <> command, %{"name" => service_name}, socket) do
-    Service.command(service_name, command)
-    {:noreply, socket}
-  end
-
-  def handle_info({event, payload}, socket) do
-    case event do
-      :command ->
-        # Logger.info("ServiceLive: Command: #{inspect(payload)}")
-
-        socket =
-          if socket.assigns.selected_item && payload.name == socket.assigns.selected_item.name do
-            socket |> assign(:selected_item, %{socket.assigns.selected_item | busy: true})
-          else
-            socket
-          end
-
-        {:noreply, socket}
-
-      :refreshed ->
-        # Logger.info("ServiceLive: Refreshed: #{inspect(payload)}")
-
-        socket =
-          if socket.assigns.selected_item && payload.name == socket.assigns.selected_item.name do
-            socket
-            |> assign(:selected_item, %{
-              socket.assigns.selected_item
-              | running: payload.running,
-                enabled: payload.enabled,
-                busy: false
-            })
-            |> assign(:items, socket.assigns.items |> Map.put(payload.name, payload))
-          else
-            socket
-          end
-
-        {:noreply, socket}
-
-      :stdlog ->
-        # Logger.info("ServiceLive: Stdlog: #{inspect(payload)}")
-
-        socket =
-          if socket.assigns.selected_item && payload.name == socket.assigns.selected_item.name do
-            socket
-            |> assign(:selected_item, %{
-              socket.assigns.selected_item
-              | log: socket.assigns.selected_item.log ++ payload.log,
-                busy: false
-            })
-          else
-            socket
-          end
-
-        {:noreply, socket}
-
-      _ ->
-        Logger.warning("ServiceLive: Unknown event: #{event}, payload: #{inspect(payload)}")
-        {:noreply, socket}
-    end
-  end
 end
 
 defmodule FreediveWeb.ServiceLive.Components do
@@ -180,16 +101,6 @@ defmodule FreediveWeb.ServiceLive.Components do
       </:actions>
     </.panel_media>
 
-    <%= if Map.has_key?(@selected_item, :log) and @selected_item.log != [] do %>
-      <.panel_media>
-        <:icon>
-          <.icon for="terminal" color="gray" aria-hidden="true" />
-        </:icon>
-        <:actions></:actions>
-        <pre><code><%= Enum.join(@selected_item.log, "\n") %></code></pre>
-      </.panel_media>
-    <% end %>
-
     <.panel_media>
       <:icon>
         <%!-- <.icon for="terminal" color="auto" size="3rem" aria-hidden="true" /> --%>
@@ -201,31 +112,18 @@ defmodule FreediveWeb.ServiceLive.Components do
             <div class="column is-narrow">
               <button
                 class="button is-warning"
-                phx-click="action:restart"
-                phx-value-name={@selected_item.name}
-                {if @selected_item.busy, do: [disabled: true], else: []}
               >
                 Restart
               </button>
             </div>
             <div class="column">
-              <button
-                class="button is-danger"
-                phx-click="action:stop"
-                phx-value-name={@selected_item.name}
-                {if @selected_item.busy, do: [disabled: true], else: []}
-              >
+              <button class="button is-danger">
                 Stop
               </button>
             </div>
           <% else %>
             <div class="column">
-              <button
-                class="button is-success"
-                phx-click="action:start"
-                phx-value-name={@selected_item.name}
-                {if @selected_item.busy, do: [disabled: true], else: []}
-              >
+              <button class="button is-success">
                 Start
               </button>
             </div>
@@ -237,10 +135,9 @@ defmodule FreediveWeb.ServiceLive.Components do
         <%= for command <- @selected_item.commands do %>
           <button
             class="button is-info"
-            phx-disable-with="..."
-            phx-click={"command:#{command}"}
+            phx-click="command"
             phx-value-name={@selected_item.name}
-            {if @selected_item.busy, do: [disabled: true], else: []}
+            phx-value-command={command}
           >
             <%= command %>
           </button>