Make an OuroborosApplication for the bundle of mini-protocols that make up the overall node-to-node protocol.

This function specifies the wire format protocol numbers.

The application specific protocol numbers start from 2. The MiniProtocolNum 0 is reserved for the Handshake protocol, while MiniProtocolNum 1 is reserved for DeltaQ messages. Handshake protocol is not included in NodeToNodeProtocols as it runs before mux is started but it reusing MuxBearer to send and receive messages. Only when the handshake protocol succeeds, we will know which protocols to run / multiplex.

These are chosen to not overlap with the node to client protocol numbers (and the handshake protocol number). This is not essential for correctness, but is helpful to allow a single shared implementation of tools that can analyse both protocols, e.g. wireshark plugins.

Enumeration of node to node protocol versions.

Version data for NodeToNode protocol

Tracer used by connectToNode (and derivatives, like connectTo or 'Ouroboros.Network.NodeToClient.connectTo).

A specialised version of connectToNode.

Tracers required by a server which handles inbound connections.

Mutable state maintained by the network component.

Policy which governs how to limit the number of accepted connections.

Clean PeerStates within NetworkMutableState every 200s

A specialised version of withServerNode. It forks a thread which runs an accept loop (server thread):

• when the server thread throws an exception the main thread rethrows it (by wait)
• when an async exception is thrown to kill the main thread the server thread will be cancelled as well (by withAsync)

Should this peer be advertised to other peers asking for known peers? For certain peers specified by configuration it would be an appropriate policy to keep them private.

Adjustable targets for the peer selection mechanism.

These are used by the peer selection governor as targets. They are used by the peer churn governor loop as knobs to adjust, to influence the peer selection governor.

The known, established and active peer targets are targets both from below and from above: the governor will attempt to grow or shrink the sets to hit these targets.

Unlike the other targets, the root peer target is "one sided", it is only a target from below. The governor does not try to shrink the root set to hit it, it simply stops looking for more.

There is also an implicit target that enough local root peers are selected as active. This comes from the configuration for local roots, and is not an independently adjustable target.

IP subscription tracers.

ipSubscriptionWorker and dnsSubscriptionWorker parameters

ipSubscriptionWorker which starts given application versions on each established connection.

DNS subscription tracers.

dnsSubscriptionWorker which starts given application versions on each established connection.

The version map supported by the local agent keyed on the version identifier.

Each Version contains a function which takes negotiated version data and returns negotiated application (the r type variable).

If one needs to combine multiple versions the simplest way is to use one of the combinators: foldMapVersions, combineVersions or the Semigroup instance directly:

fold $ (simpleSingletonVersions ...)
      :| [ (simpleSingletonVersions ...)
         , (simpleSingletonVersions ...)
         , ...
         ]

The flag which indicates whether the node runs only initiator or both initiator or responder node.

This data structure has two proposes:

• instruct the diffusion layer if it should listen on incoming connections;
• it is communicated via NodeToNodeVersionData during handshake negotiation. In non-p2p mode we always send InitiatorOnlyDiffusionMode, in p2p mode we send exactly what the diffusion is given. In non-p2p mode every connection outbound port is ephemeral, the remote side cannot connect to it, however in p2p mode the outbound port is actually the port on which the node is listening (if it runs in InitiatorAndResponderDiffusionMode).

Singleton smart constructor for Versions.

Useful for folding multiple Versions.

A foldMap restricted to the Versions Semigroup.

PRECONDITION: f x is non-empty.

Handshake codec for the node-to-node protocol suite.

Context passed to initiator mini-protocol execution.

A context passed to initiator mini-protocol execution for non-p2p applications.

Context passed to each responder mini-protocol execution.

Connection is identified by local and remote address.

TODO: the type variable which this data type fills in is called peerid. We should renamed to connectionId.

Control signal sent to a mini-protocol. Expected to exit, on Continue it should continue its operation

ControlMessageSTM should depend on muxMode (we only need to schedule stop for initiator side). This is not done only because this would break tests, but once the old api is removed it should be possible.

A boolean like type. Big ledger peers are the largest SPOs which control 90% of staked stake.

Note that IsBigLedgerPeer indicates a role that peer plays in the eclipse evasion, e.g. that a peer was explicitly selected as a big ledger peer, e.g. IsNotBigLedgerPeer does not necessarily mean that the peer isn't a big ledger peer. This is because we select root peers from all ledger peers (including big ones).

The handshake mini-protocol is used initially to agree the version and associated parameters of the protocol to use for all subsequent communication.

Basic type for a socket.

Exception which where caught in the connection thread and were re-thrown in the main thread by the rethrowPolicy.

List of error policies for exception handling and a policy for handing application return values.

A minimal error policy for remote peers, which only handles exceptions raised by `ouroboros-network`.

Error policy for local clients. This is equivalent to nullErrorPolicies, but explicit in the errors which can be caught.

We are very permissive here, and very strict in the networkErrorPolicy. After any failure the client will be killed and not penalised by this policy. This allows to restart the local client without a delay.

Semigroup of commands which acts on PeerState. The t variable might be initiated to DiffTime or Time m.

This semigroup allows to either suspend both consumer and producer or just the consumer part.

Trace for the AcceptConnectionsLimit policy.

Structured Tracer output for runPeer and derivitives.

Trace data for error policies