Safe Haskell	None
Language	Haskell2010

Network.Control

Description

Common parts to control network protocols. This library assumes that Int is 64bit.

Synopsis

defaultMaxStreams :: Int
defaultMaxStreamData :: Int
defaultMaxData :: Int
data TxFlow = TxFlow {
- txfSent :: Int
- txfLimit :: Int
}
newTxFlow :: WindowSize -> TxFlow
txWindowSize :: TxFlow -> WindowSize
type WindowSize = Int
data RxFlow = RxFlow {
- rxfBufSize :: Int
- rxfConsumed :: Int
- rxfReceived :: Int
- rxfLimit :: Int
}
newRxFlow :: WindowSize -> RxFlow
rxWindowSize :: RxFlow -> WindowSize
data FlowControlType
- = FCTWindowUpdate
- | FCTMaxData
maybeOpenRxWindow :: Int -> FlowControlType -> RxFlow -> (RxFlow, Maybe Int)
checkRxLimit :: Int -> RxFlow -> (RxFlow, Bool)
empty :: Int -> LRUCache k v
lookup :: Ord k => k -> LRUCache k v -> Maybe v
delete :: Ord k => k -> LRUCache k v -> LRUCache k v
insert :: Ord k => k -> v -> LRUCache k v -> LRUCache k v
data LRUCache k v
data Rate
newRate :: IO Rate
getRate :: Rate -> IO Int
addRate :: Rate -> Int -> IO Int

Documentation

defaultMaxStreams :: Int #

Default max streams. (64)

defaultMaxStreamData :: Int #

Default max data of a stream. (256K bytes)

defaultMaxData :: Int #

Default max data of a connection.

By default, this is set to defaultMaxStreams * defaultMaxStreamData. This ensures that streams that are not currently handled cannot exhaust the connection window.

If you use a smaller connection window size, you must ensure that if you are handling fewer concurrent streams than allowed by defaultMaxStreams, that the unhandled streams cannot exhaust the connection window, or risk the entire system deadlocking.

data TxFlow #

Flow for sending

-------------------------------------->
       ^           ^
    txfSent    txfLimit

       |-----------| The size which this node can send
       txWindowSize

Constructors

TxFlow
Fields txfSent :: Int The total size of sent data. txfLimit :: Int The total size of data which can be sent.

Instances

Instances details

Show TxFlow #
Instance details Defined in Network.Control.Flow Methods showsPrec :: Int -> TxFlow -> ShowS # show :: TxFlow -> String # showList :: [TxFlow] -> ShowS #
Eq TxFlow #
Instance details Defined in Network.Control.Flow Methods (==) :: TxFlow -> TxFlow -> Bool # (/=) :: TxFlow -> TxFlow -> Bool #

newTxFlow :: WindowSize -> TxFlow #

Creating TX flow with a receive buffer size.

txWindowSize :: TxFlow -> WindowSize #

txfLimit - txfSent.

type WindowSize = Int #

Window size.

data RxFlow #

Flow for receiving.

The goal of RxFlow is to ensure that our network peer does not send us data faster than we can consume it. We therefore impose a maximum number of unconsumed bytes that we are willing to receive from the peer, which we refer to as the buffer size:

                   rxfBufSize
          |---------------------------|
-------------------------------------------->
          ^              ^
     rxfConsumed    rxvReceived

The peer does not know of course how many bytes we have consumed of the data that they sent us, so they keep track of their own limit of how much data they are allowed to send. We keep track of this limit also:

                   rxfBufSize
          |---------------------------|
-------------------------------------------->
          ^              ^       ^
     rxfConsumed    rxvReceived  |
                              rxfLimit

Each time we receive data from the peer, we check that they do not exceed the limit (checkRxLimit). When we consume data, we periodically send the peer an update (known as a _window update_) of what their new limit is (maybeOpenRxWindow). To decrease overhead, we only this if the window update is at least half the window size.

Constructors

RxFlow

Fields

rxfBufSize :: Int
Maxinum number of unconsumed bytes the peer can send us
See discussion above for details.
rxfConsumed :: Int
How much of the data that the peer has sent us have we consumed?
This is an absolute number: the total about of bytes consumed over the lifetime of the connection or stream (i.e., not relative to the window).
rxfReceived :: Int
How much data have we received from the peer?
Like rxfConsumed, this is an absolute number.
rxfLimit :: Int
Current limit on how many bytes the peer is allowed to send us.
Like 'rxfConsumed, this is an absolute number.

Instances

Instances details

Show RxFlow #
Instance details Defined in Network.Control.Flow Methods showsPrec :: Int -> RxFlow -> ShowS # show :: RxFlow -> String # showList :: [RxFlow] -> ShowS #
Eq RxFlow #
Instance details Defined in Network.Control.Flow Methods (==) :: RxFlow -> RxFlow -> Bool # (/=) :: RxFlow -> RxFlow -> Bool #

newRxFlow :: WindowSize -> RxFlow #

Creating RX flow with an initial window size.

rxWindowSize :: RxFlow -> WindowSize #

rxfLimit - rxfReceived.

This is the number of bytes the peer is still allowed to send before they must wait for a window update; see RxFlow for details.

data FlowControlType #

The representation of window size update.

Constructors

FCTWindowUpdate	HTTP/2 style
FCTMaxData	QUIC style

maybeOpenRxWindow #

Arguments

:: Int	The consumed size.
-> FlowControlType
-> RxFlow
-> (RxFlow, Maybe Int)	`Just` if the size should be informed to the peer.

Record that we have consumed some received data

May return a window update; see RxFlow for details.

checkRxLimit #

Arguments

:: Int	The size of received data.
-> RxFlow
-> (RxFlow, Bool)	Acceptable if `True`.

Checking if received data is acceptable against the current window.

empty #

Arguments

:: Int	The size of `LRUCache`.
-> LRUCache k v

Empty LRUCache.

lookup :: Ord k => k -> LRUCache k v -> Maybe v #

Looking up.

delete :: Ord k => k -> LRUCache k v -> LRUCache k v #

Deleting.

insert :: Ord k => k -> v -> LRUCache k v -> LRUCache k v #

Inserting.

data LRUCache k v #

Sized cache based on least recently used.

data Rate #

Type for rating.

newRate :: IO Rate #

Creating a new Rate.

getRate :: Rate -> IO Int #

Getting the current rate. If one or more seconds have passed since the previous call, the counter is re-initialized with 1 and it is returned. Otherwise, incremented counter number is returned.

addRate :: Rate -> Int -> IO Int #

Getting the current rate. If one or more seconds have passed since the previous call, the counter is re-initialized with the second argument and it is returned. Otherwise, increased counter number is returned.