swarm

v3.4.0

swarm v3.4.0 Swarm.Tracker

This module implements the distributed tracker for process registrations and groups. It is implemented as a finite state machine, via :gen_statem.

Each node Swarm runs on will have a single instance of this process, and the trackers will replicate data between each other, and/or forward requests to remote trackers as necessary.

Link to this section Summary

Functions

add_meta(key, value, pid)

Adds some metadata to the given process (pid). This is primarily used for tracking group membership

anti_entropy(state)
awaiting_sync_ack(arg1, arg2, state)
callback_mode()
child_spec(arg)

Returns a specification to start this module under a supervisor

cluster_wait(arg1, arg2, state)
handle_event(event_type, msg, state)
handoff(worker_name, state)

Hand off all the processes running on the given worker to the remaining nodes in the cluster. This can be used to gracefully shut down a node. Note that if you don’t shut down the node after the handoff a rebalance can lead to processes being scheduled on it again. In other words the handoff doesn’t blacklist the node for further rebalances

remove_meta(key, pid)

Removes metadata from the given process (pid)

start_link()
syncing(arg1, arg2, state)
track(name, pid)

Tracks a process (pid) with the given name. Tracking processes with this function will not restart the process when its parent node goes down, or shift the process to other nodes if the cluster topology changes. It is strictly for global name registration

track(name, m, f, a, timeout)

Tracks a process created via the provided module/function/args with the given name. The process will be distributed on the cluster based on the implementation of the configured distribution strategy. If the process’ parent node goes down, it will be restarted on the new node which owns its keyspace. If the cluster topology changes, and the owner of its keyspace changes, it will be shifted to the new owner, after initiating the handoff process as described in the documentation. A track call will return an error tagged tuple, {:error, :no_node_available}, if there is no node available to start the process. Provide a timeout value to limit the track call duration. A value of :infinity can be used to block indefinitely

tracking(event_type, msg, state)
untrack(pid)

Stops tracking the given process (pid)

whereis(name)

Authoritatively looks up the pid associated with a given name

Link to this section Functions

Link to this function add_meta(key, value, pid)

Adds some metadata to the given process (pid). This is primarily used for tracking group membership.

Link to this function anti_entropy(state)
Link to this function awaiting_sync_ack(arg1, arg2, state)
Link to this function callback_mode()
Link to this function child_spec(arg)

Returns a specification to start this module under a supervisor.

See Supervisor in Elixir v1.6+.

Link to this function cluster_wait(arg1, arg2, state)
Link to this function handle_event(event_type, msg, state)
Link to this function handoff(worker_name, state)

Hand off all the processes running on the given worker to the remaining nodes in the cluster. This can be used to gracefully shut down a node. Note that if you don’t shut down the node after the handoff a rebalance can lead to processes being scheduled on it again. In other words the handoff doesn’t blacklist the node for further rebalances.

Link to this function remove_meta(key, pid)

Removes metadata from the given process (pid).

Link to this function syncing(arg1, arg2, state)
Link to this function track(name, pid)

Tracks a process (pid) with the given name. Tracking processes with this function will not restart the process when its parent node goes down, or shift the process to other nodes if the cluster topology changes. It is strictly for global name registration.

Link to this function track(name, m, f, a, timeout)

Tracks a process created via the provided module/function/args with the given name. The process will be distributed on the cluster based on the implementation of the configured distribution strategy. If the process’ parent node goes down, it will be restarted on the new node which owns its keyspace. If the cluster topology changes, and the owner of its keyspace changes, it will be shifted to the new owner, after initiating the handoff process as described in the documentation. A track call will return an error tagged tuple, {:error, :no_node_available}, if there is no node available to start the process. Provide a timeout value to limit the track call duration. A value of :infinity can be used to block indefinitely.

Link to this function tracking(event_type, msg, state)
Link to this function untrack(pid)

Stops tracking the given process (pid).

Link to this function whereis(name)

Authoritatively looks up the pid associated with a given name.