Network.Control

network-control-0.1.4: Library to control network protocols

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.