made a bunch of alpha modifications

Author: RooSoft

lib/nostr/client/relays/relay_manager.ex

@@ -18,10 +18,22 @@ defmodule Nostr.Client.Relays.RelayManager do
     {:ok, opts}
   end
 
-  def add(relay_url) do
+  def add(relay_url_list) when is_list(relay_url_list) do
+    for relay_url <- relay_url_list do
+      add(relay_url)
+    end
+  end
+
+  def add(relay_url) when is_binary(relay_url) do
     DynamicSupervisor.start_child(RelayManager, {RelaySocket, [relay_url, self()]})
   end
 
+  def active_relay_sockets do
+    DynamicSupervisor.which_children(RelayManager)
+    |> Enum.map(&get_pid/1)
+    |> Enum.filter(&RelaySocket.ready?/1)
+  end
+
   def active_pids() do
     DynamicSupervisor.which_children(RelayManager)
     |> Enum.map(&get_pid/1)

lib/nostr/client/relays/relay_socket/publisher.ex

@@ -4,7 +4,7 @@ defmodule Nostr.Client.Relays.RelaySocket.Publisher do
   """
 
   def successful_connection(pid, relay_url) do
-    send(pid, {:console, :connected, %{url: relay_url}})
+    send(pid, {:console, :connected, %{url: relay_url, pid: self()}})
   end
 
   def websockets_ready(pid, relay_url) do

lib/nostr/client/relays/relay_socket/server.ex

@@ -13,11 +13,20 @@ defmodule Nostr.Client.Relays.RelaySocket.Server do
 
   @impl true
   def init(%{relay_url: relay_url, owner_pid: owner_pid}) do
+    Logger.info("Starting a relay socket for #{relay_url}, #{inspect self()}")
+
     send(self(), {:connect_to_relay, relay_url, owner_pid})
 
     {:ok, %RelaySocket{}}
   end
 
+  @impl true
+  def terminate(reason, state) do
+    Logger.warning("A relay socket is terminating: #{inspect reason}")
+
+    {:ok, state}
+  end
+
   @impl true
   def handle_cast({:unsubscribe, subscription_id}, state) do
     state =
@@ -61,6 +70,9 @@ defmodule Nostr.Client.Relays.RelaySocket.Server do
   def handle_call(:url, _from, %RelaySocket{conn: conn} = state) do
     url = ~s(#{conn.private.scheme}://#{conn.host}:#{conn.port})
 
+    IO.inspect("URL: #{url}")
+    IO.inspect state
+
     {:reply, url, state}
   end
 
@@ -132,6 +144,8 @@ defmodule Nostr.Client.Relays.RelaySocket.Server do
   def handle_call({:notes, pubkeys, limit, subscriber}, _from, state) do
     {subscription_id, json} = Nostr.Client.Request.notes(pubkeys, limit)
 
+    IO.puts json
+
     send(self(), {:subscription_request, state, subscription_id, json, subscriber})
 
     {:reply, subscription_id, state}

lib/nostr/client/subscriptions/all_subscription.ex

@@ -58,8 +58,6 @@ defmodule Nostr.Client.Subscriptions.AllSubscription do
 
   @impl true
   def handle_info(event, %{subscriber: subscriber} = state) do
-    IO.inspect(event, label: "in all_subscription")
-
     send(subscriber, event)
 
     {:noreply, state}

lib/nostr/client/subscriptions/contacts_subscription.ex

@@ -6,40 +6,61 @@ defmodule Nostr.Client.Subscriptions.ContactsSubscription do
 
   use GenServer
 
+  require Logger
+
   alias Nostr.Client.Relays.RelaySocket
 
-  def start_link([relay_pids, pubkey, subscriber]) do
-    GenServer.start_link(__MODULE__, %{
-      relay_pids: relay_pids,
+  def start([relay_pid, pubkey, subscriber]), do: start(relay_pid, pubkey, subscriber)
+
+  def start(relay_pid, pubkey, subscriber \\ self()) when is_pid(relay_pid) do
+    Logger.info("#{inspect(relay_pid)} contacts subscription: #{inspect(pubkey)}")
+
+    GenServer.start(__MODULE__, %{
+      relay_pid: relay_pid,
       pubkey: pubkey,
       subscriber: subscriber
     })
   end
 
   @impl true
-  def init(%{relay_pids: relay_pids, pubkey: pubkey} = state) do
+  def init(state) do
     Process.flag(:trap_exit, true)
 
-    subscriptions =
-      relay_pids
-      |> Enum.map(fn relay_pid ->
-        RelaySocket.subscribe_contacts(relay_pid, pubkey)
-      end)
-
-    {
-      :ok,
-      state
-      |> set_contract_subscriptions(subscriptions)
-    }
+    send(self(), :connect)
+
+    {:ok, state}
   end
 
   @impl true
-  def terminate(_reason, %{relay_pids: relay_pids, subscriptions: subscriptions} = state) do
-    unsubscribe_all(relay_pids, subscriptions)
+  def terminate(_reason, %{relay_pid: relay_pid} = state) do
+    if(Map.has_key?(state, :relay_subscription)) do
+      subscription = Map.get(state, :relay_subscription)
+      unsubscribe(relay_pid, subscription)
+    end
 
     {:noreply, state}
   end
 
+  @impl true
+  def handle_info(:connect, %{relay_pid: relay_pid, pubkey: pubkey} = state) do
+    case Process.alive?(relay_pid) do
+      true ->
+        subscription = RelaySocket.subscribe_contacts(relay_pid, pubkey)
+
+        {
+          :noreply,
+          state
+          |> set_contract_subscription(subscription)
+        }
+
+      false ->
+        Process.flag(:trap_exit, false)
+        Process.exit(self(), "disconnected relay, can't subscribe to contacts")
+
+        {:noreply, state}
+    end
+  end
+
   @impl true
   def handle_info({:end_of_stored_events, _relay_url, _subscription_id}, state) do
     ## nothing to do
@@ -49,20 +70,16 @@ defmodule Nostr.Client.Subscriptions.ContactsSubscription do
 
   @impl true
   def handle_info(profile, %{subscriber: subscriber} = state) do
-    IO.puts("CONTACTS FROM HERE")
-
     send(subscriber, profile)
 
     {:noreply, state}
   end
 
-  defp set_contract_subscriptions(state, subscriptions) do
-    Map.put(state, :subscriptions, subscriptions)
+  defp set_contract_subscription(state, subscription) do
+    Map.put(state, :relay_subscription, subscription)
   end
 
-  defp unsubscribe_all(relay_pids, subscriptions) do
-    for relay_pid <- relay_pids, subscription <- subscriptions do
-      RelaySocket.unsubscribe(relay_pid, subscription)
-    end
+  defp unsubscribe(relay_pid, subscription) do
+    RelaySocket.unsubscribe(relay_pid, subscription)
   end
 end

lib/nostr/client/subscriptions/notes_subscription.ex

@@ -10,43 +10,69 @@ defmodule Nostr.Client.Subscriptions.NotesSubscription do
 
   alias Nostr.Client.Relays.RelaySocket
 
-  def start_link([relay_pids, pubkeys, subscriber]) do
-    GenServer.start_link(__MODULE__, %{
-      relay_pids: relay_pids,
+  def start([relay_pid, pubkeys, subscriber]), do: start(relay_pid, pubkeys, subscriber)
+
+  def start(relay_pid, pubkeys, subscriber \\ self()) when is_pid(relay_pid) do
+    Logger.info("#{inspect(relay_pid)} notes subscription: #{inspect(pubkeys)}")
+
+    GenServer.start(__MODULE__, %{
+      relay_pid: relay_pid,
       pubkeys: pubkeys,
-      subscriber: subscriber
+      subscriber: subscriber,
+      relay_subscriptions: []
     })
   end
 
   @impl true
-  def init(%{relay_pids: relay_pids, pubkeys: pubkeys} = state) do
+  def init(%{relay_pid: relay_pid, pubkeys: pubkeys} = state) do
     Process.flag(:trap_exit, true)
 
-    send(self(), {:connect, relay_pids, pubkeys})
+    Logger.warning("NEW SUBSCRIPTION- ---------------- #{inspect(self())}")
+
+    send(self(), {:connect, relay_pid, pubkeys})
 
     {:ok, state}
   end
 
   @impl true
-  def terminate(_reason, %{relay_pids: relay_pids, subscriptions: subscriptions} = state) do
-    unsubscribe_all(relay_pids, subscriptions)
+  def terminate(
+        _reason,
+        %{relay_pid: relay_pid, relay_subscriptions: relay_subscriptions} = state
+      ) do
+    Logger.warning("the #{inspect(self())} note subscription is terminating")
+
+    unsubscribe(relay_pid, relay_subscriptions)
+
+    {:noreply, state}
+  end
+
+  @impl true
+  def terminate(reason, %{relay_pid: relay_pid, subscriber: subscriber} = state) do
+    Logger.warning(
+      "TERMINATE EVENT: #{inspect(relay_pid)} #{inspect(subscriber)}, #{inspect(reason)}"
+    )
 
     {:noreply, state}
   end
 
   @impl true
-  def handle_info({:connect, relay_pids, pubkeys}, state) do
-    subscriptions =
-      relay_pids
-      |> Enum.map(fn relay_pid ->
-        RelaySocket.subscribe_notes(relay_pid, pubkeys)
-      end)
-
-    {
-      :noreply,
-      state
-      |> set_note_subscriptions(subscriptions)
-    }
+  def handle_info({:connect, relay_pid, pubkeys}, state) do
+    case Process.alive?(relay_pid) do
+      true ->
+        subscription = RelaySocket.subscribe_notes(relay_pid, pubkeys)
+
+        {
+          :noreply,
+          state
+          |> add_notes_subscription(subscription)
+        }
+
+      false ->
+        Process.flag(:trap_exit, false)
+        Process.exit(self(), "disconnected relay, can't subscribe to notes")
+
+        {:noreply, state}
+    end
   end
 
   @impl true
@@ -64,12 +90,12 @@ defmodule Nostr.Client.Subscriptions.NotesSubscription do
     {:noreply, state}
   end
 
-  defp set_note_subscriptions(state, subscriptions) do
-    Map.put(state, :subscriptions, subscriptions)
+  defp add_notes_subscription(%{relay_subscriptions: relay_subscriptions} = state, subscription) do
+    %{state | relay_subscriptions: [subscription | relay_subscriptions]}
   end
 
-  defp unsubscribe_all(relay_pids, subscriptions) do
-    for relay_pid <- relay_pids, subscription <- subscriptions do
+  defp unsubscribe(relay_pid, subscriptions) do
+    for subscription <- subscriptions do
       RelaySocket.unsubscribe(relay_pid, subscription)
     end
   end

mix.exs

@@ -60,7 +60,7 @@ defmodule Nostr.MixProject do
       {:credo, "~> 1.6", only: [:dev, :test], runtime: false},
       {:hammox, "~> 0.7", only: :test},
       {:mint_web_socket, "~> 1.0"},
-      {:nostr_basics, "~> 0.1.2"}
+      {:nostr_basics, "~> 0.1.6"}
     ]
   end
 end