-spec broadcast(any(), module()) -> ok.

Broadcasts a message originating from this node.

-spec monitor(process, erlang:monitor_process_identifier()) -> reference();
       (process, remote_pid() | remote_name()) -> remote_reference() | no_return();
       (port, erlang:monitor_port_identifier()) -> reference() | no_return();
       (time_offset, clock_service) -> reference() | no_return().

Sends a monitor request of type Type to the entity identified by Item. If the monitored entity does not exist or it changes monitored state, the caller of monitor/2 is notified by a message on the following format: {Tag, MonitorRef, Type, Object, Info}

This is the Partisan's equivalent to erlang:monitor/2.

-spec monitor(process, pid() | atom(), [monitor_opt()]) -> reference();
       (port, erlang:monitor_port_identifier(), [erlang:monitor_option()]) -> reference();
       (time_offset, clock_service, [erlang:monitor_option()]) -> reference();
       (process, {atom(), node()}, [monitor_opt()]) -> reference() | remote_reference();
       (process, remote_pid(), [monitor_opt()]) -> remote_reference();
       (process, remote_name(), [monitor_opt()]) -> remote_reference().

Sends a monitor request of type Type to the entity identified by Item. If the monitored entity does not exist or it changes monitored state, the caller of monitor/2 is notified by a message on the following format:

{Tag, MonitorRef, Type, Object, Info}

• MonitorRef is a remote_reference()
• Object is a remote_pid() or remote_name()

This is the Partisan's equivalent to erlang:monitor/2. It differs from the Erlang implementation only when monitoring a process. For all other cases (monitoring a port or time_offset) this function calls erlang:monitor/2.

As opposed to erlang:monitor/2 this function does not support aliases.

Monitoring a `process`

Creates monitor between the current process and another process identified by Item, which can be a pid() (local or remote), an atom RegisteredName or a tuple {RegisteredName, Node}' for a registered process, located elsewhere.

In the case of a local pid() or a remote pid() A process monitor by name resolves the RegisteredName to pid() or port() only once at the moment of monitor instantiation, later changes to the name registration will not affect the existing monitor.

-spec monitor_node(node() | node_spec(), boolean()) -> boolean().

Monitor the status of the node Node. If Flag is true, monitoring is turned on. If Flag is false, monitoring is turned off.

Making several calls to monitor_node(Node, true) for the same Node from is not an error; it results in as many independent monitoring instances as the number of different calling processes i.e. If a process has made two calls to monitor_node(Node, true) and Node terminates, only one nodedown message is delivered to the process (this differs from erlang:monitor_node/2).

If Node fails or does not exist, the message {nodedown, Node} is delivered to the calling process. If there is no connection to Node, a nodedown message is delivered. As a result when using a membership strategy that uses a partial view, you can not monitor nodes that are not members of the view.

-spec monitor_node(Node :: node(), Flag :: boolean(), Options :: [allow_passive_connect]) -> true.

Monitor the status of the node Node. If Flag is true, monitoring is turned on. If Flag is false, monitoring is turned off.

Making several calls to monitor_node(Node, true) for the same Node from is not an error; it results in as many independent monitoring instances as the number of different calling processes i.e. If a process has made two calls to monitor_node(Node, true) and Node terminates, only one nodedown message is delivered to the process (this differs from erlang:monitor_node/2).

If Node fails or does not exist, the message {nodedown, Node} is delivered to the calling process. If there is no connection to Node, a nodedown message is delivered. As a result when using a membership strategy that uses a partial view, you can not monitor nodes that are not members of the view.

-spec node_spec() -> node_spec().

Returns the node specification of the local node. This is the information required when other nodes wish to join this node (See partisan_peer_service:join/1).

-spec node_spec(node()) -> {ok, node_spec()} | {error, Reason :: any()}.

Return the partisan node_spec() for node named Node.

This function retrieves the node_spec/0 from the remote node using RPC and returns {error, Reason} if the RPC fails. Otherwise, assumes the node is running on the same host and returns a node_spec/0 with with nodename Name and host 'Host' and same metadata as myself/0.

If configuration option connect_disterl is true, the RPC will be implemented using the rpc module. Otherwise it will use partisan_rpc.

-spec node_spec(Node :: binary() | list() | node(), Opts :: #{rpc_timeout => timeout()}) ->
             {ok, node_spec()} | {error, Reason :: any()}.

Return the tuple {ok, node_spec() for node named Node or the tuple {error, Reason}.

This function first checks If there is a partisan connection to Node, if so returns the cached specification that was used for creating the connection. If no connection is present (the case for a p2p topology), then it tries to use @link partisan_rpc} to retrieve the node specification from the remote node. This later alternative requires the partisan configuration forward_opts` to have `broadcast and transitive enabled.

-spec nodes() -> [node()].

Returns a list of all nodes connected to this node via Partisan. Equivalent to erlang:nodes/1. Sames as calling nodes(visible).

-spec nodes(Arg :: node_type() | [node_type()]) -> [node()].

Returns a list of nodes according to the argument specified. The returned result, when the argument is a list, is the list of nodes satisfying the disjunction(s) of the list elements.

• hidden - always returns the empty list (there is no concept of hidden nodes in Partisan).
• this - returns the list containing the result of calling node/0
• known - will return the nodes known by the partisan_peer_service i.e. partisan_peer_service:members/0 but not the nodes referred to by process identifiers, port identifiers, and references located on this node.
• visible - equivalent to Erlang.

-spec self() -> remote_pid().

Returns the partisan encoded pid for the calling process. This is equivalent to calling partisan_remote_ref:from_term(self()).

-spec self(Opts :: [cache]) -> remote_pid().

Returns the partisan encoded pid for the calling process.

If Opts is the empty list, this is equivalent to calling partisan_remote_ref:from_term(self()).

NOTICE

You SHOULD avoid using this function in the Erlang Shell. This is because when an Erlang Shell process crashes it will copy the contents of It's dictionary to the new shell process and thus you will end up with the wrong partisan remote reference.