Trigger software updates process in event handler

lib/trento/event_handlers_supervisor.ex

@@ -6,6 +6,7 @@ defmodule Trento.EventHandlersSupervisor do
   alias Trento.Infrastructure.Commanded.EventHandlers.{
     AlertsEventHandler,
     RollUpEventHandler,
+    SoftwareUpdatesDiscoveryEventHandler,
     StreamRollUpEventHandler
   }
 
@@ -18,7 +19,8 @@ defmodule Trento.EventHandlersSupervisor do
     children = [
       AlertsEventHandler,
       RollUpEventHandler,
-      StreamRollUpEventHandler
+      StreamRollUpEventHandler,
+      SoftwareUpdatesDiscoveryEventHandler
     ]
 
     Supervisor.init(children, strategy: :one_for_one)

lib/trento/hosts/host.ex

@@ -76,7 +76,6 @@ defmodule Trento.Hosts.Host do
     CompleteHostChecksExecution,
     CompleteSoftwareUpdatesDiscovery,
     DeregisterHost,
-    DiscoverSoftwareUpdates,
     RegisterHost,
     RequestHostDeregistration,
     RollUpHost,
@@ -106,8 +105,7 @@ defmodule Trento.Hosts.Host do
     SaptuneStatusUpdated,
     SlesSubscriptionsUpdated,
     SoftwareUpdatesDiscoveryCleared,
-    SoftwareUpdatesDiscoveryCompleted,
-    SoftwareUpdatesDiscoveryRequested
+    SoftwareUpdatesDiscoveryCompleted
   }
 
   @required_fields []
@@ -538,19 +536,6 @@ defmodule Trento.Hosts.Host do
 
   # Software Updates Discovery
 
