Casts all servers locally registered as name at the specified nodes.

This function returns immediately and ignores nodes that do not exist, or where the server name does not exist.

See multi_call/4 for more information.

Makes a synchronous call to the server and waits for its reply.

The client sends the given request to the server and waits until a reply arrives or a timeout occurs. handle_call/3 will be called on the server to handle the request.

server can be any of the values described in the “Name registration” section of the documentation for this module.

Timeouts

timeout is an integer greater than zero which specifies how many milliseconds to wait for a reply, or the atom :infinity to wait indefinitely. The default value is 5000. If no reply is received within the specified time, the function call fails and the caller exits. If the caller catches the failure and continues running, and the server is just late with the reply, it may arrive at any time later into the caller’s message queue. The caller must in this case be prepared for this and discard any such garbage messages that are two-element tuples with a reference as the first element.

Sends an asynchronous request to the server.

This function always returns :ok regardless of whether the destination server (or node) exists. Therefore it is unknown whether the destination server successfully handled the message.

handle_cast/2 will be called on the server to handle the request. In case the server is on a node which is not yet connected to the caller one, the call is going to block until a connection happens. This is different than the behaviour in OTP’s :gen_server where the message is sent by another process in this case, which could cause messages to other nodes to arrive out of order.

Calls all servers locally registered as name at the specified nodes.

First, the request is sent to every node in nodes; then, the caller waits for the replies. This function returns a two-element tuple {replies, bad_nodes} where:

• replies - is a list of {node, reply} tuples where node is the node that replied and reply is its reply
• bad_nodes - is a list of nodes that either did not exist or where a server with the given name did not exist or did not reply

nodes is a list of node names to which the request is sent. The default value is the list of all known nodes (including this node).

To avoid that late answers (after the timeout) pollute the caller’s message queue, a middleman process is used to do the actual calls. Late answers will then be discarded when they arrive to a terminated process.

Examples

Assuming the Stack GenServer mentioned in the docs for the GenServer module is registered as Stack in the :"foo@my-machine" and :"bar@my-machine" nodes:

GenServer.multi_call(Stack, :pop)
#=> {[{:"foo@my-machine", :hello}, {:"bar@my-machine", :world}], []}

Replies to a client.

This function can be used to explicitly send a reply to a client that called call/3 or multi_call/4 when the reply cannot be specified in the return value of handle_call/3.

client must be the from argument (the second argument) accepted by handle_call/3 callbacks. reply is an arbitrary term which will be given back to the client as the return value of the call.

Note that reply/2 can be called from any process, not just the GenServer that originally received the call (as long as that GenServer communicated the from argument somehow).

This function always returns :ok.

Examples

def handle_call(:reply_in_one_second, from, state) do
  Process.send_after(self(), {:reply, from}, 1_000)
  {:noreply, state}
end

def handle_info({:reply, from}, state) do
  GenServer.reply(from, :one_second_has_passed)
  {:noreply, state}
end

Starts a GenServer process without links (outside of a supervision tree).

See start_link/3 for more information.

Starts a GenServer process linked to the current process.

This is often used to start the GenServer as part of a supervision tree.

Once the server is started, the init/1 function of the given module is called with args as its arguments to initialize the server. To ensure a synchronized start-up procedure, this function does not return until init/1 has returned.

Note that a GenServer started with start_link/3 is linked to the parent process and will exit in case of crashes from the parent. The GenServer will also exit due to the :normal reasons in case it is configured to trap exits in the init/1 callback.

Options

• :name - used for name registration as described in the “Name registration” section of the module documentation

• :timeout - if present, the server is allowed to spend the given amount of milliseconds initializing or it will be terminated and the start function will return {:error, :timeout}

• :debug - if present, the corresponding function in the :sys module is invoked

• :spawn_opt - if present, its value is passed as options to the underlying process as in Process.spawn/4

Return values

