Any way subscribe to Registry's 'unregister'?

darkmarmot · August 22, 2018, 3:23pm

I would find it quite useful to be able to get a callback when Registry removes a {pid, value} on process death (even if this is deferred).

Looking through Registry’s code, though, I couldn’t find the spot where it even handles this.

Any ideas or line numbers in the repo would be appreciated! Thanks!

benwilson512 · August 22, 2018, 3:28pm

You’d probably be better off explicitly having one of your own processes monitor the process you wish to be messaged about.

darkmarmot · August 22, 2018, 3:34pm

I have hundreds of thousands of processes stored in the Registry with associated values already.

I assumed the Registry, since it’s already ‘monitoring’ all of them, would be a good place to include cleanup logic.

It could be that I should just write my own Registry variant with ETS – but I was hoping to stay as closely aligned to Elixir’s core as possible.

michalmuskala · August 22, 2018, 3:39pm

I think you should be able to use the listeners option to achieve what you want - https://hexdocs.pm/elixir/Registry.html#start_link/1

darkmarmot · August 22, 2018, 3:52pm

I think something like that would work – but I think the spot I’d like a callback from would be at this line (where listeners doesn’t seem to be involved, I think…):

github.com

elixir-lang/elixir/blob/master/lib/elixir/lib/registry.ex#L1337


          id: pid_partition,
          start: {Registry.Partition, :start_link, [pid_partition, arg]}
        }
      end


    Supervisor.init(children, strategy: strategy_for_kind(kind))
  end


  # Unique registries have their key partition hashed by key.
  # This means that, if a PID partition crashes, it may have
  # entries from all key partitions, so we need to crash all.
  defp strategy_for_kind(:unique), do: :one_for_all


  # Duplicate registries have both key and pid partitions hashed
  # by pid. This means that, if a PID partition crashes, all of
  # its associated entries are in its sibling table, so we crash one.
  defp strategy_for_kind(:duplicate), do: :one_for_one
end


defmodule Registry.Partition do
  @moduledoc false

bglusman · August 22, 2018, 8:34pm

But they are called here, directly in the unregister function which is what your question seemed to be about… is there some reason that’s not good enough/an edge case we’re missing you’re trying to handle?:

github.com

elixir-lang/elixir/blob/a18f7df758432cc10c3a14565afe1a22a47eaff9/lib/elixir/lib/registry.ex#L764


  {pid_server, pid_ets} = pid_ets || pid_ets!(registry, pid_partition)


  # Remove first from the key_ets because in case of crashes
  # the pid_ets will still be able to clean up. The last step is
  # to clean if we have no more entries.
  true = :ets.match_delete(key_ets, {key, {self, :_}})
  true = :ets.delete_object(pid_ets, {self, key, key_ets})


  unlink_if_unregistered(pid_server, pid_ets, self)


  for listener <- listeners do
    Kernel.send(listener, {:unregister, registry, key, self})
  end


  :ok
end


@doc """
Unregister entries for a given key matching a pattern.


## Examples

josevalim · August 22, 2018, 8:46pm

That’s what the documentation refers to. You are only notified of explicit registration/unregistration. If you want to know a process crashed, then you need to monitor it, as suggested by @benwilson512.

darkmarmot · August 22, 2018, 9:57pm

Awesome, thanks for the feedback everyone!

For anyone interested, I ended up keeping Registry for concurrent access to the data – and then running a GenServer that subscribed to a pubsub that would explicitly check Process.alive? from the pids coming out of Registry for my edge cases.

Seems to work so far