Safe Haskell	None
Language	Haskell2010

Ouroboros.Network.Subscription.PeerState

Contents

PeerStates and its operations
Re-exports
Auxiliary functions

Description

This module contains peer state management and error policies.

Synopsis

data SuspendDecision t
- = SuspendPeer !t !t
- | SuspendConsumer !t
- | Throw
suspend :: forall (m :: Type -> Type). Ord (Async m ()) => Maybe (PeerState m) -> SuspendDecision Time -> (Set (Async m ()), Maybe (PeerState m))
data PeerState (m :: Type -> Type)
- = HotPeer !(Set (Async m ())) !(Set (Async m ()))
- | SuspendedConsumer !(Set (Async m ())) !Time
- | SuspendedPeer !Time !Time
- | ColdPeer
threadsToCancel :: forall (m :: Type -> Type) diffTime. Ord (Async m ()) => PeerState m -> SuspendDecision diffTime -> Set (Async m ())
data PeerStates (m :: Type -> Type) addr where
- PeerStates :: forall addr (m :: Type -> Type). !(Map addr (PeerState m)) -> PeerStates m addr
- ThrowException :: forall e (m :: Type -> Type) addr. Exception e => e -> PeerStates m addr
newPeerStatesVar :: MonadSTM m => m (StrictTVar m (PeerStates m addr))
newPeerStatesVarSTM :: forall (m :: Type -> Type) addr. MonadSTM m => STM m (StrictTVar m (PeerStates m addr))
cleanPeerStates :: (MonadDelay m, MonadTimer m) => DiffTime -> StrictTVar m (PeerStates m addr) -> m ()
runSuspendDecision :: forall (m :: Type -> Type) addr e. (Ord addr, Ord (Async m ()), Exception e) => Time -> addr -> e -> SuspendDecision DiffTime -> PeerStates m addr -> (PeerStates m addr, Set (Async m ()))
registerConsumer :: forall (m :: Type -> Type) addr. (Ord addr, Ord (Async m ())) => addr -> Async m () -> PeerStates m addr -> PeerStates m addr
unregisterConsumer :: forall (m :: Type -> Type) addr. (Ord addr, Ord (Async m ())) => addr -> Async m () -> PeerStates m addr -> PeerStates m addr
registerProducer :: forall (m :: Type -> Type) addr. (Ord addr, Ord (Async m ())) => addr -> Async m () -> PeerStates m addr -> PeerStates m addr
unregisterProducer :: forall (m :: Type -> Type) addr. (Ord addr, Ord (Async m ())) => addr -> Async m () -> PeerStates m addr -> PeerStates m addr
type BeforeConnect (m :: Type -> Type) s addr = Time -> addr -> s -> STM m (ConnectDecision s)
data ConnectDecision s
- = AllowConnection !s
- | DisallowConnection !s
- | OnlyAccept !s
runBeforeConnect :: (MonadMonotonicTime m, MonadSTM m) => StrictTVar m s -> BeforeConnect m s addr -> addr -> m Bool
beforeConnectTx :: forall (m :: Type -> Type) addr. (MonadSTM m, Ord addr) => BeforeConnect m (PeerStates m addr) addr
data DiffTime
alterAndLookup :: forall k s a. Ord k => (Maybe a -> (s, Maybe a)) -> k -> Map k a -> (Map k a, Maybe s)

Documentation

data SuspendDecision t Source #

Semigroup of commands which acts on PeerState. The t variable might be initiated to DiffTime or Time m.

This semigroup allows to either suspend both consumer and producer or just the consumer part.

Constructors

SuspendPeer !t !t	peer is suspend; The first `t` is the time until which a local producer is suspended, the second one is the time until which a local consumer is suspended.
SuspendConsumer !t	suspend local consumer / initiator side until `t` (this mean we are not allowing to communicate with the producer / responder of a remote peer).
Throw	throw an error from the main thread.

Instances

Instances details

