{-# LANGUAGE DeriveAnyClass    #-}
{-# LANGUAGE DeriveGeneric     #-}
{-# LANGUAGE LambdaCase        #-}
{-# LANGUAGE NamedFieldPuns    #-}
{-# LANGUAGE OverloadedStrings #-}

module DMQ.NodeToNode.Version
  ( NodeToNodeVersion (..)
  , NodeToNodeVersionData (..)
  , nodeToNodeCodecCBORTerm
  , nodeToNodeVersionCodec
  , ntnDataFlow
  ) where

import Codec.CBOR.Term qualified as CBOR
import Control.DeepSeq (NFData)
import Data.Aeson qualified as Aeson
import Data.Text (Text)
import Data.Text qualified as T
import GHC.Generics (Generic)

import Ouroboros.Network.CodecCBORTerm (CodecCBORTerm (..))
import Ouroboros.Network.ConnectionManager.Types (DataFlow (..))
import Ouroboros.Network.Handshake.Acceptable (Acceptable (..))
import Ouroboros.Network.Handshake.Queryable (Queryable (..))
import Ouroboros.Network.Magic (NetworkMagic (..))
import Ouroboros.Network.NodeToNode.Version (DiffusionMode (..))
import Ouroboros.Network.PeerSelection (PeerSharing (..))
import Ouroboros.Network.Protocol.Handshake (Accept (..))

import Ouroboros.Network.OrphanInstances ()


data NodeToNodeVersion =
  NodeToNodeV_1
  deriving (NodeToNodeVersion -> NodeToNodeVersion -> Bool
(NodeToNodeVersion -> NodeToNodeVersion -> Bool)
-> (NodeToNodeVersion -> NodeToNodeVersion -> Bool)
-> Eq NodeToNodeVersion
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: NodeToNodeVersion -> NodeToNodeVersion -> Bool
== :: NodeToNodeVersion -> NodeToNodeVersion -> Bool
$c/= :: NodeToNodeVersion -> NodeToNodeVersion -> Bool
/= :: NodeToNodeVersion -> NodeToNodeVersion -> Bool
Eq, Eq NodeToNodeVersion
Eq NodeToNodeVersion =>
(NodeToNodeVersion -> NodeToNodeVersion -> Ordering)
-> (NodeToNodeVersion -> NodeToNodeVersion -> Bool)
-> (NodeToNodeVersion -> NodeToNodeVersion -> Bool)
-> (NodeToNodeVersion -> NodeToNodeVersion -> Bool)
-> (NodeToNodeVersion -> NodeToNodeVersion -> Bool)
-> (NodeToNodeVersion -> NodeToNodeVersion -> NodeToNodeVersion)
-> (NodeToNodeVersion -> NodeToNodeVersion -> NodeToNodeVersion)
-> Ord NodeToNodeVersion
NodeToNodeVersion -> NodeToNodeVersion -> Bool
NodeToNodeVersion -> NodeToNodeVersion -> Ordering
NodeToNodeVersion -> NodeToNodeVersion -> NodeToNodeVersion
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: NodeToNodeVersion -> NodeToNodeVersion -> Ordering
compare :: NodeToNodeVersion -> NodeToNodeVersion -> Ordering
$c< :: NodeToNodeVersion -> NodeToNodeVersion -> Bool
< :: NodeToNodeVersion -> NodeToNodeVersion -> Bool
$c<= :: NodeToNodeVersion -> NodeToNodeVersion -> Bool
<= :: NodeToNodeVersion -> NodeToNodeVersion -> Bool
$c> :: NodeToNodeVersion -> NodeToNodeVersion -> Bool
> :: NodeToNodeVersion -> NodeToNodeVersion -> Bool
$c>= :: NodeToNodeVersion -> NodeToNodeVersion -> Bool
>= :: NodeToNodeVersion -> NodeToNodeVersion -> Bool
$cmax :: NodeToNodeVersion -> NodeToNodeVersion -> NodeToNodeVersion
max :: NodeToNodeVersion -> NodeToNodeVersion -> NodeToNodeVersion
$cmin :: NodeToNodeVersion -> NodeToNodeVersion -> NodeToNodeVersion
min :: NodeToNodeVersion -> NodeToNodeVersion -> NodeToNodeVersion
Ord, Int -> NodeToNodeVersion
NodeToNodeVersion -> Int
NodeToNodeVersion -> [NodeToNodeVersion]
NodeToNodeVersion -> NodeToNodeVersion
NodeToNodeVersion -> NodeToNodeVersion -> [NodeToNodeVersion]
NodeToNodeVersion
-> NodeToNodeVersion -> NodeToNodeVersion -> [NodeToNodeVersion]
(NodeToNodeVersion -> NodeToNodeVersion)
-> (NodeToNodeVersion -> NodeToNodeVersion)
-> (Int -> NodeToNodeVersion)
-> (NodeToNodeVersion -> Int)
-> (NodeToNodeVersion -> [NodeToNodeVersion])
-> (NodeToNodeVersion -> NodeToNodeVersion -> [NodeToNodeVersion])
-> (NodeToNodeVersion -> NodeToNodeVersion -> [NodeToNodeVersion])
-> (NodeToNodeVersion
    -> NodeToNodeVersion -> NodeToNodeVersion -> [NodeToNodeVersion])
-> Enum NodeToNodeVersion
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: NodeToNodeVersion -> NodeToNodeVersion
succ :: NodeToNodeVersion -> NodeToNodeVersion
$cpred :: NodeToNodeVersion -> NodeToNodeVersion
pred :: NodeToNodeVersion -> NodeToNodeVersion
$ctoEnum :: Int -> NodeToNodeVersion
toEnum :: Int -> NodeToNodeVersion
$cfromEnum :: NodeToNodeVersion -> Int
fromEnum :: NodeToNodeVersion -> Int
$cenumFrom :: NodeToNodeVersion -> [NodeToNodeVersion]
enumFrom :: NodeToNodeVersion -> [NodeToNodeVersion]
$cenumFromThen :: NodeToNodeVersion -> NodeToNodeVersion -> [NodeToNodeVersion]
enumFromThen :: NodeToNodeVersion -> NodeToNodeVersion -> [NodeToNodeVersion]
$cenumFromTo :: NodeToNodeVersion -> NodeToNodeVersion -> [NodeToNodeVersion]
enumFromTo :: NodeToNodeVersion -> NodeToNodeVersion -> [NodeToNodeVersion]
$cenumFromThenTo :: NodeToNodeVersion
-> NodeToNodeVersion -> NodeToNodeVersion -> [NodeToNodeVersion]
enumFromThenTo :: NodeToNodeVersion
-> NodeToNodeVersion -> NodeToNodeVersion -> [NodeToNodeVersion]
Enum, NodeToNodeVersion
NodeToNodeVersion -> NodeToNodeVersion -> Bounded NodeToNodeVersion
forall a. a -> a -> Bounded a
$cminBound :: NodeToNodeVersion
minBound :: NodeToNodeVersion
$cmaxBound :: NodeToNodeVersion
maxBound :: NodeToNodeVersion
Bounded, Int -> NodeToNodeVersion -> String -> String
[NodeToNodeVersion] -> String -> String
NodeToNodeVersion -> String
(Int -> NodeToNodeVersion -> String -> String)
-> (NodeToNodeVersion -> String)
-> ([NodeToNodeVersion] -> String -> String)
-> Show NodeToNodeVersion
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> NodeToNodeVersion -> String -> String
showsPrec :: Int -> NodeToNodeVersion -> String -> String
$cshow :: NodeToNodeVersion -> String
show :: NodeToNodeVersion -> String
$cshowList :: [NodeToNodeVersion] -> String -> String
showList :: [NodeToNodeVersion] -> String -> String
Show, (forall x. NodeToNodeVersion -> Rep NodeToNodeVersion x)
-> (forall x. Rep NodeToNodeVersion x -> NodeToNodeVersion)
-> Generic NodeToNodeVersion
forall x. Rep NodeToNodeVersion x -> NodeToNodeVersion
forall x. NodeToNodeVersion -> Rep NodeToNodeVersion x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. NodeToNodeVersion -> Rep NodeToNodeVersion x
from :: forall x. NodeToNodeVersion -> Rep NodeToNodeVersion x
$cto :: forall x. Rep NodeToNodeVersion x -> NodeToNodeVersion
to :: forall x. Rep NodeToNodeVersion x -> NodeToNodeVersion
Generic, NodeToNodeVersion -> ()
(NodeToNodeVersion -> ()) -> NFData NodeToNodeVersion
forall a. (a -> ()) -> NFData a
$crnf :: NodeToNodeVersion -> ()
rnf :: NodeToNodeVersion -> ()
NFData)

instance Aeson.ToJSON NodeToNodeVersion where
  toJSON :: NodeToNodeVersion -> Value
toJSON NodeToNodeVersion
NodeToNodeV_1 = Int -> Value
forall a. ToJSON a => a -> Value
Aeson.toJSON (Int
1 :: Int)
instance Aeson.ToJSONKey NodeToNodeVersion where

nodeToNodeVersionCodec :: CodecCBORTerm (Text, Maybe Int) NodeToNodeVersion
nodeToNodeVersionCodec :: CodecCBORTerm (Text, Maybe Int) NodeToNodeVersion
nodeToNodeVersionCodec = CodecCBORTerm { NodeToNodeVersion -> Term
encodeTerm :: NodeToNodeVersion -> Term
encodeTerm :: NodeToNodeVersion -> Term
encodeTerm, Term -> Either (Text, Maybe Int) NodeToNodeVersion
decodeTerm :: Term -> Either (Text, Maybe Int) NodeToNodeVersion
decodeTerm :: Term -> Either (Text, Maybe Int) NodeToNodeVersion
decodeTerm }
  where
    encodeTerm :: NodeToNodeVersion -> Term
encodeTerm NodeToNodeVersion
NodeToNodeV_1 = Int -> Term
CBOR.TInt Int
1

    decodeTerm :: Term -> Either (Text, Maybe Int) NodeToNodeVersion
decodeTerm (CBOR.TInt Int
1) = NodeToNodeVersion -> Either (Text, Maybe Int) NodeToNodeVersion
forall a b. b -> Either a b
Right NodeToNodeVersion
NodeToNodeV_1
    decodeTerm (CBOR.TInt Int
n) = (Text, Maybe Int) -> Either (Text, Maybe Int) NodeToNodeVersion
forall a b. a -> Either a b
Left ( String -> Text
T.pack String
"decode NodeToNodeVersion: unknown tag: "
                                        Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> String -> Text
T.pack (Int -> String
forall a. Show a => a -> String
show Int
n)
                                    , Int -> Maybe Int
forall a. a -> Maybe a
Just Int
n
                                    )
    decodeTerm Term
_ = (Text, Maybe Int) -> Either (Text, Maybe Int) NodeToNodeVersion
forall a b. a -> Either a b
Left ( String -> Text
T.pack String
"decode NodeToNodeVersion: unexpected term"
                        , Maybe Int
forall a. Maybe a
Nothing)

-- | Version data for NodeToNode protocols
--
-- This data type is inpired by the one defined in 'ouroboros-network-api',
-- however, it is redefined here to tie it to our custom `NodeToNodeVersion`
-- and to avoid divergences.
--
data NodeToNodeVersionData = NodeToNodeVersionData
  { NodeToNodeVersionData -> NetworkMagic
networkMagic  :: !NetworkMagic
  , NodeToNodeVersionData -> DiffusionMode
diffusionMode :: !DiffusionMode
  , NodeToNodeVersionData -> PeerSharing
peerSharing   :: !PeerSharing
  , NodeToNodeVersionData -> Bool
query         :: !Bool
  }
  deriving (Int -> NodeToNodeVersionData -> String -> String
[NodeToNodeVersionData] -> String -> String
NodeToNodeVersionData -> String
(Int -> NodeToNodeVersionData -> String -> String)
-> (NodeToNodeVersionData -> String)
-> ([NodeToNodeVersionData] -> String -> String)
-> Show NodeToNodeVersionData
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> NodeToNodeVersionData -> String -> String
showsPrec :: Int -> NodeToNodeVersionData -> String -> String
$cshow :: NodeToNodeVersionData -> String
show :: NodeToNodeVersionData -> String
$cshowList :: [NodeToNodeVersionData] -> String -> String
showList :: [NodeToNodeVersionData] -> String -> String
Show, NodeToNodeVersionData -> NodeToNodeVersionData -> Bool
(NodeToNodeVersionData -> NodeToNodeVersionData -> Bool)
-> (NodeToNodeVersionData -> NodeToNodeVersionData -> Bool)
-> Eq NodeToNodeVersionData
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: NodeToNodeVersionData -> NodeToNodeVersionData -> Bool
== :: NodeToNodeVersionData -> NodeToNodeVersionData -> Bool
$c/= :: NodeToNodeVersionData -> NodeToNodeVersionData -> Bool
/= :: NodeToNodeVersionData -> NodeToNodeVersionData -> Bool
Eq)

instance Aeson.ToJSON NodeToNodeVersionData where
  toJSON :: NodeToNodeVersionData -> Value
toJSON NodeToNodeVersionData {
      NetworkMagic
networkMagic :: NodeToNodeVersionData -> NetworkMagic
networkMagic :: NetworkMagic
networkMagic,
      DiffusionMode
diffusionMode :: NodeToNodeVersionData -> DiffusionMode
diffusionMode :: DiffusionMode
diffusionMode,
      PeerSharing
peerSharing :: NodeToNodeVersionData -> PeerSharing
peerSharing :: PeerSharing
peerSharing,
      Bool
query :: NodeToNodeVersionData -> Bool
query :: Bool
query
    }
    =
    [Pair] -> Value
Aeson.object [ Key
"NetworkMagic" Key -> Word32 -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
Aeson..= NetworkMagic -> Word32
unNetworkMagic NetworkMagic
networkMagic
                 , Key
"DiffusionMode" Key -> DiffusionMode -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
Aeson..= DiffusionMode
diffusionMode
                 , Key
"PeerSharing" Key -> PeerSharing -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
Aeson..= PeerSharing
peerSharing
                 , Key
"Query" Key -> Bool -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
Aeson..= Bool
query
                 ]


instance Acceptable NodeToNodeVersionData where
    -- | Check that both side use the same 'networkMagic'.  Choose smaller one
    -- from both 'diffusionMode's, e.g. if one is running in 'InitiatorOnlyMode'
    -- agree on it. Agree on the same 'PeerSharing' value, if the negotiated
    -- diffusion mode is 'InitiatorAndResponder', otherwise default to
    -- 'PeerSharingDisabled'.
    acceptableVersion :: NodeToNodeVersionData
-> NodeToNodeVersionData -> Accept NodeToNodeVersionData
acceptableVersion NodeToNodeVersionData
local NodeToNodeVersionData
remote
      | NodeToNodeVersionData -> NetworkMagic
networkMagic NodeToNodeVersionData
local NetworkMagic -> NetworkMagic -> Bool
forall a. Eq a => a -> a -> Bool
== NodeToNodeVersionData -> NetworkMagic
networkMagic NodeToNodeVersionData
remote
      = let acceptedDiffusionMode :: DiffusionMode
acceptedDiffusionMode = NodeToNodeVersionData -> DiffusionMode
diffusionMode NodeToNodeVersionData
local DiffusionMode -> DiffusionMode -> DiffusionMode
forall a. Ord a => a -> a -> a
`min` NodeToNodeVersionData -> DiffusionMode
diffusionMode NodeToNodeVersionData
remote
         in NodeToNodeVersionData -> Accept NodeToNodeVersionData
forall vData. vData -> Accept vData
Accept NodeToNodeVersionData
              { networkMagic :: NetworkMagic
networkMagic  = NodeToNodeVersionData -> NetworkMagic
networkMagic NodeToNodeVersionData
local
              , diffusionMode :: DiffusionMode
diffusionMode = DiffusionMode
acceptedDiffusionMode
              , peerSharing :: PeerSharing
peerSharing   = case DiffusionMode
acceptedDiffusionMode of
                                  DiffusionMode
InitiatorAndResponderDiffusionMode ->
                                    NodeToNodeVersionData -> PeerSharing
peerSharing NodeToNodeVersionData
local PeerSharing -> PeerSharing -> PeerSharing
forall a. Semigroup a => a -> a -> a
<> NodeToNodeVersionData -> PeerSharing
peerSharing NodeToNodeVersionData
remote
                                  DiffusionMode
InitiatorOnlyDiffusionMode         ->
                                    PeerSharing
PeerSharingDisabled
              , query :: Bool
query         = NodeToNodeVersionData -> Bool
query NodeToNodeVersionData
local Bool -> Bool -> Bool
|| NodeToNodeVersionData -> Bool
query NodeToNodeVersionData
remote
              }
      | Bool
otherwise
      = Text -> Accept NodeToNodeVersionData
forall vData. Text -> Accept vData
Refuse (Text -> Accept NodeToNodeVersionData)
-> Text -> Accept NodeToNodeVersionData
forall a b. (a -> b) -> a -> b
$ String -> Text
T.pack (String -> Text) -> String -> Text
forall a b. (a -> b) -> a -> b
$ String
"version data mismatch: "
                       String -> String -> String
forall a. [a] -> [a] -> [a]
++ NodeToNodeVersionData -> String
forall a. Show a => a -> String
show NodeToNodeVersionData
local
                       String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
" /= " String -> String -> String
forall a. [a] -> [a] -> [a]
++ NodeToNodeVersionData -> String
forall a. Show a => a -> String
show NodeToNodeVersionData
remote

instance Queryable NodeToNodeVersionData where
    queryVersion :: NodeToNodeVersionData -> Bool
queryVersion = NodeToNodeVersionData -> Bool
query

nodeToNodeCodecCBORTerm :: NodeToNodeVersion
                        -> CodecCBORTerm Text NodeToNodeVersionData
nodeToNodeCodecCBORTerm :: NodeToNodeVersion -> CodecCBORTerm Text NodeToNodeVersionData
nodeToNodeCodecCBORTerm =
  \case
    NodeToNodeVersion
NodeToNodeV_1 -> CodecCBORTerm Text NodeToNodeVersionData
v1

  where
    v1 :: CodecCBORTerm Text NodeToNodeVersionData
v1 = CodecCBORTerm { encodeTerm :: NodeToNodeVersionData -> Term
encodeTerm = NodeToNodeVersionData -> Term
encodeTerm1, decodeTerm :: Term -> Either Text NodeToNodeVersionData
decodeTerm = Term -> Either Text NodeToNodeVersionData
decodeTerm1 }

    encodeTerm1 :: NodeToNodeVersionData -> CBOR.Term
    encodeTerm1 :: NodeToNodeVersionData -> Term
encodeTerm1 NodeToNodeVersionData { NetworkMagic
networkMagic :: NodeToNodeVersionData -> NetworkMagic
networkMagic :: NetworkMagic
networkMagic, DiffusionMode
diffusionMode :: NodeToNodeVersionData -> DiffusionMode
diffusionMode :: DiffusionMode
diffusionMode, PeerSharing
peerSharing :: NodeToNodeVersionData -> PeerSharing
peerSharing :: PeerSharing
peerSharing, Bool
query :: NodeToNodeVersionData -> Bool
query :: Bool
query }
      = [Term] -> Term
CBOR.TList
          [ Int -> Term
CBOR.TInt (Word32 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word32 -> Int) -> Word32 -> Int
forall a b. (a -> b) -> a -> b
$ NetworkMagic -> Word32
unNetworkMagic NetworkMagic
networkMagic)
          , Bool -> Term
CBOR.TBool (case DiffusionMode
diffusionMode of
                         DiffusionMode
InitiatorOnlyDiffusionMode         -> Bool
True
                         DiffusionMode
InitiatorAndResponderDiffusionMode -> Bool
False)
          , Int -> Term
CBOR.TInt (case PeerSharing
peerSharing of
                         PeerSharing
PeerSharingDisabled -> Int
0
                         PeerSharing
PeerSharingEnabled  -> Int
1)
          , Bool -> Term
CBOR.TBool Bool
query
          ]

    decodeTerm1 :: CBOR.Term -> Either Text NodeToNodeVersionData
    decodeTerm1 :: Term -> Either Text NodeToNodeVersionData
decodeTerm1 (CBOR.TList [CBOR.TInt Int
x, CBOR.TBool Bool
diffusionMode, CBOR.TInt Int
peerSharing, CBOR.TBool Bool
query])
      | Int
x Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
0
      , Int
x Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
0xffffffff
      , Just PeerSharing
ps <- case Int
peerSharing of
                    Int
0 -> PeerSharing -> Maybe PeerSharing
forall a. a -> Maybe a
Just PeerSharing
PeerSharingDisabled
                    Int
1 -> PeerSharing -> Maybe PeerSharing
forall a. a -> Maybe a
Just PeerSharing
PeerSharingEnabled
                    Int
_ -> Maybe PeerSharing
forall a. Maybe a
Nothing
      = NodeToNodeVersionData -> Either Text NodeToNodeVersionData
forall a b. b -> Either a b
Right
          NodeToNodeVersionData {
              networkMagic :: NetworkMagic
networkMagic = Word32 -> NetworkMagic
NetworkMagic (Int -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
x),
              diffusionMode :: DiffusionMode
diffusionMode = if Bool
diffusionMode
                              then DiffusionMode
InitiatorOnlyDiffusionMode
                              else DiffusionMode
InitiatorAndResponderDiffusionMode,
              peerSharing :: PeerSharing
peerSharing = PeerSharing
ps,
              query :: Bool
query = Bool
query
            }
      | Int
x Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
0 Bool -> Bool -> Bool
|| Int
x Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
0xffffffff
      = Text -> Either Text NodeToNodeVersionData
forall a b. a -> Either a b
Left (Text -> Either Text NodeToNodeVersionData)
-> Text -> Either Text NodeToNodeVersionData
forall a b. (a -> b) -> a -> b
$ String -> Text
T.pack (String -> Text) -> String -> Text
forall a b. (a -> b) -> a -> b
$ String
"networkMagic out of bound: " String -> String -> String
forall a. Semigroup a => a -> a -> a
<> Int -> String
forall a. Show a => a -> String
show Int
x
      | Bool
otherwise -- peerSharing < 0 || peerSharing > 1
      = Text -> Either Text NodeToNodeVersionData
forall a b. a -> Either a b
Left (Text -> Either Text NodeToNodeVersionData)
-> Text -> Either Text NodeToNodeVersionData
forall a b. (a -> b) -> a -> b
$ String -> Text
T.pack (String -> Text) -> String -> Text
forall a b. (a -> b) -> a -> b
$ String
"peerSharing is out of bound: " String -> String -> String
forall a. Semigroup a => a -> a -> a
<> Int -> String
forall a. Show a => a -> String
show Int
peerSharing
    decodeTerm1 Term
t
      = Text -> Either Text NodeToNodeVersionData
forall a b. a -> Either a b
Left (Text -> Either Text NodeToNodeVersionData)
-> Text -> Either Text NodeToNodeVersionData
forall a b. (a -> b) -> a -> b
$ String -> Text
T.pack (String -> Text) -> String -> Text
forall a b. (a -> b) -> a -> b
$ String
"unknown encoding: " String -> String -> String
forall a. [a] -> [a] -> [a]
++ Term -> String
forall a. Show a => a -> String
show Term
t

ntnDataFlow :: NodeToNodeVersionData -> DataFlow
ntnDataFlow :: NodeToNodeVersionData -> DataFlow
ntnDataFlow NodeToNodeVersionData { DiffusionMode
diffusionMode :: NodeToNodeVersionData -> DiffusionMode
diffusionMode :: DiffusionMode
diffusionMode } =
  case DiffusionMode
diffusionMode of
    DiffusionMode
InitiatorAndResponderDiffusionMode -> DataFlow
Duplex
    DiffusionMode
InitiatorOnlyDiffusionMode         -> DataFlow
Unidirectional