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
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. (1M bytes)

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.

                rxfBufSize
       |------------------------|
-------------------------------------->
       ^            ^           ^
  rxfConsumed   rxfReceived  rxfLimit

                    |-----------| The size which the peer can send
                       Window

Constructors

RxFlow
Fields rxfBufSize :: Int Receive buffer size. rxfConsumed :: Int The total size which the application is consumed. rxfReceived :: Int The total already-received size. rxfLimit :: Int The total size which can be recived.

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.

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.

When an application consumed received data, this function should be called to update rxfConsumed. If the available buffer size is less than the half of the total buffer size. the representation of window size update is returned.

Example:

                rxfBufSize
       |------------------------|
-------------------------------------->
       ^            ^           ^
  rxfConsumed   rxfReceived  rxfLimit
                    |01234567890|

In the case where the window update should be informed to the peer,
rxfConsumed and rxfLimit move to the right. The difference
of old and new rxfLimit is window update.

                  rxfBufSize
         |------------------------|
-------------------------------------->
         ^          ^             ^
    rxfConsumed rxfReceived    rxfLimit
                    |0123456789012| : window glows

Otherwise, only rxfConsumed moves to the right.

                rxfBufSize
       |------------------------|
-------------------------------------->
         ^          ^           ^
    rxfConsumed rxfReceived  rxfLimit
                    |01234567890| : window stays

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.