Merge 5aa3209 into 478ae6b

config/account/test.exs

@@ -6,4 +6,5 @@ config :bcrypt_elixir, :log_rounds, 2
 
 config :helix, Helix.Account.Repo,
   pool: Ecto.Adapters.SQL.Sandbox,
-  database: prefix <> "_test_account"
+  database: prefix <> "_test_account",
+  ownership_timeout: 90_000

config/cache/test.exs

@@ -4,4 +4,5 @@ prefix = System.get_env("HELIX_DB_PREFIX") || "helix"
 
 config :helix, Helix.Cache.Repo,
   pool: Ecto.Adapters.SQL.Sandbox,
-  database: prefix <> "_test_cache"
+  database: prefix <> "_test_cache",
+  ownership_timeout: 90_000

config/core/test.exs

@@ -4,4 +4,5 @@ prefix = System.get_env("HELIX_DB_PREFIX") || "helix"
 
 config :helix, Helix.Core.Repo,
   pool: Ecto.Adapters.SQL.Sandbox,
-  database: prefix <> "_test_core"
+  database: prefix <> "_test_core",
+  ownership_timeout: 90_000

config/entity/test.exs

@@ -4,4 +4,5 @@ prefix = System.get_env("HELIX_DB_PREFIX") || "helix"
 
 config :helix, Helix.Entity.Repo,
   pool: Ecto.Adapters.SQL.Sandbox,
-  database: prefix <> "_test_entity"
+  database: prefix <> "_test_entity",
+  ownership_timeout: 90_000

config/hardware/test.exs

@@ -4,4 +4,5 @@ prefix = System.get_env("HELIX_DB_PREFIX") || "helix"
 
 config :helix, Helix.Hardware.Repo,
   pool: Ecto.Adapters.SQL.Sandbox,
-  database: prefix <> "_test_hardware"
+  database: prefix <> "_test_hardware",
+  ownership_timeout: 90_000

config/log/test.exs

@@ -4,4 +4,5 @@ prefix = System.get_env("HELIX_DB_PREFIX") || "helix"
 
 config :helix, Helix.Log.Repo,
   pool: Ecto.Adapters.SQL.Sandbox,
-  database: prefix <> "_test_log"
+  database: prefix <> "_test_log",
+  ownership_timeout: 90_000

config/network/test.exs

@@ -4,4 +4,5 @@ prefix = System.get_env("HELIX_DB_PREFIX") || "helix"
 
 config :helix, Helix.Network.Repo,
   pool: Ecto.Adapters.SQL.Sandbox,
-  database: prefix <> "_test_network"
+  database: prefix <> "_test_network",
+  ownership_timeout: 90_000

config/process/test.exs

@@ -4,4 +4,5 @@ prefix = System.get_env("HELIX_DB_PREFIX") || "helix"
 
 config :helix, Helix.Process.Repo,
   pool: Ecto.Adapters.SQL.Sandbox,
-  database: prefix <> "_test_process"
+  database: prefix <> "_test_process",
+  ownership_timeout: 90_000

config/server/test.exs

@@ -4,4 +4,5 @@ prefix = System.get_env("HELIX_DB_PREFIX") || "helix"
 
 config :helix, Helix.Server.Repo,
   pool: Ecto.Adapters.SQL.Sandbox,
-  database: prefix <> "_test_server"
+  database: prefix <> "_test_server",
+  ownership_timeout: 90_000

config/software/test.exs

@@ -4,4 +4,5 @@ prefix = System.get_env("HELIX_DB_PREFIX") || "helix"
 
 config :helix, Helix.Software.Repo,
   pool: Ecto.Adapters.SQL.Sandbox,
-  database: prefix <> "_test_software"
+  database: prefix <> "_test_software",
+  ownership_timeout: 90_000

config/story/test.exs

@@ -4,4 +4,5 @@ prefix = System.get_env("HELIX_DB_PREFIX") || "helix"
 
 config :helix, Helix.Story.Repo,
   pool: Ecto.Adapters.SQL.Sandbox,
-  database: prefix <> "_test_story"
+  database: prefix <> "_test_story",
+  ownership_timeout: 90_000

config/universe/test.exs

@@ -4,4 +4,5 @@ prefix = System.get_env("HELIX_DB_PREFIX") || "helix"
 
 config :helix, Helix.Universe.Repo,
   pool: Ecto.Adapters.SQL.Sandbox,
-  database: prefix <> "_test_universe"
+  database: prefix <> "_test_universe",
+  ownership_timeout: 90_000

lib/application.ex

@@ -6,7 +6,6 @@ defmodule Helix.Application do
 
   def start(_type, _args) do
     children = [
-      # worker(HELF.Broker, []),
       supervisor(Helix.Endpoint, []),
       supervisor(Helix.Application.DomainsSupervisor, [])
     ]