If the server is successfully created and initialized, this function returns {:ok, pid}, where pid is the PID of the server. If a process with the specified server name already exists, this function returns {:error, {:already_started, pid}} with the PID of that process.

If the init/1 callback fails with reason, this function returns {:error, reason}. Otherwise, if it returns {:stop, reason} or :ignore, the process is terminated and this function returns {:error, reason} or :ignore, respectively.

Stops the server with the given reason.

The terminate/2 callback of the given server will be invoked before exiting. This function returns :ok if the server terminates with the given reason; if it terminates with another reason, the call exits.

This function keeps OTP semantics regarding error reporting. If the reason is any other than :normal, :shutdown or {:shutdown, _}, an error report is logged.

Returns the pid or {name, node} of a GenServer process, or nil if no process is associated with the given name.

Examples

For example, to lookup a server process, monitor it and send a cast to it:

process = GenServer.whereis(server)
monitor = Process.monitor(process)
GenServer.cast(process, :hello)

Invoked to change the state of the GenServer when a different version of a module is loaded (hot code swapping) and the state’s term structure should be changed.

old_vsn is the previous version of the module (defined by the @vsn attribute) when upgrading. When downgrading the previous version is wrapped in a 2-tuple with first element :down. state is the current state of the GenServer and extra is any extra data required to change the state.

Returning {:ok, new_state} changes the state to new_state and the code change is successful.

Returning {:error, reason} fails the code change with reason reason and the state remains as the previous state.

If code_change/3 raises the code change fails and the loop will continue with its previous state. Therefore this callback does not usually contain side effects.

Invoked in some cases to retrieve a formatted version of the GenServer status.

This callback can be useful to control the appearance of the status of the GenServer. For example, it can be used to return a compact representation of the GenServer’s state to avoid having large state terms printed.

• one of :sys.get_status/1 or :sys.get_status/2 is invoked to get the status of the GenServer; in such cases, reason is :normal

• the GenServer terminates abnormally and logs an error; in such cases, reason is :terminate

pdict_and_state is a two-elements list [pdict, state] where pdict is a list of {key, value} tuples representing the current process dictionary of the GenServer and state is the current state of the GenServer.

Invoked to handle synchronous call/3 messages. call/3 will block until a reply is received (unless the call times out or nodes are disconnected).

request is the request message sent by a call/3, from is a 2-tuple containing the caller’s PID and a term that uniquely identifies the call, and state is the current state of the GenServer.

Returning {:reply, reply, new_state} sends the response reply to the caller and continues the loop with new state new_state.

Returning {:reply, reply, new_state, timeout} is similar to {:reply, reply, new_state} except handle_info(:timeout, new_state) will be called after timeout milliseconds if no messages are received.

Returning {:reply, reply, new_state, :hibernate} is similar to {:reply, reply, new_state} except the process is hibernated and will continue the loop once a message is in its message queue. If a message is already in the message queue this will be immediately. Hibernating a GenServer causes garbage collection and leaves a continuous heap that minimises the memory used by the process.

Hibernating should not be used aggressively as too much time could be spent garbage collecting. Normally it should only be used when a message is not expected soon and minimising the memory of the process is shown to be beneficial.

Returning {:noreply, new_state} does not send a response to the caller and continues the loop with new state new_state. The response must be sent with reply/2.

There are three main use cases for not replying using the return value:

• To reply before returning from the callback because the response is known before calling a slow function.
• To reply after returning from the callback because the response is not yet available.
• To reply from another process, such as a task.

When replying from another process the GenServer should exit if the other process exits without replying as the caller will be blocking awaiting a reply.

Returning {:noreply, new_state, timeout | :hibernate} is similar to {:noreply, new_state} except a timeout or hibernation occurs as with a :reply tuple.

Returning {:stop, reason, reply, new_state} stops the loop and terminate/2 is called with reason reason and state new_state. Then the reply is sent as the response to call and the process exits with reason reason.

