| Safe Haskell | Safe-Inferred |
|---|---|
| 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 {}
- 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
- maybeOpenRxWindow :: Int -> FlowControlType -> RxFlow -> (RxFlow, Maybe Int)
- checkRxLimit :: Int -> RxFlow -> (RxFlow, Bool)
- data LRUCache k v
- empty :: Int -> LRUCache k v
- insert :: Ord k => k -> v -> LRUCache k v -> LRUCache k v
- delete :: Ord k => k -> LRUCache k v -> LRUCache k v
- lookup :: Ord k => k -> LRUCache k v -> Maybe v
- lookup' :: Ord k => k -> LRUCache k v -> Maybe (v, LRUCache k v)
- data LRUCacheRef k v
- newLRUCacheRef :: Int -> IO (LRUCacheRef k v)
- cached :: Ord k => LRUCacheRef k v -> k -> IO v -> IO (v, Bool)
- cached' :: Ord k => LRUCacheRef k v -> k -> IO (Maybe v)
- empty' :: Int -> Int64 -> LRUCache k v
- data Rate
- newRate :: IO Rate
- getRate :: Rate -> IO Int
- addRate :: Rate -> Int -> IO Int
Flow control
This is based on the total approach of QUIC rather than the difference approach of HTTP/2 because QUIC'one is considered safer. Please refer to Using HTTP/3 Stream Limits in HTTP/2 to understand that QUIC's approaches are better though its topic is about stream concurrency.
Constants for flow control.
defaultMaxStreams :: Int Source #
Default max streams. (64)
defaultMaxStreamData :: Int Source #
Default max data of a stream. (256K bytes)
defaultMaxData :: Int Source #
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.
Flow control for sending
Flow for sending
-------------------------------------->
^ ^
txfSent txfLimit
|-----------| The size which this node can send
txWindowSize
Constructors
| TxFlow | |
newTxFlow :: WindowSize -> TxFlow Source #
Creating TX flow with a receive buffer size.
txWindowSize :: TxFlow -> WindowSize Source #
type WindowSize = Int Source #
Window size.
Flow control for receiving
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
| |
newRxFlow :: WindowSize -> RxFlow Source #
Creating RX flow with an initial window size.
rxWindowSize :: RxFlow -> WindowSize Source #
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 Source #
The representation of window size update.
Constructors
| FCTWindowUpdate | HTTP/2 style |
| FCTMaxData | QUIC style |
Arguments
| :: Int | The consumed size. |
| -> FlowControlType | |
| -> RxFlow | |
| -> (RxFlow, Maybe Int) |
|
Record that we have consumed some received data
May return a window update; see RxFlow for details.
Checking if received data is acceptable against the current window.
LRU cache
Sized cache based on least recently used.
lookup' :: Ord k => k -> LRUCache k v -> Maybe (v, LRUCache k v) Source #
Looking up and changing priority. O(log n)
IO
data LRUCacheRef k v Source #
newLRUCacheRef :: Int -> IO (LRUCacheRef k v) Source #
Internal
Empty LRUCache. O(1)