Functor SuspendDecision Source #
Instance details Defined in Ouroboros.Network.Subscription.PeerState Methods fmap :: (a -> b) -> SuspendDecision a -> SuspendDecision b # (<$) :: a -> SuspendDecision b -> SuspendDecision a #
Ord t => Semigroup (SuspendDecision t) Source #	The semigroup instance. Note that composing `SuspendPeer` with `SuspendConsumer` gives `SuspendPeer`. `SuspendPeer` and `SuspendConsumer` form a sub-semigroup.
Instance details Defined in Ouroboros.Network.Subscription.PeerState Methods (<>) :: SuspendDecision t -> SuspendDecision t -> SuspendDecision t # sconcat :: NonEmpty (SuspendDecision t) -> SuspendDecision t # stimes :: Integral b => b -> SuspendDecision t -> SuspendDecision t #
Show t => Show (SuspendDecision t) Source #
Instance details Defined in Ouroboros.Network.Subscription.PeerState Methods showsPrec :: Int -> SuspendDecision t -> ShowS # show :: SuspendDecision t -> String # showList :: [SuspendDecision t] -> ShowS #
Eq t => Eq (SuspendDecision t) Source #
Instance details Defined in Ouroboros.Network.Subscription.PeerState Methods (==) :: SuspendDecision t -> SuspendDecision t -> Bool # (/=) :: SuspendDecision t -> SuspendDecision t -> Bool #
Ord t => Ord (SuspendDecision t) Source #
Instance details Defined in Ouroboros.Network.Subscription.PeerState Methods compare :: SuspendDecision t -> SuspendDecision t -> Ordering # (<) :: SuspendDecision t -> SuspendDecision t -> Bool # (<=) :: SuspendDecision t -> SuspendDecision t -> Bool # (>) :: SuspendDecision t -> SuspendDecision t -> Bool # (>=) :: SuspendDecision t -> SuspendDecision t -> Bool # max :: SuspendDecision t -> SuspendDecision t -> SuspendDecision t # min :: SuspendDecision t -> SuspendDecision t -> SuspendDecision t #
SAct (SuspendDecision Time) (Maybe (PeerState m)) Source #	Action of `SuspendDecision` on `Maybe PeerState`. We use this action together with `alter` function. Note: `SuspendDecision` does not act on `PeerState`, only the sub-semigroup generated by `SuspendConsumer` and `SuspendPeer` does.
Instance details Defined in Ouroboros.Network.Subscription.PeerState Methods (<\|) :: Maybe (PeerState m) -> SuspendDecision Time -> Maybe (PeerState m) #

suspend :: forall (m :: Type -> Type). Ord (Async m ()) => Maybe (PeerState m) -> SuspendDecision Time -> (Set (Async m ()), Maybe (PeerState m)) Source #

Action of SuspendDecision on Maybe PeerState. Action laws are only satisfied for the submonoid form by SuspendPeer and SuspendConsumer.

PeerStates and its operations

data PeerState (m :: Type -> Type) Source #

Constructors

HotPeer !(Set (Async m ())) !(Set (Async m ()))	active peer with its producers and consumer threads
SuspendedConsumer !(Set (Async m ())) !Time	suspended consumer: with producer threads and time until the consumer is suspended
SuspendedPeer !Time !Time	suspended peer: producer & consumer suspend time
ColdPeer	peer with no opened connections in either direction

Instances

Instances details

MonadAsync m => Show (PeerState m) Source #
Instance details Defined in Ouroboros.Network.Subscription.PeerState Methods showsPrec :: Int -> PeerState m -> ShowS # show :: PeerState m -> String # showList :: [PeerState m] -> ShowS #
Eq (Async m ()) => Eq (PeerState m) Source #
Instance details Defined in Ouroboros.Network.Subscription.PeerState Methods (==) :: PeerState m -> PeerState m -> Bool # (/=) :: PeerState m -> PeerState m -> Bool #
Ord (Async m ()) => Ord (PeerState m) Source #
Instance details Defined in Ouroboros.Network.Subscription.PeerState Methods compare :: PeerState m -> PeerState m -> Ordering # (<) :: PeerState m -> PeerState m -> Bool # (<=) :: PeerState m -> PeerState m -> Bool # (>) :: PeerState m -> PeerState m -> Bool # (>=) :: PeerState m -> PeerState m -> Bool # max :: PeerState m -> PeerState m -> PeerState m # min :: PeerState m -> PeerState m -> PeerState m #
SAct (SuspendDecision Time) (Maybe (PeerState m)) Source #	Action of `SuspendDecision` on `Maybe PeerState`. We use this action together with `alter` function. Note: `SuspendDecision` does not act on `PeerState`, only the sub-semigroup generated by `SuspendConsumer` and `SuspendPeer` does.
Instance details Defined in Ouroboros.Network.Subscription.PeerState Methods (<\|) :: Maybe (PeerState m) -> SuspendDecision Time -> Maybe (PeerState m) #

