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

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.

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

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

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.

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

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).

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

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.

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.