Safe Haskell	None
Language	Haskell2010

Ouroboros.Network.Socket

Contents

High level socket interface
Traces
Helper function for creating servers
Re-export of PeerStates
Re-export connection table functions
Auxiliary functions
Orphan instances

Description

Module exports interface for running a node over a socket over TCP / IP.

Synopsis

data ConnectionTable m addr
data ConnectionTableRef
- = ConnectionTableCreate
- | ConnectionTableExist
- | ConnectionTableDuplicate
data ValencyCounter m
data NetworkMutableState addr = NetworkMutableState {
- nmsConnectionTable :: ConnectionTable IO addr
- nmsPeerStates :: StrictTVar IO ( PeerStates IO addr)
}
data SomeResponderApplication addr bytes m b where
- SomeResponderApplication :: forall appType addr bytes m a b. HasResponder appType ~ True => OuroborosApplication appType addr bytes m a b -> SomeResponderApplication addr bytes m b
newNetworkMutableState :: IO ( NetworkMutableState addr)
newNetworkMutableStateSTM :: STM ( NetworkMutableState addr)
cleanNetworkMutableState :: NetworkMutableState addr -> IO ()
data AcceptedConnectionsLimit = AcceptedConnectionsLimit {
- acceptedConnectionsHardLimit :: ! Word32
- acceptedConnectionsSoftLimit :: ! Word32
- acceptedConnectionsDelay :: ! DiffTime
}
data ConnectionId addr = ConnectionId {
- localAddress :: !addr
- remoteAddress :: !addr
}
withServerNode :: forall vNumber vData t fd addr b. ( Ord vNumber, Typeable vNumber, Show vNumber, Ord addr) => Snocket IO fd addr -> NetworkServerTracers addr vNumber -> NetworkMutableState addr -> AcceptedConnectionsLimit -> addr -> Codec ( Handshake vNumber Term ) DeserialiseFailure IO ByteString -> ProtocolTimeLimits ( Handshake vNumber Term ) -> VersionDataCodec Term vNumber vData -> (vData -> vData -> Accept vData) -> Versions vNumber vData ( SomeResponderApplication addr ByteString IO b) -> ErrorPolicies -> (addr -> Async Void -> IO t) -> IO t
withServerNode' :: forall vNumber vData t fd addr b. ( Ord vNumber, Typeable vNumber, Show vNumber, Ord addr) => Snocket IO fd addr -> NetworkServerTracers addr vNumber -> NetworkMutableState addr -> AcceptedConnectionsLimit -> fd -> Codec ( Handshake vNumber Term ) DeserialiseFailure IO ByteString -> ProtocolTimeLimits ( Handshake vNumber Term ) -> VersionDataCodec Term vNumber vData -> (vData -> vData -> Accept vData) -> Versions vNumber vData ( SomeResponderApplication addr ByteString IO b) -> ErrorPolicies -> (addr -> Async Void -> IO t) -> IO t
connectToNode :: forall appType vNumber vData fd addr a b. ( Ord vNumber, Typeable vNumber, Show vNumber, HasInitiator appType ~ True ) => Snocket IO fd addr -> Codec ( Handshake vNumber Term ) DeserialiseFailure IO ByteString -> ProtocolTimeLimits ( Handshake vNumber Term ) -> VersionDataCodec Term vNumber vData -> NetworkConnectTracers addr vNumber -> (vData -> vData -> Accept vData) -> Versions vNumber vData ( OuroborosApplication appType addr ByteString IO a b) -> Maybe addr -> addr -> IO ()
connectToNodeSocket :: forall appType vNumber vData a b. ( Ord vNumber, Typeable vNumber, Show vNumber, HasInitiator appType ~ True ) => IOManager -> Codec ( Handshake vNumber Term ) DeserialiseFailure IO ByteString -> ProtocolTimeLimits ( Handshake vNumber Term ) -> VersionDataCodec Term vNumber vData -> NetworkConnectTracers SockAddr vNumber -> (vData -> vData -> Accept vData) -> Versions vNumber vData ( OuroborosApplication appType SockAddr ByteString IO a b) -> Socket -> IO ()
connectToNode' :: forall appType vNumber vData fd addr a b. ( Ord vNumber, Typeable vNumber, Show vNumber, HasInitiator appType ~ True ) => Snocket IO fd addr -> Codec ( Handshake vNumber Term ) DeserialiseFailure IO ByteString -> ProtocolTimeLimits ( Handshake vNumber Term ) -> VersionDataCodec Term vNumber vData -> NetworkConnectTracers addr vNumber -> (vData -> vData -> Accept vData) -> Versions vNumber vData ( OuroborosApplication appType addr ByteString IO a b) -> fd -> IO ()
data NetworkConnectTracers addr vNumber = NetworkConnectTracers {
- nctMuxTracer :: Tracer IO ( WithMuxBearer ( ConnectionId addr) MuxTrace )
- nctHandshakeTracer :: Tracer IO ( WithMuxBearer ( ConnectionId addr) ( TraceSendRecv ( Handshake vNumber Term )))
}
nullNetworkConnectTracers :: NetworkConnectTracers addr vNumber
debuggingNetworkConnectTracers :: ( Show addr, Show vNumber) => NetworkConnectTracers addr vNumber
data NetworkServerTracers addr vNumber = NetworkServerTracers {
- nstMuxTracer :: Tracer IO ( WithMuxBearer ( ConnectionId addr) MuxTrace )
- nstHandshakeTracer :: Tracer IO ( WithMuxBearer ( ConnectionId addr) ( TraceSendRecv ( Handshake vNumber Term )))
- nstErrorPolicyTracer :: Tracer IO ( WithAddr addr ErrorPolicyTrace )
- nstAcceptPolicyTracer :: Tracer IO AcceptConnectionsPolicyTrace
}
nullNetworkServerTracers :: NetworkServerTracers addr vNumber
debuggingNetworkServerTracers :: ( Show addr, Show vNumber) => NetworkServerTracers addr vNumber
data AcceptConnectionsPolicyTrace
- = ServerTraceAcceptConnectionRateLimiting DiffTime Int
- | ServerTraceAcceptConnectionHardLimit Word32
- | ServerTraceAcceptConnectionResume Int
fromSnocket :: forall fd addr. Ord addr => ConnectionTable IO addr -> Snocket IO fd addr -> fd -> IO ( Socket addr fd)
beginConnection :: forall vNumber vData addr st fd. ( Ord vNumber, Typeable vNumber, Show vNumber) => Snocket IO fd addr -> Tracer IO ( WithMuxBearer ( ConnectionId addr) MuxTrace ) -> Tracer IO ( WithMuxBearer ( ConnectionId addr) ( TraceSendRecv ( Handshake vNumber Term ))) -> Codec ( Handshake vNumber Term ) DeserialiseFailure IO ByteString -> ProtocolTimeLimits ( Handshake vNumber Term ) -> VersionDataCodec Term vNumber vData -> (vData -> vData -> Accept vData) -> ( Time -> addr -> st -> STM (AcceptConnection st vNumber vData addr IO ByteString )) -> BeginConnection addr fd st ()
data PeerStates m addr
newConnectionTable :: MonadSTM m => m ( ConnectionTable m addr)
refConnection :: ( MonadSTM m, Ord addr) => ConnectionTable m addr -> addr -> ValencyCounter m -> m ConnectionTableRef
addConnection :: forall m addr. ( MonadSTM m, Ord addr) => ConnectionTable m addr -> addr -> addr -> Maybe ( ValencyCounter m) -> STM m ()
removeConnection :: forall m addr. ( MonadSTM m, Ord addr) => ConnectionTable m addr -> addr -> addr -> m ()
newValencyCounter :: MonadSTM m => ConnectionTable m addr -> Int -> STM m ( ValencyCounter m)
addValencyCounter :: MonadSTM m => ValencyCounter m -> STM m ()
remValencyCounter :: MonadSTM m => ValencyCounter m -> STM m ()
waitValencyCounter :: MonadSTM m => ValencyCounter m -> STM m ()
readValencyCounter :: MonadSTM m => ValencyCounter m -> STM m Int
sockAddrFamily :: SockAddr -> Family

