Listing processes registered in Registry

Questions / Help
1

Is there a way to list all the processes registered in Registry [0] with the help of via tuple?
There is a way to look up the pid for a given key. But I’d like to get all the processes registered in a particular registry. Maybe I can access its ets table(s) somehow? Or maybe I can register all those processes in a group somehow? But it’s only possible to use unique registries for via calls…

I was thinking about :listeners option on start_link [1] where I would add some genserver which would be storing the names of registered processes, but that would be duplication of data.

[0] https://hexdocs.pm/elixir/master/Registry.html
[1] https://hexdocs.pm/elixir/master/Registry.html#start_link/3

2

Since you are probably using the Registry for registering processes that are then supervised by a Supervisor, you could try Supervisor.which_children/1.

3

That’s what I am currently doing, but there is a note in the docs, that it can cause a memory exception, so I thought it’s simpler to get the data from ets tables.

4

What are you trying to do? What would you do with the list once you get it?

5

The processes I’m registering in Registry are rooms from apps/room in umbrella. Their state is a struct like this (might not work, I’ve just started using types and specs)

@type message :: record(:message, username: String.t, content: String.t)
@type room :: %__MODULE__{
  id: String.t,
  title: String.t,
  history: [message],
  timer_ref: reference
}

What I want is to list all the active rooms (just their id and title) when a user connects to a "lobby" channel.

With which_children I also get history and timer_ref which I don’t need

def list_rooms do
  Supervisor.which_children(Test.Room.Supervisor)
  |> Enum.map(fn {_, pid, _, _} when is_pid(pid) ->
    %Test.Room{id: id, title: title} = :sys.get_state(pid)
    {id, title}
  end)
end
6

If there’s a lot of rooms, I’d be more worried about the impact of sequentially messaging every single room process (which is what map + get_state does) than about the impact of duplicating the registration.

Have you considered using a duplicate registry, and registering directly in your room’s init rather than using :via? Then you could register with {id, title} as the value and get all the id/titles quickly without adding load to your processes.

1 Like
7

Thank you. I’ll try that now. Just thought I could access the ets tables that Registry uses directly.

8

Is this approximately what you suggested? I’ve removed some unnecessary code

defmodule Test.Room do
  use GenServer

  @registry Test.Room.Registry

  def start_link(room_id, title \\ nil, history \\ []) do
    case Registry.match(@registry, :rooms, {room_id, :_}) do
      [] ->
        room = %__MODULE__{id: room_id, title: title, history: history}
        GenServer.start_link(__MODULE__, room)
      [{pid, _value}] ->
        {:error, {:already_registered, pid}}
    end
  end

  def do_smth(room_id, data) do
    GenServer.call(room_pid(room_id), {:do_smth, data})
  end

  def list do
    Registry.lookup(@registry, :rooms)
  end
  def list(limit) do
    Registry.lookup(@registry, :rooms) |> Enum.take(limit)
  end


  def init(%__MODULE__{id: id, title: title} = room) do
    {:ok, _owner_pid} = Registry.register(@registry, :rooms, {id, title})
    {:ok, room}
  end


  defp room_pid(room_id) do
    case Registry.match(@registry, :rooms, {room_id, :_}) do
      [{pid, {^room_id, _title}}] -> pid
      [] -> :undefined
    end
  end
end

What I don’t like about this approach now is that I have to manually check whether a room has already been started. And I can only list all the rooms, and not just some subset of them.

Anyway, thanks again. I think it’s a good solution.

I will try and compare it with a unique registry with :via callbacks and a listener (maybe a genserver) which keeps the list of active rooms. What I like about that option is that I will be able to add pagination there (maybe with ets iterator).

9

Registry.lookup/2 would return all entries under a given key for a duplicate registry.

1 Like
10

Hmm yes, but there’s a race condition in start_link, so you’d really need both registries.

Rolling your own cache isn’t a bad idea either.

11

there’s a race condition in start_link

Oops, I don’t see it. Can you please tell me where? I thought GenServer.start_link and init were synchronous.

12

They’re synchronous, but if you call Room.start_link from multiple processes around the same time for the same id, they may all see Registry.match return [] and enter GenServer.start_link, rather than return {:error, {:already_registered, pid}}. There is a window between Registry.match and Registry.register. Unique registry does not have this problem since register also checks if it’s already registered in one atomic operation.

1 Like