Merge 54d2705 into 37c9ede

lib/process/event/cracker.ex

@@ -1,75 +1,62 @@
 defmodule Helix.Process.Event.Cracker do
   @moduledoc false
 
+  alias Ecto.Changeset
+  alias Helix.Server.Model.Server
+  alias Helix.Software.Model.SoftwareType.Cracker
   alias Helix.Process.Model.Process
   alias Helix.Process.Query.Process, as: ProcessQuery
   alias Helix.Process.Action.Process, as: ProcessAction
   alias Helix.Process.Repo
-  alias Software.Cracker.ProcessType, as: Cracker
+
   alias Helix.Software.Model.SoftwareType.Firewall.FirewallStartedEvent
   alias Helix.Software.Model.SoftwareType.Firewall.FirewallStoppedEvent
 
   def firewall_started(event = %FirewallStartedEvent{}) do
-    # ME COOKIE MONSTER
-    crackers =
-      event.gateway_id
-      |> ProcessQuery.get_processes_of_type_targeting_server("cracker")
-      |> Enum.filter(&(&1.process_data.firewall_version < event.version))
-      |> Enum.map(fn process ->
-        base_fw_version = process.process_data.firewall_version
-
-        base_cost = Cracker.firewall_additional_wu(base_fw_version)
-        new_cost = Cracker.firewall_additional_wu(event.version)
-        cost_diff = new_cost - base_cost
-
-        process_data = %{process.process_data| firewall_version: event.version}
-        objective = %{process.objective| cpu: process.objective.cpu + cost_diff}
-        objective = Map.from_struct(objective)
-        params = %{process_data: process_data, objective: objective}
-
-        Process.update_changeset(process, params)
-      end)
-
-    {:ok, gateways} = Repo.transaction fn ->
-      Enum.reduce(crackers, MapSet.new(), fn cracker, acc ->
-        Repo.update!(cracker)
-
-        MapSet.put(acc, Ecto.Changeset.get_field(cracker, :gateway_id))
-      end)
-    end
-
-    Enum.each(gateways, fn gateway ->
-      ProcessAction.reset_processes_on_server(gateway)
-    end)
+    event.gateway_id
+    |> ProcessQuery.get_processes_of_type_targeting_server("cracker")
+    |> processes_changeset(event.version)
+    |> repo_update_all()
+    |> notify_top()
   end
 
   def firewall_stopped(event = %FirewallStoppedEvent{}) do
-    crackers =
-      event.gateway_id
-      |> ProcessQuery.get_processes_of_type_targeting_server("cracker")
-      |> Enum.filter(&(&1.process_data.firewall_version == event.version))
-      |> Enum.map(fn process ->
-        firewall_cost = Cracker.firewall_additional_wu(event.version)
+    event.gateway_id
+    |> ProcessQuery.get_processes_of_type_targeting_server("cracker")
+    |> processes_changeset(event.version)
+    |> repo_update_all()
+    |> notify_top()
+  end
 
-        process_data = %{process.process_data| firewall_version: 0}
-        cpu_objective = process.objective.cpu - firewall_cost
-        objective = %{process.objective| cpu: cpu_objective}
-        objective = Map.from_struct(objective)
-        params = %{process_data: process_data, objective: objective}
+  @spec processes_changeset([Process.t], non_neg_integer) ::
+    [Changeset.t]
+  defp processes_changeset(processes, version) do
+    Enum.map(processes, fn process ->
+      objective = Cracker.objective(process.process_data, version)
 
-        Process.update_changeset(process, params)
-      end)
+      Process.update_changeset(process, %{objective: objective})
+    end)
+  end
 