threadsToCancel :: forall (m :: Type -> Type) diffTime. Ord (Async m ()) => PeerState m -> SuspendDecision diffTime -> Set (Async m ()) Source #

Threads which needs to be cancelled when updating the PeerState with SuspendDecision.

data PeerStates (m :: Type -> Type) addr where Source #

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

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

Constructors

PeerStates :: forall addr (m :: Type -> Type). !(Map addr (PeerState m)) -> PeerStates m addr	Map of peer states
ThrowException :: forall e (m :: Type -> Type) addr. Exception e => e -> PeerStates m addr	Or an exception to throw

Instances

Instances details

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

newPeerStatesVar :: MonadSTM m => m (StrictTVar m (PeerStates m addr)) Source #

newPeerStatesVarSTM :: forall (m :: Type -> Type) addr. MonadSTM m => STM m (StrictTVar m (PeerStates m addr)) Source #

cleanPeerStates :: (MonadDelay m, MonadTimer m) => DiffTime -> StrictTVar m (PeerStates m addr) -> m () Source #

Periodically clean PeerState. It will stop when PeerState becomes ThrowException.

runSuspendDecision :: forall (m :: Type -> Type) addr e. (Ord addr, Ord (Async m ()), Exception e) => Time -> addr -> e -> SuspendDecision DiffTime -> PeerStates m addr -> (PeerStates m addr, Set (Async m ())) Source #

Update PeerStates for a given addr, using suspend, and return threads which must be cancelled.

This is more efficient that using the action of SuspendDecision on PeerStates, since it only uses a single dictionary lookup to update the state and return the set of threads to be cancelled.

registerConsumer :: forall (m :: Type -> Type) addr. (Ord addr, Ord (Async m ())) => addr -> Async m () -> PeerStates m addr -> PeerStates m addr Source #

Register consumer in PeerState. This is a partial function which assumes that the PeerState is HotPeer.

unregisterConsumer :: forall (m :: Type -> Type) addr. (Ord addr, Ord (Async m ())) => addr -> Async m () -> PeerStates m addr -> PeerStates m addr Source #

Unregister consumer from a PeerState.

registerProducer :: forall (m :: Type -> Type) addr. (Ord addr, Ord (Async m ())) => addr -> Async m () -> PeerStates m addr -> PeerStates m addr Source #

Register producer in PeerStates. This is a partial function which assumes that the PeerState is either HotPeer or SuspendedConsumer.

unregisterProducer :: forall (m :: Type -> Type) addr. (Ord addr, Ord (Async m ())) => addr -> Async m () -> PeerStates m addr -> PeerStates m addr Source #

type BeforeConnect (m :: Type -> Type) s addr = Time -> addr -> s -> STM m (ConnectDecision s) Source #

Check state before connecting to a remote peer. We will connect only if it retuns True.

data ConnectDecision s Source #

Before connectin with a peer we make a decision to either connect to it or not.

Constructors

AllowConnection !s
DisallowConnection !s
OnlyAccept !s

Instances

Instances details

Functor ConnectDecision Source #
Instance details Defined in Ouroboros.Network.Subscription.PeerState Methods fmap :: (a -> b) -> ConnectDecision a -> ConnectDecision b # (<$) :: a -> ConnectDecision b -> ConnectDecision a #

runBeforeConnect :: (MonadMonotonicTime m, MonadSTM m) => StrictTVar m s -> BeforeConnect m s addr -> addr -> m Bool Source #

Run BeforeConnect callback in a MonadTime monad.

beforeConnectTx :: forall (m :: Type -> Type) addr. (MonadSTM m, Ord addr) => BeforeConnect m (PeerStates m addr) addr Source #

BeforeConnect callback: it updates peer state and return boolean value wheather to connect to it or not. If a peer hasn't been recorded in PeerStates, we add it and try to connect to it.

Re-exports

data DiffTime #

This is a length of time, as measured by a clock. Conversion functions such as fromInteger and realToFrac will treat it as seconds. For example, (0.010 :: DiffTime) corresponds to 10 milliseconds.

It has a precision of one picosecond (= 10^-12 s). Enumeration functions will treat it as picoseconds.