-  def execute(
-        %Host{
-          host_id: host_id,
-          fully_qualified_domain_name: fully_qualified_domain_name
-        },
-        %DiscoverSoftwareUpdates{}
-      ) do
-    %SoftwareUpdatesDiscoveryRequested{
-      host_id: host_id,
-      fully_qualified_domain_name: fully_qualified_domain_name
-    }
-  end
-
   def execute(
         %Host{host_id: host_id} = host,
         %CompleteSoftwareUpdatesDiscovery{
@@ -737,8 +722,6 @@ defmodule Trento.Hosts.Host do
     }
   end
 
-  def apply(%Host{} = host, %SoftwareUpdatesDiscoveryRequested{}), do: host
-
   def apply(
         %Host{} = host,
         %SoftwareUpdatesDiscoveryCompleted{

lib/trento/infrastructure/commanded/event_handlers/software_updates_discovery_event_handler.ex

@@ -0,0 +1,94 @@
+defmodule Trento.Infrastructure.Commanded.EventHandlers.SoftwareUpdatesDiscoveryEventHandler do
+  @moduledoc """
+  Event handler for software updates discovery related events.
+
+  It triggers the process of discovering software updates for a host when:
+  - a host gets registered
+  - the fqdn of a host changes
+  - when a host gets restored after being deregistered
+  """
+
+  use Commanded.Event.Handler,
+    application: Trento.Commanded,
+    name: "software_updates_discovery_event_handler"
+
+  require Logger
+
+  alias Trento.Hosts.Events.{
+    HostDetailsUpdated,
+    HostRegistered,
+    HostRestored
+  }
+
+  alias Trento.Hosts
+  alias Trento.Hosts.Projections.HostReadModel
+  alias Trento.SoftwareUpdates.Discovery
+
+  def handle(
+        %HostRegistered{
+          host_id: host_id,
+          fully_qualified_domain_name: fully_qualified_domain_name
+        },
+        _
+      )
+      when not is_nil(fully_qualified_domain_name) do
+    Discovery.discover_host_software_updates(host_id, fully_qualified_domain_name)
+    :ok
+  end
+
+  def handle(%HostRestored{host_id: host_id}, _) do
+    case Hosts.get_host_by_id(host_id) do
+      %HostReadModel{id: host_id, fully_qualified_domain_name: fully_qualified_domain_name} ->
+        Discovery.discover_host_software_updates(host_id, fully_qualified_domain_name)
+
+      nil ->
+        Logger.error("Host not found: #{host_id}")
+    end
+
+    :ok
+  end
+
+  def handle(
+        %HostDetailsUpdated{
+          host_id: host_id,
+          fully_qualified_domain_name: new_fully_qualified_domain_name
+        },
+        _
+      ) do
+    case Hosts.get_host_by_id(host_id) do
+      %HostReadModel{
+        id: host_id,
+        fully_qualified_domain_name: current_fully_qualified_domain_name
+      } ->
+        discover_or_clear_software_updates(
+          host_id,
+          current_fully_qualified_domain_name,
+          new_fully_qualified_domain_name
+        )
+
+      nil ->
+        Logger.error("Host not found: #{host_id}")
+    end
+
+    :ok
+  end
+
+  defp discover_or_clear_software_updates(
+         host_id,
+         current_fully_qualified_domain_name,
+         new_fully_qualified_domain_name
+       )
+       when current_fully_qualified_domain_name != new_fully_qualified_domain_name and
+              is_nil(new_fully_qualified_domain_name),
+       do: Discovery.clear_host_software_updates_discovery(host_id)
+
+  defp discover_or_clear_software_updates(
+         host_id,
+         current_fully_qualified_domain_name,
+         new_fully_qualified_domain_name
+       )
+       when current_fully_qualified_domain_name != new_fully_qualified_domain_name,
+       do: Discovery.discover_host_software_updates(host_id, new_fully_qualified_domain_name)
+
+  defp discover_or_clear_software_updates(_, _, _), do: nil
+end

lib/trento/router.ex

@@ -16,7 +16,6 @@ defmodule Trento.Router do
     CompleteHostChecksExecution,
     CompleteSoftwareUpdatesDiscovery,
     DeregisterHost,
-    DiscoverSoftwareUpdates,
     RegisterHost,
     RequestHostDeregistration,
     RollUpHost,
@@ -56,7 +55,6 @@ defmodule Trento.Router do
              RequestHostDeregistration,
              DeregisterHost,
              CompleteHostChecksExecution,
-             DiscoverSoftwareUpdates,
              CompleteSoftwareUpdatesDiscovery,
              ClearSoftwareUpdatesDiscovery
            ],

lib/trento/software_updates/discovery.ex

@@ -41,7 +41,12 @@ defmodule Trento.SoftwareUpdates.Discovery do
     do:
       {:ok,
        Hosts.get_all_hosts()
-       |> Enum.map(&discover_host_software_updates/1)
+       |> Enum.map(fn %HostReadModel{
+                        id: host_id,
+                        fully_qualified_domain_name: fully_qualified_domain_name
+                      } ->
+         discover_host_software_updates(host_id, fully_qualified_domain_name)
+       end)
        |> Enum.split_with(fn
          {:ok, _, _, _} -> true
          _ -> false
@@ -52,12 +57,8 @@ defmodule Trento.SoftwareUpdates.Discovery do
     hosts = Hosts.get_all_hosts()
 
     hosts
-    |> Enum.map(fn %HostReadModel{id: host_id} -> %{host_id: host_id} end)
-    |> Enum.each(fn command_payload ->
-      command_payload
-      |> ClearSoftwareUpdatesDiscovery.new!()
-      |> commanded().dispatch()
-    end)
+    |> Enum.map(fn %HostReadModel{id: host_id} -> host_id end)
+    |> Enum.each(&clear_host_software_updates_discovery/1)
 
     if !Enum.empty?(hosts) do
       clear()
@@ -66,18 +67,27 @@ defmodule Trento.SoftwareUpdates.Discovery do
     :ok
   end
 
-  defp discover_host_software_updates(%HostReadModel{
-         id: host_id,
-         fully_qualified_domain_name: nil
-       }) do
+  def clear_host_software_updates_discovery(host_id),
+    do:
+      %{host_id: host_id}
+      |> ClearSoftwareUpdatesDiscovery.new!()
+      |> commanded().dispatch()
+
+  @spec discover_host_software_updates(String.t(), String.t()) ::
+          {:ok, any()} | {:error, any(), any()}
+  def discover_host_software_updates(host_id, fully_qualified_domain_name)
+      when is_nil(fully_qualified_domain_name) do
     Logger.info("Host #{host_id} does not have an fqdn. Skipping software updates discovery")
     {:error, host_id, :host_without_fqdn}
   end
 
-  defp discover_host_software_updates(%HostReadModel{
-         id: host_id,
-         fully_qualified_domain_name: fully_qualified_domain_name
-       }) do
+  @spec discover_host_software_updates(String.t(), String.t()) ::
+          {:ok, any()} | {:error, any()}
+  def discover_host_software_updates(_, nil), do: {:error, :host_without_fqdn}
+
+  @spec discover_host_software_updates(String.t(), String.t()) ::
+          {:ok, any()} | {:error, any()}
+  def discover_host_software_updates(host_id, fully_qualified_domain_name) do
     with {:ok, system_id} <- get_system_id(fully_qualified_domain_name),
          {:ok, relevant_patches} <- get_relevant_patches(system_id),
          :ok <-

test/support/factory.ex

@@ -35,6 +35,7 @@ defmodule Trento.Factory do
     HostDetailsUpdated,
     HostHealthChanged,
     HostRegistered,
+    HostRestored,
     HostSaptuneHealthChanged,
     HostTombstoned,
     SaptuneStatusUpdated,
@@ -139,6 +140,12 @@ defmodule Trento.Factory do
     }
   end
 
+  def host_restored_event_factory do
+    %HostRestored{
+      host_id: Faker.UUID.v4()
+    }
+  end
+
   def host_factory do
     %HostReadModel{
       id: Faker.UUID.v4(),

test/trento/hosts/host_test.exs

@@ -8,7 +8,6 @@ defmodule Trento.Hosts.HostTest do
     CompleteHostChecksExecution,
     CompleteSoftwareUpdatesDiscovery,
     DeregisterHost,
-    DiscoverSoftwareUpdates,
     RegisterHost,
     RequestHostDeregistration,
     RollUpHost,
@@ -38,8 +37,7 @@ defmodule Trento.Hosts.HostTest do
     SaptuneStatusUpdated,
     SlesSubscriptionsUpdated,
     SoftwareUpdatesDiscoveryCleared,
-    SoftwareUpdatesDiscoveryCompleted,
-    SoftwareUpdatesDiscoveryRequested
+    SoftwareUpdatesDiscoveryCompleted
   }
 
   alias Trento.Hosts.ValueObjects.{
@@ -1410,7 +1408,6 @@ defmodule Trento.Hosts.HostTest do
   describe "software updates discovery" do
     test "should not accept software updates discovery commands if a host is not registered yet" do
       commands = [
-        %DiscoverSoftwareUpdates{host_id: Faker.UUID.v4()},
         %CompleteSoftwareUpdatesDiscovery{host_id: Faker.UUID.v4()},
         %ClearSoftwareUpdatesDiscovery{host_id: Faker.UUID.v4()}
       ]
@@ -1420,37 +1417,6 @@ defmodule Trento.Hosts.HostTest do
       end
     end
 
-    test "should trigger the software updates discovery process" do
-      host_id = Faker.UUID.v4()
-      fully_qualified_domain_name = Faker.Internet.domain_name()
-
-      initial_events = [
-        build(:host_registered_event,
-          host_id: host_id,
-          fully_qualified_domain_name: fully_qualified_domain_name
-        ),
-        build(:heartbeat_succeded, host_id: host_id)
-      ]
-
-      assert_events_and_state(
-        initial_events,
-        DiscoverSoftwareUpdates.new!(%{
-          host_id: host_id
-        }),
-        %SoftwareUpdatesDiscoveryRequested{
-          host_id: host_id,
-          fully_qualified_domain_name: fully_qualified_domain_name
-        },
-        fn host ->
-          assert %Host{
-                   host_id: ^host_id,
-                   fully_qualified_domain_name: ^fully_qualified_domain_name,
-                   heartbeat: Health.passing()
-                 } = host
-        end
-      )
-    end
-
     defp get_host_health_changed_event(host_id, scenario) do
       case Map.get(scenario, :expect_host_health_changed, true) do
         true ->
@@ -1762,7 +1728,6 @@ defmodule Trento.Hosts.HostTest do
             vpc_id: "vpc-12345"
           }
         }),
-        DiscoverSoftwareUpdates.new!(%{host_id: host_id}),
         RollUpHost.new!(%{
           host_id: host_id
         })
@@ -1946,7 +1911,6 @@ defmodule Trento.Hosts.HostTest do
         %UpdateHeartbeat{host_id: host_id},
         %UpdateProvider{host_id: host_id},
         %UpdateSlesSubscriptions{host_id: host_id},
-        %DiscoverSoftwareUpdates{host_id: host_id},
         %CompleteSoftwareUpdatesDiscovery{host_id: host_id},
         %ClearSoftwareUpdatesDiscovery{host_id: host_id},
         %SelectHostChecks{host_id: host_id}