@@ -54,6 +53,7 @@ defmodule Helix.Application.DomainsSupervisor do
       supervisor(Helix.Account.Supervisor, []),
       supervisor(Helix.Cache.Supervisor, []),
       supervisor(Helix.Core.Supervisor, []),
+      supervisor(Helix.Event.Supervisor, []),
       supervisor(Helix.Entity.Supervisor, []),
       supervisor(Helix.Hardware.Supervisor, []),
       supervisor(Helix.Log.Supervisor, []),

lib/event/dispatcher.ex

@@ -112,6 +112,22 @@ defmodule Helix.Event.Dispatcher do
   # All
   event ProcessEvent.Process.Created
   event ProcessEvent.Process.Completed
+  event ProcessEvent.Process.Signaled
+  event ProcessEvent.TOP.BringMeToLife
+  event ProcessEvent.TOP.Recalcado
+
+  # Custom handlers
+  event ProcessEvent.Process.Created,
+    ProcessHandler.TOP,
+    :recalque_handler
+
+  event ProcessEvent.TOP.BringMeToLife,
+    ProcessHandler.TOP,
+    :wake_me_up
+
+  event ProcessEvent.Process.Signaled,
+    ProcessHandler.Process,
+    :signal_handler
 
   ##############################################################################
   # Server events

lib/event/event.ex

@@ -10,6 +10,7 @@ defmodule Helix.Event do
 
   alias Helix.Event.Dispatcher, as: HelixDispatcher
   alias Helix.Event.Meta, as: EventMeta
+  alias Helix.Event.State.Timer, as: EventTimer
   alias Helix.Process.Model.Process
 
   @type t :: HELF.Event.t
@@ -85,6 +86,18 @@ defmodule Helix.Event do
   def emit(event),
     do: HelixDispatcher.emit(event)
 