-    {:ok, gateways} = Repo.transaction fn ->
-      Enum.reduce(crackers, MapSet.new(), fn cracker, acc ->
+  @spec repo_update_all([Changeset.t]) ::
+    {:ok, MapSet.t(Server.id)}
+  # Updates each changeset and accumulates uniquely their gateway
+  defp repo_update_all(changesets) do
+    Repo.transaction fn ->
+      Enum.reduce(changesets, MapSet.new(), fn cracker, acc ->
         Repo.update!(cracker)
 
-        MapSet.put(acc, Ecto.Changeset.get_field(cracker, :gateway_id))
+        gateway = Changeset.get_field(cracker, :gateway_id)
+
+        MapSet.put(acc, gateway)
       end)
     end
-
-    Enum.each(gateways, fn gateway ->
-      ProcessAction.reset_processes_on_server(gateway)
-    end)
   end
+
+  @spec notify_top({:ok, MapSet.t(Server.id)}) ::
+    :ok
+  # Notifies each top from the now-updated crackers to recalculate everything as
+  # the objective changed
+  defp notify_top({:ok, gateways}),
+    do: Enum.each(gateways, &ProcessAction.reset_processes_on_server/1)
 end

lib/process/internal/top/server_resources.ex

@@ -184,8 +184,12 @@ defmodule Helix.Process.Internal.TOP.ServerResources do
   defp do_sum_process(server_resources, allocated, network_id) do
     net = if network_id do
       net_alloc = Map.take(allocated, [:ulk, :dlk])
-      sum_net_alloc = &Map.merge(&1, net_alloc, fn _, v1, v2 -> v1 + v2 end)
-      Map.update(server_resources.net, network_id, net_alloc, sum_net_alloc)
+      if %{ulk: 0, dlk: 0} == net_alloc do
+        server_resources.net
+      else
+        sum_net_alloc = &Map.merge(&1, net_alloc, fn _, v1, v2 -> v1 + v2 end)
+        Map.update(server_resources.net, network_id, net_alloc, sum_net_alloc)
+      end
     else
       server_resources.net
     end
@@ -278,9 +282,12 @@ defmodule Helix.Process.Internal.TOP.ServerResources do
     or a.ram > b.ram
     or not MapSet.subset?(MapSet.new(Map.keys(a)), MapSet.new(Map.keys(b)))
     or Enum.any?(a.net, fn {net_id, a} ->
-      b = b.net[net_id]
-
-      a.ulk > b.ulk or a.dlk > b.dlk
+      case b.net[net_id] do
+        nil ->
+          true
+        b ->
+          a.ulk > b.ulk or a.dlk > b.dlk
+      end
     end)
   end
 end

lib/software/action/flow/file.ex

@@ -6,9 +6,11 @@ defmodule Helix.Software.Action.Flow.File do
   alias Helix.Log.Query.Log, as: LogQuery
   alias Helix.Process.Model.Process
   alias Helix.Process.Action.Process, as: ProcessAction
+  alias Helix.Process.Query.Process, as: ProcessQuery
   alias Helix.Server.Model.Server
   alias Helix.Software.Query.File, as: FileQuery
   alias Helix.Software.Model.File
+  alias Helix.Software.Model.SoftwareType.Cracker
   alias Helix.Software.Model.SoftwareType.Firewall.Passive, as: FirewallPassive
   alias Helix.Software.Model.SoftwareType.LogForge
 
@@ -25,6 +27,8 @@ defmodule Helix.Software.Action.Flow.File do
     server = Server.ID.cast!(server)
 
     case file do
+      %File{software_type: :cracker} ->
+        cracker(file, server, params)
       %File{software_type: :firewall} ->
         firewall(file, server, params)
       %File{software_type: :log_forger} ->
@@ -34,11 +38,64 @@ defmodule Helix.Software.Action.Flow.File do
     end
   end
 
+  @spec cracker(File.t_of_type(:cracker), Server.id, Cracker.create_params) ::
+    {:ok, Process.t}
+    | ProcessAction.on_create_error
+    | {:error, Cracker.changeset}
+  defp cracker(file, server, params) do
+    flowing do
+      with \
+        {:ok, data, firewall} <- cracker_prepare(file, params),
+        {:ok, process_params} <- cracker_process_params(data, server, firewall),
+        {:ok, process, events} <- ProcessAction.create(process_params),
+        on_success(fn -> Event.emit(events) end)
+      do
+        {:ok, process}
+      end
+    end
+  end
+
+  @spec cracker_prepare(File.t_of_type(:cracker), Cracker.create_params) ::
+    {:ok, Cracker.t, non_neg_integer}
+    | {:error, Cracker.changeset}
+  defp cracker_prepare(file, params) do
+    target_firewall = fn server_id ->
+      ProcessQuery.get_running_processes_of_type_on_server(
+        server_id,
+        "firewall_passive")
+    end
+
+    with {:ok, cracker} <- file |> load_modules() |> Cracker.create(params) do
+      case target_firewall.(cracker.target_server_id) do
+        [] ->
+          {:ok, cracker, 0}
+        [%{process_data: %{version: v}}] ->
+          {:ok, cracker, v}
+      end
+    end
+  end
+
+  @spec cracker_process_params(Cracker.t, Server.id, non_neg_integer) ::
+    {:ok, Process.create_params}
+  defp cracker_process_params(cracker, server_id, firewall) do
+    params = %{
+      gateway_id: server_id,
+      target_server_id: cracker.target_server_id,
+      network_id: cracker.network_id,
+      objective: Cracker.objective(cracker, firewall),
+      process_data: cracker,
+      process_type: "cracker"
+    }
+
+    {:ok, params}
+  end
+
   @spec firewall(File.t_of_type(:firewall), Server.id, map) ::
-    term
+    {:ok, Process.t}
+    | ProcessAction.on_create_error
   defp firewall(file, server, _) do
-    %{firewall_passive: version} = FileQuery.get_modules(file)
-    process_data = %FirewallPassive{version: version}
+    file = load_modules(file)
+    process_data = %FirewallPassive{version: file.file_modules.firewall_passive}
 
     params = %{
       gateway_id: server,
@@ -50,7 +107,7 @@ defmodule Helix.Software.Action.Flow.File do
 
     event = %FirewallStartedEvent{
       gateway_id: server,
-      version: version
+      version: file.file_modules.firewall_passive
     }
 
     flowing do
@@ -82,11 +139,18 @@ defmodule Helix.Software.Action.Flow.File do
     end
   end
 
+  @spec log_forger_prepare(File.t_of_type(:log_forger), LogForge.create_params) ::
+    {:ok, LogForge.t}
+    | {:error, Ecto.Changeset.t}
   defp log_forger_prepare(file, params) do
-    modules = FileQuery.get_modules(file)
-    LogForge.create(params, modules)
+    file
+    |> load_modules()
+    |> LogForge.create(params)
   end
 
+  @spec log_forger_process_params(File.t_of_type(:log_forger), Server.id, LogForge.t) ::
+    {:ok, Process.create_params}
+    | {:error, {:log, :notfound}}
   defp log_forger_process_params(file, server, data = %{operation: "edit"}) do
     with \
       log_id = data.target_log_id,
@@ -122,4 +186,8 @@ defmodule Helix.Software.Action.Flow.File do
 
     {:ok, process_params}
   end
+
+  # FIXME: this will be removed when file modules become just an attribute
+  defp load_modules(file),
+    do: %{file| file_modules: FileQuery.get_modules(file)}
 end

lib/software/model/file.ex

@@ -29,6 +29,8 @@ defmodule Helix.Software.Model.File do
     updated_at: NaiveDateTime.t
   }
 
+  @type changeset :: %Changeset{data: %__MODULE__{}}
+
   @type creation_params :: %{
     name: String.t,
     path: String.t,