feat: introduce room_id generator

config/runtime.exs

@@ -88,6 +88,12 @@ case ConfigReader.read_ssl_config() do
     config :fishjam, FishjamWeb.Endpoint, http: [ip: ip, port: port]
 end
 
+config :fishjam,
+  feature_flags: [
+    custom_room_name_disabled:
+      ConfigReader.read_boolean("FJ_FEATURE_FLAG_CUSTOM_ROOM_NAME_DISABLED")
+  ]
+
 check_origin = ConfigReader.read_check_origin("FJ_CHECK_ORIGIN")
 
 if check_origin != nil do

lib/fishjam/feature_flags.ex

@@ -0,0 +1,15 @@
+defmodule Fishjam.FeatureFlags do
+  @moduledoc """
+  Module to resolve any feature flags, since we are not using database we can't use fun_with_flags.
+  Because of that we base feature flags on the environment variables mainly.
+  """
+
+  @doc """
+  Flag for disabling custom room names, which will be replaced by the generated based on the node name.
+
+  Introduced: 28/05/2024
+  Removal: Once we move on to generated room_ids permanently.
+  """
+  def custom_room_name_disabled?,
+    do: Application.get_env(:fishjam, :feature_flags)[:custom_room_name_disabled] || false
+end

lib/fishjam/room/config.ex

@@ -2,6 +2,10 @@ defmodule Fishjam.Room.Config do
   @moduledoc """
   Room configuration
   """
+
+  alias Fishjam.FeatureFlags
+  alias Fishjam.Room.ID
+
   @enforce_keys [
     :room_id,
     :max_peers,
@@ -30,7 +34,11 @@ defmodule Fishjam.Room.Config do
 
   @spec from_params(map()) :: {:ok, __MODULE__.t()} | {:error, atom()}
   def from_params(params) do
-    room_id = Map.get(params, "roomId")
+    room_id =
+      if FeatureFlags.custom_room_name_disabled?(),
+        do: ID.generate(),
+        else: Map.get(params, "roomId")
+
     max_peers = Map.get(params, "maxPeers")
     video_codec = Map.get(params, "videoCodec")
     webhook_url = Map.get(params, "webhookUrl")

lib/fishjam/room/id.ex

@@ -0,0 +1,42 @@
+defmodule Fishjam.Room.ID do
+  @moduledoc """
+  This module allows to generate room_id with the node name in it.
+  """
+
+  @doc """
+  Room ID structure resembles the one of the UUID, although the last part is replaced by node name hash.
+
+  ## Example:
+      For node_name: "fishjam@10.0.0.1"
+
+      iex> Fishjam.Room.ID.generate()
+      "da2e-4a75-95ff-776bad2caf04-666973686a616d4031302e302e302e31"
+  """
+  @spec generate() :: String.t()
+  def generate do
+    UUID.uuid4()
+    |> String.split("-")
+    |> Enum.take(-4)
+    |> Enum.concat([encoded_node_name()])
+    |> Enum.join("-")
+  end
+
+  @doc """
+  Based on the Room ID determines to which node it belongs to.
+  """
+  @spec determine_node(String.t()) :: node()
+  def determine_node(room_id) do
+    room_id
+    |> String.split("-")
+    |> Enum.take(-1)
+    |> Enum.at(0)
+    |> Base.decode16!(case: :lower)
+    |> String.to_atom()
+  end
+
+  defp encoded_node_name do
+    Node.self()
+    |> Atom.to_string()
+    |> Base.encode16(case: :lower)
+  end
+end

lib/fishjam/room_service.ex

@@ -7,7 +7,9 @@ defmodule Fishjam.RoomService do
 
   require Logger
 
-  alias Fishjam.{Event, Room, WebhookNotifier}
+  alias Fishjam.Event
+  alias Fishjam.Room
+  alias Fishjam.WebhookNotifier
 
   @metric_interval_in_seconds Application.compile_env!(:fishjam, :room_metrics_scrape_interval)
   @metric_interval_in_milliseconds @metric_interval_in_seconds * 1_000
@@ -58,31 +60,14 @@ defmodule Fishjam.RoomService do
 
   @spec create_room(Room.Config.t()) :: {:ok, Room.t(), String.t()} | {:error, atom()}
   def create_room(config) do
-    {node_resources, failed_nodes} = :rpc.multicall(Fishjam.RoomService, :get_resource_usage, [])
-
-    if Enum.count(failed_nodes) > 0 do
-      Logger.warning(
-        "Couldn't get resource usage of the following nodes. Reason: nodes don't exist. Nodes: #{inspect(failed_nodes)}"
-      )
-    end
-
-    {failed_rpcs, node_resources} =
-      Enum.split_with(node_resources, fn
-        {:badrpc, _info} -> true
-        _other -> false
-      end)
-
-    unless Enum.empty?(failed_rpcs) do
-      Logger.warning("These RPC calls fail: #{inspect(failed_rpcs)}")
-    end
-
-    min_node = find_best_node(node_resources)
-
-    if Enum.count(node_resources) > 1 do
-      Logger.info("Node with least used resources is #{inspect(min_node)}")
-      GenServer.call({__MODULE__, min_node}, {:create_room, config})
-    else
-      GenServer.call(__MODULE__, {:create_room, config})
+    case Fishjam.RPCClient.multicall(Fishjam.RoomService, :get_resource_usage, []) do
+      [_only_self_resources] ->
+        GenServer.call(__MODULE__, {:create_room, config})
+
+      nodes_resources ->
+        min_node = find_best_node(nodes_resources)
+        Logger.info("Node with least used resources is #{inspect(min_node)}")
+        GenServer.call({__MODULE__, min_node}, {:create_room, config})
     end
   end
 

lib/fishjam/rpc_client.ex

@@ -0,0 +1,50 @@
+defmodule Fishjam.RPCClient do
+  @moduledoc """
+  This modules serves as simple RPC client to communicate with other nodes in cluster.
+  It utilizes the Enhanced version of Erlang `rpc` called `erpc`.
+
+  Enhanced version allows to  distinguish between returned value, raised exceptions, and other errors.
+  `erpc` also has better performance and scalability than the original rpc implementation.
+  """
+  require Logger
+
+  @doc """
+  Executes mfa on a remote node.
+  Function returns {:ok, result} tuple only if the execution succeeded.
+  In case of any exceptions we are catching them logging and returning simple :error atom.
+  """
+  @spec call(node(), module(), atom(), term(), timeout()) :: {:ok, term()} | :error
+  def call(node, module, function, args, timeout \\ :infinity) do
+    try do
+      {:ok, :erpc.call(node, module, function, args, timeout)}
+    rescue
+      e ->
+        Logger.warning("RPC call to node #{node} failed with exception: #{inspect(e)}")
+        :error
+    end
+  end
+
+  @doc """
+  Multicall to all nodes in cluster.
+  It filters out any errors or exceptions from return so you may end up with empty list.
+  """
+  @spec multicall(module(), atom(), term(), timeout()) :: list(term)
+  def multicall(module, function, args, timeout \\ :infinity) do
+    :erpc.multicall(nodes(), module, function, args, timeout)
+    |> handle_result()
+  end
+
+  defp handle_result(result) when is_list(result) do
+    result
+    |> Enum.reduce([], fn {status, res}, acc ->
+      if status == :ok do
+        [res | acc]
+      else
+        Logger.warning("RPC multicall to one of the nodes failed because of: #{inspect(res)}")
+        acc
+      end
+    end)
+  end
+
+  defp nodes, do: [Node.self() | Node.list()]
+end