How to setup Phoenix PubSub subscriber callbacks - redis

Question

I've got a fairly straightforward requirement centered around 2 services (for now) built in Phoenix:
ServiceA is responsible for registering users. When a user is registered, ServiceA broadcasts a message with info about the newly created user. This is being done using the following code in a Controller action right now:
ServiceA.Endpoint.broadcast("activity:all", "new:user", %{email: "test#test.com"})
ServiceB is responsible for listening out for all of these activity broadcasts and doing something with them (essentially building up a feed of activity).
I've hit a stumbling block in that I can see ServiceA broadcasting the message to Redis (using Phoenix.PubSub.Redis), but don't fully understand how to get the subscriber on ServiceB to process it...
The following piece of code is as far as I've managed to get, which does something when a message is broadcast and then raises an exception.
Partial Subscriber Module
defmodule ServiceB.UserSubscriber do
def start_link do
sub = spawn_link &(process_feed/0)
ServiceB.Endpoint.subscribe(:user_pubsub, "activity:all")
{:ok, sub}
end
def process_feed do
receive do
params ->
IO.inspect "processing goes here..."
end
process_feed
end
end
Exception
[error] GenServer :user_pubsub terminating
** (FunctionClauseError) no function clause matching in Phoenix.PubSub.RedisServer.handle_info/2
I'm guessing I've missed a whole load of GenServer work somewhere, but can't seem to find anything online that suggests where.

Answer 1

The problem (as expected) was that my Subscriber module wasn't implemented as a GenServer but I was trying to replicate the same functionality (and badly!). Updating my Subscriber Model as follows has done the trick:
defmodule SubscriberService.ActivitySubscriber do
use GenServer
def start_link(channel) do
GenServer.start_link(__MODULE__, channel)
end
def init(channel) do
pid = self
ref = SubscriberService.Endpoint.subscribe(pid, channel)
{:ok, {pid, channel, ref}}
end
def handle_info(%{event: "new:user"} = message, state) do
IO.inspect "#######################"
IO.inspect "New User - Received Message:"
IO.inspect message
IO.inspect "#######################"
{:noreply, state}
end
def handle_info(message, state) do
IO.inspect "#######################"
IO.inspect "Catch All - Received Message:"
IO.inspect message
IO.inspect "#######################"
{:noreply, state}
end
end
As you can see, init/1 triggers the subscription, and the handle_info/2 functions receive the incoming messages.
If you want to see how it works in all its glory (both Publisher and Subscriber services), take a look at the repo.