Rewrite Log internals

Author: renatomassaro

lib/event/dispatcher.ex

@@ -146,7 +146,7 @@ defmodule Helix.Event.Dispatcher do
   # All
   event LogEvent.Log.Created
   event LogEvent.Log.Deleted
-  event LogEvent.Log.Modified
+  # event LogEvent.Log.Modified
 
   ##############################################################################
   # Process events

lib/event/loggable/flow.ex

@@ -24,17 +24,17 @@ defmodule Helix.Event.Loggable.Flow do
   alias Helix.Event
   alias Helix.Event.Loggable.Utils, as: LoggableUtils
   alias Helix.Entity.Model.Entity
+  alias Helix.Log.Model.Log
+  alias Helix.Log.Model.LogType
   alias Helix.Log.Action.Log, as: LogAction
   alias Helix.Network.Model.Bounce
   alias Helix.Network.Model.Network
   alias Helix.Network.Model.Tunnel
   alias Helix.Network.Query.Bounce, as: BounceQuery
   alias Helix.Server.Model.Server
 
-  @type log_entry ::
-    {Server.id, Entity.id, log_msg}
-
-  @type log_msg :: String.t
+  @typep log_entry ::
+    {Server.id, Entity.id, Log.info}
 
   @doc """
   Top-level macro for events wanting to implement the Loggable protocol.
@@ -66,13 +66,12 @@ defmodule Helix.Event.Loggable.Flow do
   """
   defmacro log_map(map) do
     quote do
-      map = unquote(map)
+      unquote(map)
 
       # Put default values (if not specified)
-      map
       |> Map.put_new(:network_id, nil)
       |> Map.put_new(:endpoint_id, nil)
-      |> Map.put_new(:msg_endpoint, nil)
+      |> Map.put_new(:data_both, %{})
       |> Map.put_new(:opts, %{})
     end
   end
@@ -119,8 +118,11 @@ defmodule Helix.Event.Loggable.Flow do
       gateway_id: gateway_id,
       endpoint_id: endpoint_id,
       network_id: network_id,
-      msg_gateway: msg_gateway,
-      msg_endpoint: msg_endpoint,
+      type_gateway: type_gateway,
+      data_gateway: data_gateway,
+      type_endpoint: type_endpoint,
+      data_endpoint: data_endpoint,
+      data_both: data_both,
       opts: opts
     })
   do
@@ -147,25 +149,36 @@ defmodule Helix.Event.Loggable.Flow do
       end
       |> customize_last_ip(opts)
 
-    msg_gateway = String.replace(msg_gateway, "$first_ip", first_ip)
-    msg_endpoint = String.replace(msg_endpoint, "$last_ip", last_ip)
+    data_gateway =
+      data_gateway
+      |> replace_ips(first_ip, last_ip)
+      |> Map.merge(data_both)
+
+    data_endpoint =
+      data_endpoint
+      |> replace_ips(first_ip, last_ip)
+      |> Map.merge(data_both)
 
-    log_gateway = build_entry(gateway_id, entity_id, msg_gateway)
-    log_endpoint = build_entry(endpoint_id, entity_id, msg_endpoint)
+    log_gateway = {type_gateway, LogType.new(type_gateway, data_gateway)}
+    log_endpoint = {type_endpoint, LogType.new(type_endpoint, data_endpoint)}
 
-    bounce_logs =
+    entry_gateway = build_entry(gateway_id, entity_id, log_gateway)
+    entry_endpoint = build_entry(endpoint_id, entity_id, log_endpoint)
+
+    bounce_entries =
       if skip_bounce? do
         []
       else
         build_bounce_entries(
           bounce,
           {gateway_id, network_id, gateway_ip},
           {endpoint_id, network_id, endpoint_ip},
-          entity_id
+          entity_id,
+          network_id
         )
       end
 