High level socket interface

data ConnectionTable m addr Source #

data ConnectionTableRef Source #

Constructors

ConnectionTableCreate	No connection to peer exists, attempt to create one.
ConnectionTableExist	A connection to the peer existed, either from another subscriber or the peer opened one towards us.
ConnectionTableDuplicate	This subscriber already has counted a connection to this peer. It must try another target.

Instances

Instances details

Show ConnectionTableRef Source #
Instance details Defined in Ouroboros.Network.Server.ConnectionTable Methods showsPrec :: Int -> ConnectionTableRef -> ShowS Source # show :: ConnectionTableRef -> String Source # showList :: [ ConnectionTableRef ] -> ShowS Source #

data ValencyCounter m Source #

ValencyCounter represents how many active connections we have towards a given peer. It starts out with a positive value representing a desired number of connections for a specific subscription worker. It can become negative, for example if a peer opens multiple connections to us. The vcId is unique per ConnectionTable and ensures that we won't count the same connection twice.

Instances

Instances details

Eq ( ValencyCounter m) Source #
Instance details Defined in Ouroboros.Network.Server.ConnectionTable Methods (==) :: ValencyCounter m -> ValencyCounter m -> Bool Source # (/=) :: ValencyCounter m -> ValencyCounter m -> Bool Source #
Ord ( ValencyCounter m) Source #
Instance details Defined in Ouroboros.Network.Server.ConnectionTable Methods compare :: ValencyCounter m -> ValencyCounter m -> Ordering Source # (<) :: ValencyCounter m -> ValencyCounter m -> Bool Source # (<=) :: ValencyCounter m -> ValencyCounter m -> Bool Source # (>) :: ValencyCounter m -> ValencyCounter m -> Bool Source # (>=) :: ValencyCounter m -> ValencyCounter m -> Bool Source # max :: ValencyCounter m -> ValencyCounter m -> ValencyCounter m Source # min :: ValencyCounter m -> ValencyCounter m -> ValencyCounter m Source #