Returning {:stop, reason, new_state} is similar to {:stop, reason, reply, new_state} except a reply is not sent.

If this callback is not implemented, the default implementation by use GenServer will return {:stop, {:bad_call, request}, state}.

Invoked to handle asynchronous cast/2 messages.

request is the request message sent by a cast/2 and state is the current state of the GenServer.

Returning {:noreply, new_state} continues the loop with new state new_state.

Returning {:noreply, new_state, timeout} is similar to {:noreply, new_state} except handle_info(:timeout, new_state) will be called after timeout milliseconds if no messages are received.

Returning {:noreply, new_state, :hibernate} is similar to {:noreply, new_state} except the process is hibernated before continuing the loop. See handle_call/3 for more information.

Returning {:stop, reason, new_state} stops the loop and terminate/2 is called with the reason reason and state new_state. The process exits with reason reason.

If this callback is not implemented, the default implementation by use GenServer will return {:stop, {:bad_cast, request}, state}.

Invoked to handle all other messages.

msg is the message and state is the current state of the GenServer. When a timeout occurs the message is :timeout.

Return values are the same as handle_cast/2.

If this callback is not implemented, the default implementation by use GenServer will return {:noreply, state}.

Invoked when the server is started. start_link/3 or start/3 will block until it returns.

args is the argument term (second argument) passed to start_link/3.

Returning {:ok, state} will cause start_link/3 to return {:ok, pid} and the process to enter its loop.

Returning {:ok, state, timeout} is similar to {:ok, state} except handle_info(:timeout, state) will be called after timeout milliseconds if no messages are received within the timeout.

Returning {:ok, state, :hibernate} is similar to {:ok, state} except the process is hibernated before entering the loop. See handle_call/3 for more information on hibernation.

Returning :ignore will cause start_link/3 to return :ignore and the process will exit normally without entering the loop or calling terminate/2. If used when part of a supervision tree the parent supervisor will not fail to start nor immediately try to restart the GenServer. The remainder of the supervision tree will be (re)started and so the GenServer should not be required by other processes. It can be started later with Supervisor.restart_child/2 as the child specification is saved in the parent supervisor. The main use cases for this are:

• The GenServer is disabled by configuration but might be enabled later.
• An error occurred and it will be handled by a different mechanism than the Supervisor. Likely this approach involves calling Supervisor.restart_child/2 after a delay to attempt a restart.

Returning {:stop, reason} will cause start_link/3 to return {:error, reason} and the process to exit with reason reason without entering the loop or calling terminate/2.

Invoked when the server is about to exit. It should do any cleanup required.

reason is exit reason and state is the current state of the GenServer. The return value is ignored.

terminate/2 is called if a callback (except init/1) returns a :stop tuple, raises, calls Kernel.exit/1 or returns an invalid value. It may also be called if the GenServer traps exits using Process.flag/2 and the parent process sends an exit signal.

If part of a supervision tree a GenServer’s Supervisor will send an exit signal when shutting it down. The exit signal is based on the shutdown strategy in the child’s specification. If it is :brutal_kill the GenServer is killed and so terminate/2 is not called. However if it is a timeout the Supervisor will send the exit signal :shutdown and the GenServer will have the duration of the timeout to call terminate/2 - if the process is still alive after the timeout it is killed.

If the GenServer receives an exit signal (that is not :normal) from any process when it is not trapping exits it will exit abruptly with the same reason and so not call terminate/2. Note that a process does NOT trap exits by default and an exit signal is sent when a linked process exits or its node is disconnected.

Therefore it is not guaranteed that terminate/2 is called when a GenServer exits. For such reasons, we usually recommend important clean-up rules to happen in separated processes either by use of monitoring or by links themselves. For example if the GenServer controls a port (e.g. :gen_tcp.socket) or File.io_device/0, they will be closed on receiving a GenServer’s exit signal and do not need to be closed in terminate/2.

If reason is not :normal, :shutdown nor {:shutdown, term} an error is logged.