Instances

Instances details

NFData DiffTime
Instance details Defined in Data.Time.Clock.Internal.DiffTime Methods rnf :: DiffTime -> () #
Data DiffTime
Instance details Defined in Data.Time.Clock.Internal.DiffTime Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DiffTime -> c DiffTime # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c DiffTime # toConstr :: DiffTime -> Constr # dataTypeOf :: DiffTime -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c DiffTime) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DiffTime) # gmapT :: (forall b. Data b => b -> b) -> DiffTime -> DiffTime # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DiffTime -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DiffTime -> r # gmapQ :: (forall d. Data d => d -> u) -> DiffTime -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> DiffTime -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> DiffTime -> m DiffTime # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DiffTime -> m DiffTime # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DiffTime -> m DiffTime #
Enum DiffTime
Instance details Defined in Data.Time.Clock.Internal.DiffTime Methods succ :: DiffTime -> DiffTime # pred :: DiffTime -> DiffTime # toEnum :: Int -> DiffTime # fromEnum :: DiffTime -> Int # enumFrom :: DiffTime -> [DiffTime] # enumFromThen :: DiffTime -> DiffTime -> [DiffTime] # enumFromTo :: DiffTime -> DiffTime -> [DiffTime] # enumFromThenTo :: DiffTime -> DiffTime -> DiffTime -> [DiffTime] #
Num DiffTime
Instance details Defined in Data.Time.Clock.Internal.DiffTime Methods (+) :: DiffTime -> DiffTime -> DiffTime # (-) :: DiffTime -> DiffTime -> DiffTime # (*) :: DiffTime -> DiffTime -> DiffTime # negate :: DiffTime -> DiffTime # abs :: DiffTime -> DiffTime # signum :: DiffTime -> DiffTime # fromInteger :: Integer -> DiffTime #
Read DiffTime
Instance details Defined in Data.Time.Clock.Internal.DiffTime Methods readsPrec :: Int -> ReadS DiffTime # readList :: ReadS [DiffTime] # readPrec :: ReadPrec DiffTime # readListPrec :: ReadPrec [DiffTime] #
Fractional DiffTime
Instance details Defined in Data.Time.Clock.Internal.DiffTime Methods (/) :: DiffTime -> DiffTime -> DiffTime # recip :: DiffTime -> DiffTime # fromRational :: Rational -> DiffTime #
Real DiffTime
Instance details Defined in Data.Time.Clock.Internal.DiffTime Methods toRational :: DiffTime -> Rational #
RealFrac DiffTime
Instance details Defined in Data.Time.Clock.Internal.DiffTime Methods properFraction :: Integral b => DiffTime -> (b, DiffTime) # truncate :: Integral b => DiffTime -> b # round :: Integral b => DiffTime -> b # ceiling :: Integral b => DiffTime -> b # floor :: Integral b => DiffTime -> b #
Show DiffTime
Instance details Defined in Data.Time.Clock.Internal.DiffTime Methods showsPrec :: Int -> DiffTime -> ShowS # show :: DiffTime -> String # showList :: [DiffTime] -> ShowS #
Eq DiffTime
Instance details Defined in Data.Time.Clock.Internal.DiffTime Methods (==) :: DiffTime -> DiffTime -> Bool # (/=) :: DiffTime -> DiffTime -> Bool #
Ord DiffTime
Instance details Defined in Data.Time.Clock.Internal.DiffTime Methods compare :: DiffTime -> DiffTime -> Ordering # (<) :: DiffTime -> DiffTime -> Bool # (<=) :: DiffTime -> DiffTime -> Bool # (>) :: DiffTime -> DiffTime -> Bool # (>=) :: DiffTime -> DiffTime -> Bool # max :: DiffTime -> DiffTime -> DiffTime # min :: DiffTime -> DiffTime -> DiffTime #
NoThunks DiffTime
Instance details Defined in NoThunks.Class Methods noThunks :: Context -> DiffTime -> IO (Maybe ThunkInfo) # wNoThunks :: Context -> DiffTime -> IO (Maybe ThunkInfo) # showTypeOf :: Proxy DiffTime -> String #

Auxiliary functions

alterAndLookup :: forall k s a. Ord k => (Maybe a -> (s, Maybe a)) -> k -> Map k a -> (Map k a, Maybe s) Source #