-    [log_gateway, log_endpoint, bounce_logs] |> List.flatten()
+    [entry_gateway, entry_endpoint, bounce_entries] |> List.flatten()
   end
 
   @doc """
@@ -178,10 +191,13 @@ defmodule Helix.Event.Loggable.Flow do
       event: _,
       server_id: server_id,
       entity_id: entity_id,
-      msg_server: msg_server
+      type: type,
+      data: data
     })
   do
-    [build_entry(server_id, entity_id, msg_server)]
+    log_type = LogType.new(type, data)
+
+    [build_entry(server_id, entity_id, {type, log_type})]
   end
 
   @doc """
@@ -249,7 +265,7 @@ defmodule Helix.Event.Loggable.Flow do
   defdelegate format_ip(ip),
     to: LoggableUtils
 
-  @spec build_entry(Server.id, Entity.id, log_msg) ::
+  @spec build_entry(Server.id, Entity.id, Log.info) ::
     log_entry
   @doc """
   Returns data required to insert the log
@@ -263,16 +279,23 @@ defmodule Helix.Event.Loggable.Flow do
 
   Messages follow the format "Connection bounced from hop (n-1) to (n+1)"
   """
-  def build_bounce_entries(nil, _, _, _),
+  def build_bounce_entries(nil, _, _, _, _),
     do: []
-  def build_bounce_entries(bounce_id = %Bounce.ID{}, gateway, endpoint, entity) do
+  def build_bounce_entries(
+    bounce_id = %Bounce.ID{}, gateway, endpoint, entity, network
+  ) do
     bounce_id
     |> BounceQuery.fetch()
-    |> build_bounce_entries(gateway, endpoint, entity)
+    |> build_bounce_entries(gateway, endpoint, entity, network)
   end
+
   def build_bounce_entries(
-    bounce = %Bounce{}, gateway = {_, _, _}, endpoint = {_, _, _}, entity_id)
-  do
+    bounce = %Bounce{},
+    gateway = {_, _, _},
+    endpoint = {_, _, _},
+    entity_id,
+    network_id
+  ) do
     full_path = [gateway | bounce.links] ++ [endpoint]
     length_hop = length(full_path)
 
@@ -298,8 +321,11 @@ defmodule Helix.Event.Loggable.Flow do
         {_, _, ip_prev} = bounce_map[idx - 1]
         {_, _, ip_next} = bounce_map[idx + 1]
 
-        msg = "Connection bounced from #{ip_prev} to #{ip_next}"
-        entry = build_entry(server_id, entity_id, msg)
+        data = %{ip_prev: ip_prev, ip_next: ip_next, network_id: network_id}
+        # TODO
+        log_type = {:connection_bounced, LogType.new(:connection_bounced, data)}
+
+        entry = build_entry(server_id, entity_id, log_type)
 
         {idx + 1, acc ++ [entry]}
       end
@@ -321,8 +347,8 @@ defmodule Helix.Event.Loggable.Flow do
     do: save([log_entry])
   def save(logs) do
     logs
