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

This function specifies the wire format protocol numbers as well as the protocols that run for each NodeToClientVersion.

They are chosen to not overlap with the node to node protocol numbers. 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.

Record of node-to-client mini protocols.

Enumeration of node to client protocol versions.

Version data for NodeToClient protocol v1

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

A specialised version of connectToNode. It is a general purpose function which can connect using any version of the protocol. This is mostly useful for future enhancements.

A version of connectTo which exposes Mux interfaces which allows to run mini-protocols and handle their termination (e.g. restart them when they terminate or error).

Tracers required by a server which handles inbound connections.

Mutable state maintained by the network component.

Clean PeerStates within NetworkMutableState every 200s

A specialised version of withServerNode.

Comments to withServer apply here as well.

IP subscription tracers.

ncSubscriptionWorker which starts given application versions on each established connection.

This is public api to interact with the io manager; On Windows IOManager holds associateWithIOCompletionPort; on other platforms IOManager can run over any type, and thus is guaranteed to be no-op.

withIOManager allows to do asynchronous io on Windows hiding the differences between posix and Win32.

It starts an io manger thread, which should be only one running at a time, so the best place to call it is very close to the main function and last for duration of the application.

Async IO operations which are using the iocp port should not leak out-side of withIOManager. They will be silently cancelled when withIOManager exists. In particular one should not return IOManager from withIOManager.

System dependent LocalSnocket

Create a LocalSnocket.

On Windows, there is no way to get path associated to a named pipe. To go around this, the address passed to open via LocalFamily will be referenced by LocalSocket.

System dependent LocalSnocket type

Local address, on Unix is associated with AF_UNIX family, on

Windows with `named-pipes`.

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 ...)
         , ...
         ]

Versions containing a single version of nodeToClientProtocols.

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-client protocol suite.

We set 16ths bit to distinguish NodeToNodeVersion and NodeToClientVersion. This way connecting wrong protocol suite will fail during Handshake negotiation

This is done in backward compatible way, so NodeToClientV_1 encoding is not changed.

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.

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

Context passed to each responder mini-protocol execution.

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

ErrorPolicies for client application. Additional rules can be added by means of a Semigroup instance of ErrorPolicies.

This error policies will try to preserve subscriptionWorker, e.g. if the connect function throws an IOException we will suspend it for a shortDelay, and try to re-connect.

This allows to recover from a situation where a node temporarily shutsdown, or running a client application which is subscribed two more than one node (possibly over network).

Trace data for error policies

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.

Structured Tracer output for runPeer and derivitives.

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