Come posso eseguire una chiamata al processo corrente in un GenServer?

Question

So che posso chiamare un GenServer come questo

GenServer.call(pid, request) 
# using a pid 

o come questo

GenServer.call(registered_name, request) 
# if I registered the process with a name 

Ma c'è un modo per excute il GenServer.call all'interno del modulo senza conoscere il nome pid/registrato? (Vale a dire c'è qualcosa di simile GenServer.call(__CURRENT_PROCESS__, request)?)

Answer 1

non sono sicuro che è il modo migliore per andare, ma quello che stai cercando è Kernel.self/0

EDIT:

commento di Per Sasha il codice sarebbe simile a questa:

GenServer.call(self, request) 

EDIT:

Per il punto eccellente fatto da Pawel Obrok, non si dovrebbe mai fare una chiamata al processo in corso . Se è necessario inviare un messaggio al processo in corso si dovrebbe fare in questo fasion:

GenServer.cast(self, request) 

NB è colata vs. chiamata.

Answer 2

Questo semplicemente non funzionerà. Un GenServer.call invia semplicemente un messaggio al processo specificato e quindi attende un altro messaggio (la risposta), bloccando il processo corrente. Se si invia un messaggio a self in questo modo il processo non sarà libero di gestire quel messaggio in quanto verrà bloccato in attesa di una risposta. Quindi lo call scadrà sempre.

Quello che sospetto sia necessario è solo estrarre la funzionalità desiderata in una funzione e chiamarla direttamente. In alternativa puoi inviare un cast al processo corrente, dicendo in modo efficace di fare qualcosa "dopo".

Answer 3

Da quello che ho capito dal tuo commento stai provando a scrivere una funzione API pubblica per il tuo GenServer invece di fare un call all'interno del processo GenServer. AFAIK non c'è un modo per farlo senza conoscere il PID. Tuttavia, per GenServers di cui si crea solo un'istanza, esiste un idioma per un caso del genere: si nomina l'unica istanza del proprio GenServer con il nome del modulo che la implementa. Questo può essere fatto facilmente usando il __MODULE__ macro:

def start_link do 
    GenServer.start_link(__MODULE__, nil, name: __MODULE__) 
end 

E poi nelle funzioni API è sufficiente utilizzare __MODULE__ al posto di PID:

def api_function do 
    GenServer.call(__MODULE__, :api_function) 
end 

Questo ha la simpatica proprietà che __MODULE__ sarà sempre riflettere il nome corretto del modulo che lo contiene, anche quando lo si rinomina.

Answer 4

Dipende.Se si avvia un solo GenServer processo per nodo si può chiamare come:

@doc """ 
If you want to call the server only from the current module. 
""" 
def local_call(message) do 
    GenServer.call(__MODULE__, message) 
end 

o

@doc """ 
If you want to call the server from another node on the network. 
""" 
def remote_call(message, server \\ nil) do 
    server = if server == nil, do: node(), else: server 
    GenServer.call({__MODULE__, server}, message) 
end 

Se si dispone di numerosi processi dello stesso modulo, è necessario un identificatore supplementare (Per esempio, se si dispone di una strategia di supervisore :simple_one_for_one per generare GenServer s su richiesta).

Per una cosa del genere mi consiglia di utilizzare:

• :gproc ai processi di nome.
• :ets se sono necessarie ulteriori informazioni per identificare i processi.

:gproc è fantastico e funziona con GenServer. Di solito nominali i tuoi processi usando un atomo come nome registrato. :gproc consente di denominare i processi con un termine arbitrario, ad esempio una tupla.

Diciamo che nella mia chiamata di funzione ho un identificatore complesso del mio server come {:id, id :: term} dove id può essere una stringa, ad esempio. Potrei iniziare la mia GenServer come:

defmodule MyServer do 
    use GenServer 

    def start_link(id) do 
    name = {:n, :l, {:id, id}} 
    GenServer.start_link(__MODULE__, %{}, name: {:via, :gproc, name}) 
    end 
    (...) 
end 

E guarda il mio processo con qualcosa di diverso da un atomo, come ho detto prima, una stringa per esempio. Quindi, se ho iniziare il mio server come:

MyServer.start_link("My Random Hash") 

E ho una funzione come:

def f(id, message) do 
    improved_call(id, message) 
end 

defp improved_call(id, message, timeout \\ 5000) do 
    name = {:n, :l, {:id, id}} 
    case :gproc.where(name) do 
    undefined -> :error 
    pid -> GenServer.call(pid, message, timeout) 
end 

È possibile utilizzarlo per chiamare processi come:

MyServer.f("My Random Hash", {:message, "Hello"}) 

Se il processo di denominazione è più complesso, è possibile utilizzare :ets per memorizzare uno stato più complesso.

Se si desidera utilizzare :gproc è possibile aggiungere al file mix.exs come:

(...) 
defp deps do 
    [{:gproc, github: "uwiger/gproc"}] 
end 
(...) 

Una nota a parte, mai, mai chiamare GenServer.call/3 dall'interno handle_call/3. Timeout e eseguirà un DOS sull'altro GenServer.call s. handle_call/3 gestisce un messaggio alla volta.