data NetworkMutableState addr Source #

Mutable state maintained by the network component.

Constructors

NetworkMutableState
Fields nmsConnectionTable :: ConnectionTable IO addr `ConnectionTable` which maintains information about current upstream and downstream connections. nmsPeerStates :: StrictTVar IO ( PeerStates IO addr) `PeerStates` which maintains state of each downstream / upstream peer that errored, misbehaved or was not interesting to us.

data SomeResponderApplication addr bytes m b where Source #

Wrapper for OuroborosResponderApplication and OuroborosInitiatorAndResponderApplication.

Constructors

SomeResponderApplication :: forall appType addr bytes m a b. HasResponder appType ~ True => OuroborosApplication appType addr bytes m a b -> SomeResponderApplication addr bytes m b

newNetworkMutableState :: IO ( NetworkMutableState addr) Source #

newNetworkMutableStateSTM :: STM ( NetworkMutableState addr) Source #

cleanNetworkMutableState :: NetworkMutableState addr -> IO () Source #

Clean PeerStates within NetworkMutableState every 200s

data AcceptedConnectionsLimit Source #

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

Constructors

AcceptedConnectionsLimit

Fields

acceptedConnectionsHardLimit :: ! Word32

Hard limit of accepted connections.
acceptedConnectionsSoftLimit :: ! Word32

Soft limit of accepted connections. If we are above this threshold, we will start rate limiting.
acceptedConnectionsDelay :: ! DiffTime

Max delay for limiting accepted connections. We use linear regression starting from 0 at the soft limit up to acceptedConnectionDelay at the hard limit.

Instances

Instances details

Eq AcceptedConnectionsLimit Source #
Instance details Defined in Ouroboros.Network.Server.RateLimiting Methods (==) :: AcceptedConnectionsLimit -> AcceptedConnectionsLimit -> Bool Source # (/=) :: AcceptedConnectionsLimit -> AcceptedConnectionsLimit -> Bool Source #
Ord AcceptedConnectionsLimit Source #
Instance details Defined in Ouroboros.Network.Server.RateLimiting Methods compare :: AcceptedConnectionsLimit -> AcceptedConnectionsLimit -> Ordering Source # (<) :: AcceptedConnectionsLimit -> AcceptedConnectionsLimit -> Bool Source # (<=) :: AcceptedConnectionsLimit -> AcceptedConnectionsLimit -> Bool Source # (>) :: AcceptedConnectionsLimit -> AcceptedConnectionsLimit -> Bool Source # (>=) :: AcceptedConnectionsLimit -> AcceptedConnectionsLimit -> Bool Source # max :: AcceptedConnectionsLimit -> AcceptedConnectionsLimit -> AcceptedConnectionsLimit Source # min :: AcceptedConnectionsLimit -> AcceptedConnectionsLimit -> AcceptedConnectionsLimit Source #
Show AcceptedConnectionsLimit Source #
Instance details Defined in Ouroboros.Network.Server.RateLimiting Methods showsPrec :: Int -> AcceptedConnectionsLimit -> ShowS Source # show :: AcceptedConnectionsLimit -> String Source # showList :: [ AcceptedConnectionsLimit ] -> ShowS Source #

