I have two clean installations of Phoenix 1.4.2 - apps named A and B. I’m running these with --sname option. I can run command from another application using :rpc.call. Can I subscribe to Phoenix.PubSub from another app?
Should it be somehow wrapped by a GenServer on the B side and used with Node.spawn_link? Is there some easier solution? First I wanted to broadcast messages between two apps installed on same server using websockets but then I thought there should be an easier method.
I’m not super familiar with the implementation details, but I’ll try to describe it conceptually and hopefully that’ll help.
Phoenix.PubSub works, by creating a cluster of different nodes. You need to start a Phoenix.PubSub process on every node in the cluster. You can specify an adapter, which allows Phoenix.PubSub to discover what other nodes are available to connect to. In the case of the redis adapter, each node will connect to redis and messages will be sent through that. In the case of PG2 (the default), Phoenix.PubSub will connect with other Phoenix.PubSub processes on any of the nodes already clustered by the nodes being connected.
So, you’ve correctly connected the nodes. But it looks like you’ve not started a Phoenix.PubSub process. So, when you call Phoenix.PubSub.subscribe/2, the process that would’ve setup stuff locally on the current node hasn’t done so and you’re getting an error about a lookup on an ets table not existing.
I think in the simple iex session you’re just missing something like:
I figured it out without the Phoenix.PubSub. I think it’s all I need.
Create pg2 group in A
defmodule A.Application do
def start(_type, _args) do
:pg2.create :some_group
# ...
end
Connect to group in B
defmodule B.Application do
def start(_type, _args) do
children = [
# ...
{B.Worker, []},
]
# ...
end
defmodule B.Worker do
use GenServer
def start_link(opts) do
{:ok, pid} = GenServer.start_link(__MODULE__, :ok, opts)
true = Node.connect(:"a@MacBook-Pro")
:ok = :pg2.join(:some_group, pid)
{:ok, pid}
end
end
Maybe someone will be interested in my final implementation of the subscriber module
defmodule B.Worker do
use GenServer
@reconnect_interval 1_000
def start_link(opts) do
GenServer.start_link(__MODULE__, :ok, opts)
end
def init(:ok) do
Process.send_after(self(), :join_pg2, 0)
{:ok, %{}}
end
def handle_info(:join_pg2, state) do
node_name = :"a@MacBook-Pro"
case Node.connect(agent_node) do
true ->
if :group_name not in :pg2.which_groups() do
:global.sync()
:ok = :pg2.join(:group_name, self())
end
Node.monitor(node_name, true)
{:noreply, state}
false ->
Process.send_after(self(), :join_pg2, @reconnect_interval)
{:noreply, state}
end
end
# from Node.monitor
def handle_info({:nodedown, _node}, state) do
Process.send_after(self(), :join_pg2, 0)
{:noreply, state}
end
def handle_info(msg, state) do
IO.inspect msg
{:noreply, state}
end
end