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

Broadcasts a message originating from this node.

-spec monitor(process, monitor_process_id()) -> reference() | partisan_remote_ref:r() | 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, monitor_process_id(), [erlang:monitor_option()]) ->
           reference() | partisan_remote_ref:r() | no_return();
       (port, erlang:monitor_port_identifier(), [erlang:monitor_option()]) ->
           reference() | no_return();
       (time_offset, clock_service, [erlang:monitor_option()]) -> 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. 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.

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 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() from the remote node using RPC and returns {error, Reason} if the RPC fails. Otherwise, asumes the node is running on the same host and returns a node_spec() 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 :: 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).