data ConnectionId addr Source #

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 .

Constructors

ConnectionId
Fields localAddress :: !addr remoteAddress :: !addr

Instances

Instances details

Eq addr => Eq ( ConnectionId addr) Source #
Instance details Defined in Ouroboros.Network.ConnectionId Methods (==) :: ConnectionId addr -> ConnectionId addr -> Bool Source # (/=) :: ConnectionId addr -> ConnectionId addr -> Bool Source #
Ord addr => Ord ( ConnectionId addr) Source #
Instance details Defined in Ouroboros.Network.ConnectionId Methods compare :: ConnectionId addr -> ConnectionId addr -> Ordering Source # (<) :: ConnectionId addr -> ConnectionId addr -> Bool Source # (<=) :: ConnectionId addr -> ConnectionId addr -> Bool Source # (>) :: ConnectionId addr -> ConnectionId addr -> Bool Source # (>=) :: ConnectionId addr -> ConnectionId addr -> Bool Source # max :: ConnectionId addr -> ConnectionId addr -> ConnectionId addr Source # min :: ConnectionId addr -> ConnectionId addr -> ConnectionId addr Source #
Show addr => Show ( ConnectionId addr) Source #
Instance details Defined in Ouroboros.Network.ConnectionId Methods showsPrec :: Int -> ConnectionId addr -> ShowS Source # show :: ConnectionId addr -> String Source # showList :: [ ConnectionId addr] -> ShowS Source #
Generic ( ConnectionId addr) Source #
Instance details Defined in Ouroboros.Network.ConnectionId Associated Types type Rep ( ConnectionId addr) :: Type -> Type Source # Methods from :: ConnectionId addr -> Rep ( ConnectionId addr) x Source # to :: Rep ( ConnectionId addr) x -> ConnectionId addr Source #
Hashable a => Hashable ( ConnectionId a) Source #
Instance details Defined in Ouroboros.Network.ConnectionId Methods hashWithSalt :: Int -> ConnectionId a -> Int Source # hash :: ConnectionId a -> Int Source #
Typeable addr => NoThunks ( ConnectionId addr) Source #
Instance details Defined in Ouroboros.Network.ConnectionId Methods noThunks :: Context -> ConnectionId addr -> IO ( Maybe ThunkInfo ) Source # wNoThunks :: Context -> ConnectionId addr -> IO ( Maybe ThunkInfo ) Source # showTypeOf :: Proxy ( ConnectionId addr) -> String Source #
type Rep ( ConnectionId addr) Source #
Instance details Defined in Ouroboros.Network.ConnectionId type Rep ( ConnectionId addr) = D1 (' MetaData "ConnectionId" "Ouroboros.Network.ConnectionId" "ouroboros-network-framework-0.1.0.1-8Cos8Lgj9CwATl9eblNk02" ' False ) ( C1 (' MetaCons "ConnectionId" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "localAddress") ' NoSourceUnpackedness ' SourceStrict ' DecidedStrict ) ( Rec0 addr) :*: S1 (' MetaSel (' Just "remoteAddress") ' NoSourceUnpackedness ' SourceStrict ' DecidedStrict ) ( Rec0 addr)))

withServerNode Source #

Arguments

:: forall vNumber vData t fd addr b. ( Ord vNumber, Typeable vNumber, Show vNumber, Ord addr)
=> Snocket IO fd addr
-> NetworkServerTracers addr vNumber
-> NetworkMutableState addr
-> AcceptedConnectionsLimit
-> addr
-> Codec ( Handshake vNumber Term ) DeserialiseFailure IO ByteString
-> ProtocolTimeLimits ( Handshake vNumber Term )
-> VersionDataCodec Term vNumber vData
-> (vData -> vData -> Accept vData)
-> Versions vNumber vData ( SomeResponderApplication addr ByteString IO b)	The mux application that will be run on each incoming connection from a given address. Note that if `MuxClientAndServerApplication` is returned, the connection will run a full duplex set of mini-protocols.
-> ErrorPolicies
-> (addr -> Async Void -> IO t)	callback which takes the `Async` of the thread that is running the server. Note: the server thread will terminate when the callback returns or throws an exception.
-> IO t

Run a server application. It will listen on the given address for incoming connection, otherwise like withServerNode'.

withServerNode' Source #

Arguments

:: forall vNumber vData t fd addr b. ( Ord vNumber, Typeable vNumber, Show vNumber, Ord addr)
=> Snocket IO fd addr
-> NetworkServerTracers addr vNumber
-> NetworkMutableState addr
-> AcceptedConnectionsLimit
-> fd
-> Codec ( Handshake vNumber Term ) DeserialiseFailure IO ByteString
-> ProtocolTimeLimits ( Handshake vNumber Term )
-> VersionDataCodec Term vNumber vData
-> (vData -> vData -> Accept vData)
-> Versions vNumber vData ( SomeResponderApplication addr ByteString IO b)	The mux application that will be run on each incoming connection from a given address. Note that if `MuxClientAndServerApplication` is returned, the connection will run a full duplex set of mini-protocols.
-> ErrorPolicies
-> (addr -> Async Void -> IO t)	callback which takes the `Async` of the thread that is running the server. Note: the server thread will terminate when the callback returns or throws an exception.
-> IO t

Run a server application on the provided socket. The socket must be ready to accept connections. The server thread runs using withAsync function, which means that it will terminate when the callback terminates or throws an exception.

TODO: we should track connections in the state and refuse connections from peers we are already connected to. This is also the right place to ban connection from peers which missbehaved.

The server will run handshake protocol on each incoming connection. We assume that each versin negotiation message should fit into maxTransmissionUnit (~5k bytes).

Note: it will open a socket in the current thread and pass it to the spawned thread which runs the server. This makes it useful for testing, where we need to guarantee that a socket is open before we try to connect to it.

connectToNode Source #

Arguments

:: forall appType vNumber vData fd addr a b. ( Ord vNumber, Typeable vNumber, Show vNumber, HasInitiator appType ~ True )
=> Snocket IO fd addr
-> Codec ( Handshake vNumber Term ) DeserialiseFailure IO ByteString
-> ProtocolTimeLimits ( Handshake vNumber Term )
-> VersionDataCodec Term vNumber vData
-> NetworkConnectTracers addr vNumber
-> (vData -> vData -> Accept vData)
-> Versions vNumber vData ( OuroborosApplication appType addr ByteString IO a b)	application to run over the connection
-> Maybe addr	local address; the created socket will bind to it
-> addr	remote address
-> IO ()

Connect to a remote node. It is using bracket to enclose the underlying socket acquisition. This implies that when the continuation exits the underlying bearer will get closed.

The connection will start with handshake protocol sending Versions to the remote peer. It must fit into maxTransmissionUnit (~5k bytes).

Exceptions thrown by MuxApplication are rethrown by connectTo .

connectToNodeSocket Source #

Arguments

:: forall appType vNumber vData a b. ( Ord vNumber, Typeable vNumber, Show vNumber, HasInitiator appType ~ True )
=> IOManager
-> Codec ( Handshake vNumber Term ) DeserialiseFailure IO ByteString
-> ProtocolTimeLimits ( Handshake vNumber Term )
-> VersionDataCodec Term vNumber vData
-> NetworkConnectTracers SockAddr vNumber
-> (vData -> vData -> Accept vData)
-> Versions vNumber vData ( OuroborosApplication appType SockAddr ByteString IO a b)	application to run over the connection
-> Socket
-> IO ()

connectToNode' Source #

Arguments

:: forall appType vNumber vData fd addr a b. ( Ord vNumber, Typeable vNumber, Show vNumber, HasInitiator appType ~ True )
=> Snocket IO fd addr
-> Codec ( Handshake vNumber Term ) DeserialiseFailure IO ByteString
-> ProtocolTimeLimits ( Handshake vNumber Term )
-> VersionDataCodec Term vNumber vData
-> NetworkConnectTracers addr vNumber
-> (vData -> vData -> Accept vData)
-> Versions vNumber vData ( OuroborosApplication appType addr ByteString IO a b)	application to run over the connection
-> fd
-> IO ()

Connect to a remote node using an existing socket. It is up to to caller to ensure that the socket is closed in case of an exception.

The connection will start with handshake protocol sending Versions to the remote peer. It must fit into maxTransmissionUnit (~5k bytes).

Exceptions thrown by MuxApplication are rethrown by connectTo .

Traces

data NetworkConnectTracers addr vNumber Source #

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

Constructors

NetworkConnectTracers
Fields nctMuxTracer :: Tracer IO ( WithMuxBearer ( ConnectionId addr) MuxTrace ) low level mux-network tracer, which logs mux sdu (send and received) and other low level multiplexing events. nctHandshakeTracer :: Tracer IO ( WithMuxBearer ( ConnectionId addr) ( TraceSendRecv ( Handshake vNumber Term ))) handshake protocol tracer; it is important for analysing version negotation mismatches.

nullNetworkConnectTracers :: NetworkConnectTracers addr vNumber Source #

debuggingNetworkConnectTracers :: ( Show addr, Show vNumber) => NetworkConnectTracers addr vNumber Source #

data NetworkServerTracers addr vNumber Source #

Tracers required by a server which handles inbound connections.

Constructors

NetworkServerTracers

Fields

nstMuxTracer :: Tracer IO ( WithMuxBearer ( ConnectionId addr) MuxTrace )

low level mux-network tracer, which logs mux sdu (send and received) and other low level multiplexing events.
nstHandshakeTracer :: Tracer IO ( WithMuxBearer ( ConnectionId addr) ( TraceSendRecv ( Handshake vNumber Term )))

handshake protocol tracer; it is important for analysing version negotation mismatches.
nstErrorPolicyTracer :: Tracer IO ( WithAddr addr ErrorPolicyTrace )

error policy tracer; must not be nullTracer , otherwise all the exceptions which are not matched by any error policy will be caught and not logged or rethrown.
nstAcceptPolicyTracer :: Tracer IO AcceptConnectionsPolicyTrace

tracing rate limiting of accepting connections.

nullNetworkServerTracers :: NetworkServerTracers addr vNumber Source #

debuggingNetworkServerTracers :: ( Show addr, Show vNumber) => NetworkServerTracers addr vNumber Source #

data AcceptConnectionsPolicyTrace Source #

Trace for the AcceptConnectionsLimit policy.

Constructors

ServerTraceAcceptConnectionRateLimiting DiffTime Int
ServerTraceAcceptConnectionHardLimit Word32
ServerTraceAcceptConnectionResume Int

Instances

Instances details

Eq AcceptConnectionsPolicyTrace Source #
Instance details Defined in Ouroboros.Network.Server.RateLimiting Methods (==) :: AcceptConnectionsPolicyTrace -> AcceptConnectionsPolicyTrace -> Bool Source # (/=) :: AcceptConnectionsPolicyTrace -> AcceptConnectionsPolicyTrace -> Bool Source #
Ord AcceptConnectionsPolicyTrace Source #
Instance details Defined in Ouroboros.Network.Server.RateLimiting Methods compare :: AcceptConnectionsPolicyTrace -> AcceptConnectionsPolicyTrace -> Ordering Source # (<) :: AcceptConnectionsPolicyTrace -> AcceptConnectionsPolicyTrace -> Bool Source # (<=) :: AcceptConnectionsPolicyTrace -> AcceptConnectionsPolicyTrace -> Bool Source # (>) :: AcceptConnectionsPolicyTrace -> AcceptConnectionsPolicyTrace -> Bool Source # (>=) :: AcceptConnectionsPolicyTrace -> AcceptConnectionsPolicyTrace -> Bool Source # max :: AcceptConnectionsPolicyTrace -> AcceptConnectionsPolicyTrace -> AcceptConnectionsPolicyTrace Source # min :: AcceptConnectionsPolicyTrace -> AcceptConnectionsPolicyTrace -> AcceptConnectionsPolicyTrace Source #
Show AcceptConnectionsPolicyTrace Source #
Instance details Defined in Ouroboros.Network.Server.RateLimiting Methods showsPrec :: Int -> AcceptConnectionsPolicyTrace -> ShowS Source # show :: AcceptConnectionsPolicyTrace -> String Source # showList :: [ AcceptConnectionsPolicyTrace ] -> ShowS Source #

Helper function for creating servers

fromSnocket Source #

Arguments

:: forall fd addr. Ord addr
=> ConnectionTable IO addr
-> Snocket IO fd addr
-> fd	socket or handle
-> IO ( Socket addr fd)

Make a server-compatible socket from a network socket.

beginConnection Source #

Arguments

:: forall vNumber vData addr st fd. ( Ord vNumber, Typeable vNumber, Show vNumber)
=> Snocket IO fd addr
-> Tracer IO ( WithMuxBearer ( ConnectionId addr) MuxTrace )
-> Tracer IO ( WithMuxBearer ( ConnectionId addr) ( TraceSendRecv ( Handshake vNumber Term )))
-> Codec ( Handshake vNumber Term ) DeserialiseFailure IO ByteString
-> ProtocolTimeLimits ( Handshake vNumber Term )
-> VersionDataCodec Term vNumber vData
-> (vData -> vData -> Accept vData)
-> ( Time -> addr -> st -> STM (AcceptConnection st vNumber vData addr IO ByteString ))	either accept or reject a connection.
-> BeginConnection addr fd st ()

Accept or reject incoming connection based on the current state and address of the incoming connection.

Re-export of PeerStates

data PeerStates m addr Source #

Map from addresses to PeerState s; it will be be shared in a StrictTVar .

Abstracting t is useful for tests, the IO version will use Time IO .

Instances

Instances details

Eq addr => Eq ( PeerStates IO addr) Source #
Instance details Defined in Ouroboros.Network.Subscription.PeerState Methods (==) :: PeerStates IO addr -> PeerStates IO addr -> Bool Source # (/=) :: PeerStates IO addr -> PeerStates IO addr -> Bool Source #
Show addr => Show ( PeerStates IO addr) Source #
Instance details Defined in Ouroboros.Network.Subscription.PeerState Methods showsPrec :: Int -> PeerStates IO addr -> ShowS Source # show :: PeerStates IO addr -> String Source # showList :: [ PeerStates IO addr] -> ShowS Source #

Re-export connection table functions

newConnectionTable :: MonadSTM m => m ( ConnectionTable m addr) Source #

refConnection :: ( MonadSTM m, Ord addr) => ConnectionTable m addr -> addr -> ValencyCounter m -> m ConnectionTableRef Source #

addConnection Source #

Arguments

:: forall m addr. ( MonadSTM m, Ord addr)
=> ConnectionTable m addr
-> addr
-> addr
-> Maybe ( ValencyCounter m)	Optional ValencyCounter, used by subscription worker and set to Nothing when called by a local server.
-> STM m ()

Insert a new connection into the ConnectionTable.

removeConnection :: forall m addr. ( MonadSTM m, Ord addr) => ConnectionTable m addr -> addr -> addr -> m () Source #

newValencyCounter Source #

Arguments

:: MonadSTM m
=> ConnectionTable m addr
-> Int	Desired valency, that is number of connections a subscription worker will attempt to maintain.
-> STM m ( ValencyCounter m)

Create a new ValencyCounter

addValencyCounter :: MonadSTM m => ValencyCounter m -> STM m () Source #

Add a connection.

remValencyCounter :: MonadSTM m => ValencyCounter m -> STM m () Source #

Remove a connection.

waitValencyCounter :: MonadSTM m => ValencyCounter m -> STM m () Source #

Wait until ValencyCounter becomes positive, used for detecting when we can create new connections.

readValencyCounter :: MonadSTM m => ValencyCounter m -> STM m Int Source #

Returns current ValencyCounter value, represent the number of additional connections that can be created. May be negative.

Auxiliary functions

sockAddrFamily :: SockAddr -> Family Source #

Orphan instances

Hashable SockAddr Source #
Instance details Methods hashWithSalt :: Int -> SockAddr -> Int Source # hash :: SockAddr -> Int Source #