The MapSet is referred to as tasks.
Using the MyWorker module might look as follows:
in a supervisor, possibly the root application supervisor
children = [
...
worker(MyWorker, [])
]
adding user tasks
# adding a task with user ID 1
MyWorker.add(1)
# adding a second task with user ID 2
MyWorker.add(2)
removing a user task
MyWorker.remove(1)
And also where it is stored, as that is the returned state that is then threaded through all other calls.
Yes, and it is described in the GenServer documentation. 
Imagine genserver implemented this way in pseudo-code:
def start_link(user_module, args) do
{:ok, spawn_link(fn -> gen_server_init(user_module, args) end)}
end
def gen_server_init(user_module, args) do
{:ok, state} = user_module.init(args)
gen_server_loop(user_module, state)
end
def gen_server_loop(user_module, state) do
receive do
{:__special_genserver_cast__, msg} ->
{:noreply, newstate} = user_module.handle_cast(msg, state)
gen_server_loop(user_module, newstate)
{:__special_genserver_call__, msg, from} ->
{:reply, outmsg, newstate} = user_module.handle_call(msg, from, state)
send(from, outmsg)
gen_server_loop(user_module, newstate)
unknown_msg ->
{:noreply, newstate} = user_module.handle_info(unknown_msg, state)
gen_server_loop(user_module, newstate)
end
end
And so forth, but with significantly more error checking and cases and such. GenServer is just an infinite receiving loop passing the state from iteration to iteration.
I would recommend you to have a look at the Registry module.
First, some considerations:
GenServer per user;GenServer process.Tackling the first part, which involves associating a user’s id with a process, start one if one is not running and keeping a list of executing processes based on the user’s name, can be done using the following construct:
defmodule MyWorker do
use GenServer
@doc """
Should be called before `start_worker`.
"""
def start_link() do
Registry.start_link(:unique, __MODULE__)
end
@doc """
Starts a worker process for a given `user` to handle the given `task`.
"""
def maybe_start_worker(user, task) do
case Registry.lookup(__MODULE__, user) do
[{pid, _value}] ->
{:ok, pid} # do nothing, already running
[] ->
name = {:via, Registry, {__MODULE__, user}}
GenServer.start_link(__MODULE__, task, name: name)
end
end
def init(task) do
self() |> Process.send_after(:process_task, 0)
{:ok, task}
end
def handle_info(:process_task, task) do
# do something with the task
access_external_service(task)
# finishes the process, nothing else to do for the moment
{:stop, :normal, task}
end
defp access_external_service(task) do
# a request to an external web server
end
end
Assuming the above, then now you could create another process to re-run the worker process every 30 seconds. This another process can hold a simple Map where the key is the user’s id and the value is the task. Just call MyScheduler.add_item/2 when the user clicks on the button, followed by MyWorker.start_worker/2 if you want to process the task immediately, otherwise, the worker will be executed 30 seconds later by the scheduler.
defmodule MyScheduler do
use GenServer
def start_link() do
GenServer.start_link(__MODULE__, %{}, name: __MODULE__)
end
def add_item(user, task) do
GenServer.call(__MODULE__, {:add_item, user, task})
end
def remove_item(user) do
GenServer.call(__MODULE__, {:remove_item, user})
end
def init(map), do: {:ok, map}
def handle_info({:reschedule, user, task}, map) do
MyWorker.maybe_start_worker(user, task)
timer = self() |> Process.send_after({:reschedule, user, task}, 30_000) # reschedule
{:noreply, %{map | user => {task, timer}}}
end
def handle_call({:add_item, user, task}, map) do
timer = self() |> Process.send_after({:reschedule, user, task}, 30_000)
{:reply, :ok, map |> Map.put(user, {task, timer})
end
def handle_call({:remove_item, user}, map) do
map =
map |> Map.get_and_update(user, fn {_task, timer} ->
timer |> Process.cancel_timer()
:pop
end)
{:reply, :ok, map}
end
end
With the above:
MyScheduler.remove_item/1 for the same user ID you used in MyScheduler.add_item/2.