Merge 7abea21 into 3c19635

.gitignore

@@ -23,3 +23,7 @@ erl_crash.dump
 # xref graphs
 xref_graph.dot
 /graphs
+
+**GPATH
+**GRTAGS
+**GTAGS

lib/core/listener/event/handler/listener.ex

@@ -47,6 +47,6 @@ defmodule Helix.Core.Listener.Event.Handler.Listener do
 
     {:ok, events} = apply(module, method, params)
 
-    Event.emit(events)
+    Event.emit(events, from: event)
   end
 end

lib/core/listener/listener.ex

@@ -4,18 +4,20 @@ defmodule Helix.Core.Listener do
   events happening a specific `object_id`.
   """
 
+  import HELL.Macros
+
   alias Helix.Core.Listener.Action.Listener, as: ListenerAction
 
   @doc """
-  Subscribes to `event` on `object_id`, calling `method` as a callback once/if
+  Subscribes to `events` on `object_id`, calling `method` as a callback once/if
   the event happens.
   """
-  defmacro listen(object_id, event, method, opts) do
+  defmacro listen(object_id, events, method, opts) do
     module = __CALLER__.module
     quote do
       do_listen(
         unquote(object_id),
-        unquote(event),
+        unquote(events),
         {unquote(module), unquote(method)},
         unquote(opts)
       )
@@ -31,6 +33,8 @@ defmodule Helix.Core.Listener do
     meta = Keyword.get(opts, :meta, nil)
 
     Enum.each(events, fn event ->
+      assert_aliased(event)
+
       ListenerAction.listen(
         object_id, event, {module, method}, meta, owner_id, subscriber
       )
@@ -45,4 +49,20 @@ defmodule Helix.Core.Listener do
   """
   def unlisten(owner_id, object_id, event, subscriber),
     do: ListenerAction.unlisten(owner_id, object_id, event, subscriber)
+
+  docp """
+  `assert_aliased` makes sure that the given event has been aliased by whoever
+  is trying to subscribe to events on it. The reason being that, if not aliased,
+  the module will be able to listen on a bogus event and no warnings will be
+  emitted.
+  """
+  defp assert_aliased(event) do
+    module_depth =
+      event
+      |> Module.split()
+      |> length()
+
+    if module_depth == 1,
+      do: raise "Event #{event} isn't aliased"
+  end
 end

lib/entity/make/entity.ex

@@ -0,0 +1,10 @@
+defmodule Helix.Entity.Make.Entity do
+
+  alias Helix.Universe.NPC.Model.NPC
+  alias Helix.Entity.Action.Entity, as: EntityAction
+
+  def entity(npc = %NPC{}, _data \\ %{}) do
+    {:ok, entity} = EntityAction.create_from_specialization(npc)
+    entity
+  end
+end

lib/event/dispatcher.ex

@@ -64,8 +64,6 @@ defmodule Helix.Event.Dispatcher do
   all_events LogHandler.Log, :handle_event,
     skip: [LogEvent.Log.Created]
 
-  all_events StoryHandler, :step_handler
-
   all_events ListenerHandler, :listener_handler
 
   ##############################################################################
@@ -205,8 +203,18 @@ defmodule Helix.Event.Dispatcher do
   # All
   event StoryEvent.Email.Sent
   event StoryEvent.Reply.Sent
+  event StoryEvent.Step.ActionRequested
   event StoryEvent.Step.Proceeded
 
+  # Custom handlers
+  event StoryEvent.Reply.Sent,
+    StoryHandler,
+    :event_handler
+
+  event StoryEvent.Step.ActionRequested,
+    StoryHandler,
+    :action_handler
+
   ##############################################################################
   # Universe events
   ##############################################################################

lib/network/event/connection.ex

@@ -8,7 +8,6 @@ defmodule Helix.Network.Event.Connection do
     alias Helix.Entity.Query.Entity, as: EntityQuery
     alias Helix.Network.Model.Connection
     alias Helix.Network.Model.Tunnel