+  @spec emit_after([t] | t, interval :: float | non_neg_integer) ::
+    term
+  @doc """
+  Emits the given event(s) after `interval` milliseconds have passed.
+  """
+  def emit_after([], _),
+    do: :noop
+  def emit_after(events = [_|_], interval),
+    do: Enum.each(events, &(emit_after(&1, interval)))
+  def emit_after(event, interval),
+    do: EventTimer.emit_after(event, interval)
+
   @spec inherit(t, t) ::
     t
   docp """

lib/event/state/supervisor.ex

@@ -0,0 +1,20 @@
+defmodule Helix.Event.State.Supervisor do
+
+  use Supervisor
+
+  alias Helix.Event.State.Timer, as: EventTimer
+
+  @doc false
+  def start_link do
+    Supervisor.start_link(__MODULE__, [])
+  end
+
+  @doc false
+  def init(_) do
+    children = [
+      worker(EventTimer, [])
+    ]
+
+    supervise(children, strategy: :one_for_one)
+  end
+end

lib/event/state/timer.ex

@@ -0,0 +1,44 @@
+defmodule Helix.Event.State.Timer do
+  @moduledoc """
+  `EventTimer` is responsible for handling events that were asked to be emitted
+  sometime in the future.
+  """
+
+  use GenServer
+
+  alias Helix.Event
+
+  @registry_name :event_timer
+
+  # Client API
+
+  def start_link,
+    do: GenServer.start_link(__MODULE__, [], name: @registry_name)
+
+  @spec emit_after(Event.t, interval :: float | non_neg_integer) ::
+    term
+  @doc """
+  Emits `event` after `interval` milliseconds have passed.
+
+  Unit is in milliseconds!
+  """
+  def emit_after(event, interval),
+    do: GenServer.call(@registry_name, {:emit_after, event, interval})
+
+  # Callbacks
+
+  def init(_),
+    do: {:ok, []}
+
+  def handle_call({:emit_after, event, interval}, _from, state) do
+    Process.send_after(@registry_name, {:emit, event}, interval)
+
+    {:reply, :ok, state}
+  end
+
+  def handle_info({:emit, event}, state) do
+    Event.emit(event)
+
+    {:noreply, state}
+  end
+end

lib/event/supervisor.ex

@@ -0,0 +1,20 @@
+defmodule Helix.Event.Supervisor do
+
+  use Supervisor
+
+  alias Helix.Event.State.Supervisor, as: StateSupervisor
+
+  @doc false
+  def start_link do
+    Supervisor.start_link(__MODULE__, [])
+  end
+
+  @doc false
+  def init(_) do
+    children = [
+      supervisor(StateSupervisor, [])
+    ]
+
+    supervise(children, strategy: :one_for_one)
+  end
+end

lib/hardware/internal/motherboard.ex

@@ -35,7 +35,7 @@ defmodule Helix.Hardware.Internal.Motherboard do
     end
   end
 
-  @spec fetch_by_nip(Network.id, NetworkConnection.ip) ::
+  @spec fetch_by_nip(Network.id, Network.ip) ::
     Motherboard.t
     | nil
   def fetch_by_nip(network_id, ip) do
@@ -102,38 +102,33 @@ defmodule Helix.Hardware.Internal.Motherboard do
     |> get_hdds_from_ids()
   end
 
-  defp get_cpus_from_ids(components) do
+  def get_cpus_from_ids(components) do
     components
     |> Component.CPU.Query.from_components_ids()
     |> Repo.all()
   end
 
-  defp get_rams_from_ids(components) do
+  def get_rams_from_ids(components) do
     components
     |> Component.RAM.Query.from_components_ids()
     |> Repo.all()
   end
 
-  defp get_nics_from_ids(components) do
+  def get_nics_from_ids(components) do
     components
     |> Component.NIC.Query.from_components_ids()
     |> Component.NIC.Query.inner_join_network_connection()
     |> Repo.all()
   end
 
-  defp get_hdds_from_ids(components) do
+  def get_hdds_from_ids(components) do
     components
     |> Component.HDD.Query.from_components_ids()
     |> Repo.all()
   end
 
   @spec resources(Motherboard.t) ::
-    %{
-      cpu: non_neg_integer,
-      ram: non_neg_integer,
-      hdd: non_neg_integer,
-      net: %{String.t => %{uplink: non_neg_integer, downlink: non_neg_integer}}
-    }
+    Motherboard.resources
   def resources(motherboard) do
     components_ids = get_components_ids(motherboard)
 
@@ -155,7 +150,7 @@ defmodule Helix.Hardware.Internal.Motherboard do
       components_ids
       |> get_nics_from_ids()
       |> Enum.reduce(%{}, fn el, acc ->
-        network = to_string(el.network_connection.network_id)
+        network = el.network_connection.network_id
         value = Map.take(el.network_connection, [:uplink, :downlink])
 
         sum_map_values = &Map.merge(&1, value, fn _, v1, v2 -> v1 + v2 end)

lib/hardware/internal/network_connection.ex

@@ -42,7 +42,7 @@ defmodule Helix.Hardware.Internal.NetworkConnection do
     end
   end
 
-  @spec update_ip(NetworkConnection.t | NetworkConnection.id, NetworkConnection.ip) ::
+  @spec update_ip(NetworkConnection.idt, NetworkConnection.ip) ::
     {:ok, NetworkConnection}
     | {:error, Ecto.Changeset.t}
   def update_ip(nc = %NetworkConnection{}, new_ip) do

lib/hardware/model/motherboard.ex

@@ -5,6 +5,7 @@ defmodule Helix.Hardware.Model.Motherboard do
   import Ecto.Changeset
 
   alias Ecto.Changeset
+  alias Helix.Network.Model.Network
   alias Helix.Hardware.Model.Component
   alias Helix.Hardware.Model.ComponentSpec
   alias Helix.Hardware.Model.MotherboardSlot
@@ -23,6 +24,20 @@ defmodule Helix.Hardware.Model.Motherboard do
     updated_at: NaiveDateTime.t
   }
 
+  @type resources ::
+    %{
+      cpu: non_neg_integer,
+      ram: non_neg_integer,
+      hdd: non_neg_integer,
+      net: %{
+        Network.id =>
+        %{
+          uplink: non_neg_integer,
+          downlink: non_neg_integer
+        }
+      }
+    }
+
   @primary_key false
   schema "motherboards" do
     field :motherboard_id, Component.ID,

lib/hell/hack.ex

@@ -41,11 +41,9 @@ defmodule HELL.Hack.Experience do
         {:join, 3}
       ],
       "Elixir.Helix.Process.Model.Processable" => [
-        {:dynamic_resources, 1},
-        {:state_change, 4},
         {:kill, 3},
-        {:minimum, 1},
-        {:conclusion, 2},
+        {:complete, 2},
+        {:connection_closed, 3},
         {:after_read_hook, 1}
       ],
       "Elixir.Helix.Process.Public.View.ProcessViewable" => [

lib/process/model/process/naive_struct.ex → lib/hell/hell/naive_struct.ex

@@ -1,9 +1,5 @@
-defmodule Helix.Process.Model.Process.NaiveStruct do
-  @moduledoc false
-
-  import HELL.Macros
-
-  docp """
+defmodule HELL.NaiveStruct do
+  @moduledoc """
   This module is a converter that transforms any struct into a non-struct map
   (while keeping the metadata of which struct that map was) and transforms that
   map back into it's original struct on runtime.

lib/log/event/handler/log.ex

@@ -38,7 +38,7 @@ defmodule Helix.Log.Event.Handler.Log do
 
   def log_forge_conclusion(event = %LogForgeCreateComplete{}) do
     {:ok, _, events} = LogAction.create(
-      event.target_server_id,
+      event.target_id,
       event.entity_id,
       event.message,
       event.version)