-    |> Enum.map(fn {server_id, entity_id, msg} ->
-      {:ok, _, events} = LogAction.create(server_id, entity_id, msg)
+    |> Enum.map(fn {server_id, entity_id, log_type} ->
+      {:ok, _, events} = LogAction.create(server_id, entity_id, log_type)
       events
     end)
     |> List.flatten()
@@ -378,4 +404,24 @@ defmodule Helix.Event.Loggable.Flow do
     do: censor_ip(ip)
   defp customize_last_ip(ip, _),
     do: ip
+
+  defp replace_ips(params, first_ip, last_ip) do
+    params
+    |> Enum.reduce([], fn {k, v}, acc ->
+      new_v =
+        case v do
+          "$first_ip" ->
+            first_ip
+
+          "$last_ip" ->
+            last_ip
+
+          _ ->
+            v
+        end
+
+      [{k, new_v} | acc]
+    end)
+    |> Enum.into(%{})
+  end
 end

lib/log/action/log.ex

@@ -25,73 +25,56 @@ defmodule Helix.Log.Action.Log do
   alias Helix.Log.Event.Log.Deleted, as: LogDeletedEvent
   alias Helix.Log.Event.Log.Modified, as: LogModifiedEvent
 
-  @spec create(Server.idt, Entity.idt, String.t, pos_integer | nil) ::
+  @spec create(Server.id, Entity.id, Log.info, pos_integer | nil) ::
     {:ok, Log.t, [LogCreatedEvent.t]}
-    | {:error, Ecto.Changeset.t}
+    | :error
   @doc """
-  Creates a new log linked to `entity` on `server` with `message` as content.
+  Creates a new log linked to `entity` on `server` with `log_info` as content.
   """
-  def create(server, entity, message, forge \\ nil) do
-    with {:ok, log} <- LogInternal.create(server, entity, message, forge) do
-      event = LogCreatedEvent.new(log)
+  def create(server_id, entity_id, log_info, forge_version \\ nil) do
+    case LogInternal.create(server_id, entity_id, log_info, forge_version) do
+      {:ok, log} ->
+        {:ok, log, [LogCreatedEvent.new(log)]}
 
-      {:ok, log, [event]}
+      {:error, _} ->
+        :error
     end
   end
 
-  @spec revise(Log.t, Entity.idt, String.t, pos_integer) ::
-    {:ok, Log.t, [LogModifiedEvent.t]}
-    | {:error, Ecto.Changeset.t}
+  @spec revise(Log.t, Entity.id, Log.info, pos_integer) ::
+    {:ok, Log.t, [LogRevisedEvent.t]}
+    | :error
   @doc """
-  Adds a revision over `log`.
-
-  ### Params
-  - `entity` is the the entity that is doing the revision.
-  - `message` is the new log's content.
-  - `forge_version` is the version of log forger used to make this revision.
-
-  ### Examples
-
-      iex> revise(%Log{}, %Entity{}, "empty log", 100)
-      {:ok, %Log{message: "empty log"}, [%LogModifiedEvent{}]}
+  Adds a revision to the given `log`.
   """
-  def revise(log, entity, message, forge_version) do
-    with \
-      {:ok, log} <- LogInternal.revise(log, entity, message, forge_version)
-    do
-      event = LogModifiedEvent.new(log)
-
-      {:ok, log, [event]}
+  def revise(log = %Log{}, entity_id, log_info, forge_version) do
+    case LogInternal.revise(log, entity_id, log_info, forge_version) do
+      {:ok, log} ->
+        event = LogRevisedEvent.new(log)
+        {:ok, log, [event]}
+
+      {:error, _} ->
+        :error
     end
   end
 
   @spec recover(Log.t) ::
-    {:ok, :recovered, [LogModifiedEvent.t]}
-    | {:ok, :deleted, [LogDeletedEvent.t]}
-    | {:error, :original_revision}
+    {:ok, :destroyed, [LogDeletedEvent.t]}
+    | {:ok, :original, []}
+    | {:ok, :recovered, [LogRecoveredEvent.t]}
   @doc """
-  Recovers `log` to a previous revision.
-
-  ### Notes
-  - If the log is in its original state and it is not a forged log, the
-  operation will fail with `{:error, :original_revision}`.
-  - If the log is in its original state and it is forged, it will be deleted,
-  returning `{:ok, :deleted, [Helix.Event.t]}`.
-  - Otherwise the revision will be deleted and the log will be updated to use
-  the last revision's message, returning `{:ok, :recovered, [Helix.Event.t]}`.
+  Attempts to recover the given `log`.
   """
-  def recover(log) do
+  def recover(log = %Log{}) do
     case LogInternal.recover(log) do
-      {:ok, :deleted} ->
-        event = LogDeletedEvent.new(log)
-        {:ok, :deleted, [event]}
+      :destroyed ->
+        {:ok, :destroyed, [LogDeletedEvent.new(log)]}
 
-      {:ok, :recovered} ->
-        event = LogModifiedEvent.new(log)
-        {:ok, :recovered, [event]}
+      {:original, _} ->
+        {:ok, :original, []}
 
-      {:error, :original_revision} ->
-        {:error, :original_revision}
+      {:recovered, new_log} ->
+        {:ok, :recovered, [LogRecoveredEvent.new(new_log)]}
     end
   end
 end