-    alias Helix.Network.Repo
 
     @type t :: %__MODULE__{
       connection: Connection.t,
@@ -21,8 +20,6 @@ defmodule Helix.Network.Event.Connection do
     @spec new(Connection.t) ::
       t
     def new(connection = %Connection{}) do
-      connection = Repo.preload(connection, :tunnel)
-
       %__MODULE__{
         connection: connection,
         tunnel: connection.tunnel,
@@ -57,7 +54,6 @@ defmodule Helix.Network.Event.Connection do
 
     alias Helix.Network.Model.Connection
     alias Helix.Network.Model.Tunnel
-    alias Helix.Network.Repo
 
     @type t :: %__MODULE__{
       connection: Connection.t,
@@ -71,8 +67,6 @@ defmodule Helix.Network.Event.Connection do
     @spec new(Connection.t, Connection.close_reasons) ::
       t
     def new(connection = %Connection{}, reason \\ :normal) do
-      connection = Repo.preload(connection, :tunnel)
-
       %__MODULE__{
         connection: connection,
         tunnel: connection.tunnel,

lib/network/internal/tunnel.ex

@@ -135,7 +135,10 @@ defmodule Helix.Network.Internal.Tunnel do
     cs = Connection.create(tunnel, connection_type, meta)
 
     with {:ok, connection} <- Repo.insert(cs) do
-      event = ConnectionStartedEvent.new(connection)
+      event =
+        connection
+        |> Repo.preload(:tunnel)
+        |> ConnectionStartedEvent.new()
 
       {:ok, connection, [event]}
     end
@@ -157,9 +160,12 @@ defmodule Helix.Network.Internal.Tunnel do
   The current reasons are valid: #{inspect Connection.close_reasons()}
   """
   def close_connection(connection = %Connection{}, reason \\ :normal) do
-    Repo.delete!(connection)
+    event =
+      connection
+      |> Repo.preload(:tunnel)
+      |> ConnectionClosedEvent.new(reason)
 
-    event = ConnectionClosedEvent.new(connection, reason)
+    Repo.delete!(connection)
 
     [event]
   end

lib/network/model/dns/anycast.ex

@@ -9,8 +9,8 @@ defmodule Helix.Network.Model.DNS.Anycast do
   @type t :: %__MODULE__{}
 
   @type creation_params :: %{
-    :name => String.t,
-    :npc_id => NPC.idtb
+    name: String.t,
+    npc_id: NPC.id
   }
 
   @one_npc_per_name :dns_anycast_npc_unique_index

lib/network/model/dns/unicast.ex

@@ -10,9 +10,9 @@ defmodule Helix.Network.Model.DNS.Unicast do
   @type t :: %__MODULE__{}
 
   @type creation_params :: %{
-    :network_id => Network.idtb,
-    :name => String.t,
-    :ip => IPv4.t
+    network_id: Network.id,
+    name: String.t,
+    ip: Network.ip
   }
 
   @one_nip_per_name :dns_unicast_nip_unique_index
@@ -23,6 +23,7 @@ defmodule Helix.Network.Model.DNS.Unicast do
   schema "dns_unicast" do
     field :network_id, Network.ID,
       primary_key: true
+
     field :name, :string,
       primary_key: true
     field :ip, IPv4
@@ -44,12 +45,12 @@ defmodule Helix.Network.Model.DNS.Unicast do
     alias Helix.Network.Model.DNS.Unicast
     alias Helix.Network.Model.Network
 
-    @spec by_net_and_name(Queryable.t, Network.idtb, String.t) ::
+    @spec by_net_and_name(Queryable.t, Network.id, String.t) ::
       Queryable.t
     def by_net_and_name(query \\ Unicast, network, name),
       do: where(query, [u], u.network_id == ^network and u.name == ^name)
 
-    @spec by_nip(Queryable.t, Network.idtb, IPv4.t) ::
+    @spec by_nip(Queryable.t, Network.id, IPv4.t) ::
       Queryable.t
     def by_nip(query \\ Unicast, network, ip),
       do: where(query, [u], u.network_id == ^network and u.ip == ^ip)

lib/network/model/net.ex

@@ -11,13 +11,13 @@ defmodule Helix.Network.Model.Net do
   defstruct [:network_id, :bounce_id]
 
   @type t ::
-  %__MODULE__{
-    network_id: Network.id,
-    bounce_id: term
-  }
+    %__MODULE__{
+      network_id: Network.id,
+      bounce_id: term
+    }
 
   @spec new(Network.id, term) ::
-  t
+    t
   def new(network_id = %Network.ID{}, bounce_id) do
     %__MODULE__{
       network_id: network_id,
@@ -26,7 +26,7 @@ defmodule Helix.Network.Model.Net do
   end
 
   @spec new(Tunnel.t) ::
-  t
+    t
   def new(tunnel = %Tunnel{}) do
     %__MODULE__{
       network_id: tunnel.network_id,

lib/network/model/network.ex

@@ -7,9 +7,10 @@ defmodule Helix.Network.Model.Network do
 
   @type t :: %__MODULE__{
     network_id: id,
-    name: String.t
+    name: name
   }
 
+  @type name :: String.t
   @type ip :: IPv4.t
 
   @type nip :: %{

lib/network/model/tunnel.ex

@@ -74,7 +74,7 @@ defmodule Helix.Network.Model.Tunnel do
     |> Enum.join("_")
   end
 
-  # TODO: Refactor this ?
+  # TODO: Refactor this ? YES PLEASE #256
   defp bounce(changeset, [gateway| bounces]) do
     set = MapSet.new([gateway])
     result = Enum.reduce_while(bounces, {[], gateway, set, 0}, fn

lib/network/model/web/player.ex

@@ -5,18 +5,21 @@ defmodule Helix.Network.Model.Web.Player do
   import Ecto.Changeset
 
   alias HELL.IPv4
+  alias Helix.Network.Model.Network
 
   @type t :: %__MODULE__{}
 
   @type creation_params :: %{
-    :ip => IPv4,
-    :content => String.t
+    ip: Network.ip,
+    content: content
   }
 
-  @creation_fields ~w/ip content/a
+  @type content :: String.t
 
   @max_content_size 2048
 
+  @creation_fields [:ip, :content]
+
   @primary_key false
   schema "webservers" do
     field :ip, IPv4,
@@ -37,10 +40,10 @@ defmodule Helix.Network.Model.Web.Player do
     import Ecto.Query, only: [where: 3]
 
     alias Ecto.Queryable
-    alias HELL.IPv4
+    alias Helix.Network.Model.Network
     alias Helix.Network.Model.Web.Player
 
-    @spec by_ip(Queryable.t, IPv4.t) ::
+    @spec by_ip(Queryable.t, Network.ip) ::
       Queryable.t
     def by_ip(query \\ Player, ip),
       do: where(query, [w], w.ip == ^ip)

lib/network/public/network.ex

@@ -2,15 +2,14 @@ defmodule Helix.Network.Public.Network do
 
   import HELL.Macros
 
-  alias HELL.IPv4
   alias Helix.Cache.Query.Cache, as: CacheQuery
   alias Helix.Entity.Query.Database, as: DatabaseQuery
   alias Helix.Entity.Query.Entity, as: EntityQuery
   alias Helix.Server.Model.Server
   alias Helix.Network.Model.Network
   alias Helix.Network.Query.Web, as: WebQuery
 
-  @spec browse(Network.idt, String.t | IPv4.t, Server.idt) ::
+  @spec browse(Network.idt, String.t | Network.ip, Server.idt) ::
     {:ok, term, relay :: %{server_id: Server.id}}
     | {:error, %{message: String.t}}
   @doc """
@@ -60,7 +59,7 @@ defmodule Helix.Network.Public.Network do
   end
 
   @spec get_origin_ip(Network.id, Server.idt) ::
-    IPv4.t
+    Network.ip
   docp """
   Internal helper to quickly figure out what is the IP address of the given
   server.

lib/network/query/web.ex

@@ -16,7 +16,7 @@ defmodule Helix.Network.Query.Web do
   @type page_owner ::
     :account
     | :clan
-    | {:npc, NPCType.types}
+    | {:npc, NPCType.type}
 
   @spec browse(Network.idt, String.t | IPv4.t, IPv4.t) ::
     {:ok, {page_owner, page_content}, IPv4.t}

lib/process/event/handler/top.ex

@@ -47,6 +47,7 @@ defmodule Helix.Process.Event.Handler.TOP do
         |> Event.emit(from: event)
 
       {false, _} ->
+        # TODO
         :todo
         # event
         # |> ProcessCreateFailedEvent.new()

lib/server/make/server.ex

@@ -0,0 +1,25 @@
+defmodule Helix.Server.Make.Server do
+
+  alias Helix.Entity.Model.Entity
+  alias Helix.Server.Action.Flow.Server, as: ServerFlow
+  alias Helix.Server.Model.Server
+
+  @type server_data ::
+    %{
+      type: Server.type
+    }
+
+  @doc """
+  Data:
+
+  - *type: Server type. `:desktop`, `:mobile`.
+  - hardware: Specs?
+  """
+  def server(entity = %Entity{}, data) do
+    if data.type != :desktop,
+      do: raise "pls wait server refactor"
+
+    {:ok, server} = ServerFlow.setup_server(entity)
+    server
+  end
+end

lib/server/model/server.ex

@@ -26,7 +26,7 @@ defmodule Helix.Server.Model.Server do
 
   @type hostname :: String.t
   @type name :: hostname
-
+  @type type :: Constant.t
   @type password :: String.t
 
   @type resources :: Motherboard.resources

lib/server/query/server.ex

@@ -25,9 +25,11 @@ defmodule Helix.Server.Query.Server do
   defdelegate fetch_by_motherboard(motherboard_id),
     to: ServerInternal
 
-  @spec get_ip(Server.id, Network.idt) ::
+  @spec get_ip(Server.idt, Network.idt) ::
     NetworkConnection.ip
     | nil
+  def get_ip(server = %Server{}, network),
+    do: get_ip(server.server_id, network)
   def get_ip(server_id, network = %Network{}),
     do: get_ip(server_id, network.network_id)
   def get_ip(server_id, network_id) do