I’ve read interesting topic where I found practical example of how to use new Registry. Based on mentioned topic I’ve created Supervisors and Genservers, but I’m not sure if this implementation is correct for my needs or if I’m missing something. I want to create Room by room id than under it spawn Groups and many Users, Room should store all users and groups ids to fast check if user or group exists. Also I want to let user join and leave at once many groups or get all groups that user belongs to. In code below I got stuck in all functions with require IEx;IEx.pry, e.g. :get_user_groups how can I get user groups from children processes? Can I use Registry to subscribe users to their groups or in current implementation can I just extract this data by e.g. Registry.lookup?
Supervisors:
defmodule MyApp.Room.SystemsSupervisor do
use Supervisor
def start_link() do
IO.puts "Starting MyApp.Room.SystemsSupervisor"
Supervisor.start_link(
__MODULE__,
nil
)
end
def init(_) do
children = [
supervisor(Registry, [:unique, Registry.ProcessRegistry], id: :proc),
supervisor(MyApp.Room.RoomSupervisor, [])
]
supervise(children, strategy: :rest_for_one)
end
end
defmodule MyApp.Room.RoomSupervisor do
use Supervisor
def start_link() do
IO.puts "Starting MyApp.Room.RoomSupervisor"
Supervisor.start_link(
__MODULE__,
nil,
name: :rooms_supervisor
)
end
def start_child(room_id, user) do
Supervisor.start_child(
:rooms_supervisor,
[room_id, user]
)
end
def init(_) do
children = [
supervisor(MyApp.Room.SingleRoomSupervisor, []),
]
supervise(children, strategy: :simple_one_for_one)
end
end
defmodule MyApp.Room.SingleRoomSupervisor do
use Supervisor
def start_link(room_id, user) do
IO.puts "Starting SingleRoomSupervisor"
Supervisor.start_link(
__MODULE__,
{room_id, user},
name: via_tuple(room_id)
)
end
defp via_tuple(room_id) do
{:via, Registry, {Registry.ProcessRegistry, {:room_sup, room_id}}}
end
def init({room_id, user}) do
children = [
supervisor(MyApp.Room.UserSupervisor, [room_id]),
supervisor(MyApp.Room.GroupSupervisor, [room_id]),
worker(MyApp.Room.Room, [room_id, user]),
]
supervise(children, strategy: :one_for_all)
end
end
defmodule MyApp.Room.GroupSupervisor do
use Supervisor
def start_link(room_id) do
IO.puts "Starting MyApp.Room.GroupSupervisor"
Supervisor.start_link(
__MODULE__,
nil,
name: via_tuple(room_id)
)
end
defp via_tuple(room_id) do
{:via, Registry, {Registry.ProcessRegistry, {:group_sup, room_id}}}
end
def start_child(room_id, group_id, user_id) do
Supervisor.start_child(
via_tuple(room_id), #user_id
[group_id, user_id]
)
end
def init(_) do
children = [
worker(MyApp.Room.Group, [])
]
supervise(children, strategy: :simple_one_for_one)
end
end
defmodule MyApp.Room.UserSupervisor do
use Supervisor
def start_link(room_id) do
IO.puts "Starting MyApp.Room.UserSupervisor"
Supervisor.start_link(
__MODULE__,
nil,
name: via_tuple(room_id)
)
end
defp via_tuple(room_id) do
{:via, Registry, {Registry.ProcessRegistry, {:user_sup, room_id}}}
end
def start_child(room_id, user) do
Supervisor.start_child(
via_tuple(room_id),
[user.id, user.username]
)
end
def init(_) do
children = [
worker(MyApp.Room.User, [])
]
supervise(children, strategy: :simple_one_for_one)
end
end
Genservers:
defmodule MyApp.Room.Room do
use GenServer
defstruct groups: [], users: [], room_id: :none
# Client API
def start_link(room_id, user) do
IO.puts "Starting Room for #{room_id}"
GenServer.start_link(
__MODULE__,
{room_id, user},
name: via_tuple(room_id)
)
end
defp via_tuple(room_id) do
{:via, Registry, {Registry.ProcessRegistry, {:room, room_id}}}
end
def new(room_id, user) do
# r = Registry.lookup(Registry.ProcessRegistry, {:room, room_id})
# g = GenServer.whereis(via_tuple(room_id))
# IO.inspect {g, "vs", r}
case GenServer.whereis(via_tuple(room_id)) do
nil ->
MyApp.Room.RoomSupervisor.start_child(room_id, user)
room_pid ->
send(room_pid, {:real_init, room_id, user})
end
end
def get_user_groups(room_id, user_id) do
GenServer.call(via_tuple(room_id), {:get_user_groups, user_id}, 50 * 10000)
end
def user_joined_groups(room_id, user_id, groups) do
GenServer.call(via_tuple(room_id), {:user_joined_groups, user_id, groups}, 50 * 10000)
end
def user_left_groups(room_id, user_id, groups) do
GenServer.call(via_tuple(room_id), {:user_left_groups, user_id, groups}, 50 * 10000)
end
# Server Callbacks
def init({room_id, user}) do
send(self(), {:real_init, room_id, user})
{:ok, %__MODULE__{room_id: room_id}}
end
def handle_call({:get_user_groups, user_id}, _from, state) do
require IEx;IEx.pry
{:noreply, state}
end
def handle_call({:user_joined_groups, user_id, groups}, _from, state) do
require IEx;IEx.pry
{:noreply, state}
end
def handle_call({:user_left_groups, user_id, groups}, _from, state) do
require IEx;IEx.pry
{:noreply, state}
end
def handle_info({:real_init, room_id, user}, state) do
areas = prepare_areas(room_id, user)
{:ok, _user} = MyApp.Room.UserSupervisor.start_child(room_id, user)
{:noreply, %__MODULE__{state | areas: state.areas ++ areas, users: state.users ++ [user.id]}}
end
# Helper Functions
defp prepare_areas(room_id, user) do
for group <- user.groups do
MyApp.Room.Group.new(room_id, group, user.id)
group.id
end
end
end
defmodule MyApp.Room.Group do
use GenServer
defstruct users: [], group_id: :none
# Client API
def start_link(group_id, user_id) do
IO.puts "Starting group: #{group_id}"
GenServer.start_link(
__MODULE__,
[group_id, user_id],
name: via_tuple(group_id)
)
end
defp via_tuple(group_id) do
{:via, Registry, {Registry.ProcessRegistry, {:group, group_id}}}
end
def new(room_id, group_id, user_id) do
case GenServer.whereis(via_tuple(group_id)) do
nil ->
IO.inspect {"creating group #{group_id} with user: #{user_id}"}
MyApp.Room.GroupSupervisor.start_child(room_id, group_id, user_id)
group_pid ->
IO.inspect {"updating group #{group_id} with user: #{user_id}"}
send(group_pid, {:add_user, user_id})
end
end
# Server Callbacks
def init([group_id, user_id]) do
{:ok, %__MODULE__{group_id: group_id, users: [user_id]}}
end
def handle_info({:add_user, user_id}, state) do
{:noreply, %__MODULE__{state | users: state.users ++ [user_id]}}
end
end
defmodule MyApp.Room.User do
use GenServer
defstruct username: nil, id: :none, metas: []
# Client API
def start_link(user_id, username) do
IO.puts "Starting user: #{user_id}"
GenServer.start_link(
__MODULE__,
[user_id, username],
name: via_tuple(user_id)
)
end
defp via_tuple(user_id) do
{:via, Registry, {Registry.ProcessRegistry, {:user, user_id}}}
end
# Server Callbacks
def init([user_id, username]) do
{:ok, %__MODULE__{id: user_id, username: username}}
end
end
