run stylish

src/Hash2Pub/ASN1Coding.hs

@@ -3,7 +3,7 @@
 module Hash2Pub.ASN1Coding where
 
 import           Control.Exception        (displayException)
-import           Data.ASN1.BinaryEncoding -- asn1-encoding package
+import           Data.ASN1.BinaryEncoding
 import           Data.ASN1.Encoding
 import           Data.ASN1.Error          ()
 import           Data.ASN1.Parse
@@ -17,8 +17,8 @@ import           Data.Time.Clock.POSIX    ()
 import           Safe
 
 import           Hash2Pub.FediChord
-import           Hash2Pub.Utils
 import           Hash2Pub.ProtocolTypes
+import           Hash2Pub.Utils
 
 import           Debug.Trace
 

src/Hash2Pub/DHTProtocol.hs

@@ -16,25 +16,27 @@ module Hash2Pub.DHTProtocol
         where
 
 import           Control.Concurrent.STM
-import                                     Control.Concurrent.STM.TQueue
 import           Control.Concurrent.STM.TBQueue
+import           Control.Concurrent.STM.TQueue
 import qualified Data.ByteString                as BS
 import qualified Data.Map                       as Map
 import           Data.Maybe                     (fromMaybe, maybe)
 import qualified Data.Set                       as Set
 import           Data.Time.Clock.POSIX
-import           Network.Socket            hiding (recv, recvFrom, send, sendTo)
+import           Network.Socket                 hiding (recv, recvFrom, send,
+                                                 sendTo)
 import           Network.Socket.ByteString
 import           System.Timeout
 
 import           Hash2Pub.ASN1Coding
-import           Hash2Pub.FediChord        (CacheEntry (..), NodeCache, NodeID,
+import           Hash2Pub.FediChord             (CacheEntry (..), NodeCache,
-                                            NodeState (..),
+                                                 NodeID, NodeState (..),
                                                  cacheGetNodeStateUnvalidated,
                                                  cacheLookup, cacheLookupPred,
-                                            cacheLookupSucc, getPredecessors,
+                                                 cacheLookupSucc,
-                                            getSuccessors, localCompare,
+                                                 getPredecessors, getSuccessors,
-                                            putPredecessors, putSuccessors)
+                                                 localCompare, putPredecessors,
+                                                 putSuccessors)
 import           Hash2Pub.ProtocolTypes
 
 import           Debug.Trace                    (trace)

src/Hash2Pub/FediChord.hs

@@ -122,8 +122,8 @@ a `localCompare` b
 
 
 -- | represents a node and all its important state
-data NodeState = NodeState {
+data NodeState = NodeState
-    nid       :: NodeID
+    { nid       :: NodeID
     , domain    :: String
     -- ^ full public domain name the node is reachable under
     , ipAddr    :: HostAddress6
@@ -132,48 +132,33 @@ data NodeState = NodeState {
     -- ^ port of the DHT itself
     , apPort    :: Maybe PortNumber
     -- ^ port of the ActivityPub relay and storage service
-  -- might have to be queried first
     , vServerID :: Integer
     -- ^ ID of this vserver
-
-  -- ==== internal state ====
     , internals :: Maybe InternalNodeState
     -- ^ data not present in the representation of remote nodes
-  -- is put into its own type.
+    }
-  -- This is usually @Nothing@ for all remote nodes.
+    deriving (Show, Eq)
-  } deriving (Show, Eq)
 
 -- | encapsulates all data and parameters that are not present for remote nodes
-data InternalNodeState = InternalNodeState {
+data InternalNodeState = InternalNodeState
-    nodeCache           :: IORef NodeCache
+    { nodeCache           :: IORef NodeCache
     -- ^ EpiChord node cache with expiry times for nodes
-  -- as the map is ordered, lookups for the closes preceding node can be done using @lookupLT@.
-  -- encapsulated into an IORef for allowing concurrent reads without locking
     , cacheWriteQueue     :: TQueue (NodeCache -> NodeCache)
     -- ^ cache updates are not written directly to the  'nodeCache' but queued and
-  -- only processed by a single writer thread to prevent lost updates.
-  -- All nodeCache modifying functions have to be partially applied enough before
-  -- being put into the queue.
-  --
     , successors          :: [NodeID] -- could be a set instead as these are ordered as well
     -- ^ successor nodes in ascending order by distance
     , predecessors        :: [NodeID]
     -- ^ predecessor nodes in ascending order by distance
-  ----- protocol parameters -----
-  -- TODO: evaluate moving these somewhere else
     , kNeighbours         :: Int
     -- ^ desired length of predecessor and successor list
-  -- needs to be parameterisable for simulation purposes
     , lNumBestNodes       :: Int
     -- ^ number of best next hops to provide
-  -- needs to be parameterisable for simulation purposes
     , pNumParallelQueries :: Int
     -- ^ number of parallel sent queries
-  -- needs to be parameterisable for simulation purposes
     , jEntriesPerSlice    :: Int
     -- ^ number of desired entries per cache slice
-  -- needs to be parameterisable for simulation purposes
+    }
-                         } deriving (Show, Eq)
+    deriving (Show, Eq)
 
 -- | defining Show instances to be able to print NodeState for debug purposes
 instance Typeable a => Show (IORef a) where
@@ -230,11 +215,7 @@ getLNumBestNodes = getInternals_ lNumBestNodes
 type NodeCache = Map.Map NodeID CacheEntry
 
 -- |an entry of the 'nodeCache' can hold 2 different kinds of data
-data CacheEntry =
+data CacheEntry = NodeEntry Bool NodeState POSIXTime
-    -- | an entry representing its validation status, the node state and its timestamp
-    NodeEntry Bool NodeState POSIXTime
-    -- | a proxy field for closing the ring structure, indicating the lookup shall be
-    -- resumed at the given @NodeID@ unless the @ProxyEntry@ itself holds a @NodeEntry@
     | ProxyEntry (NodeID, ProxyDirection) (Maybe CacheEntry)
     deriving (Show, Eq)
 
@@ -247,7 +228,9 @@ instance Ord CacheEntry where
             extractID (NodeEntry _ eState _) = nid eState
             extractID (ProxyEntry _ _) = error "proxy entries should never appear outside of the NodeCache"
 
-data ProxyDirection = Backwards | Forwards deriving (Show, Eq)
+data ProxyDirection = Backwards
+    | Forwards
+    deriving (Show, Eq)
 
 instance Enum ProxyDirection where
     toEnum (-1) = Backwards
@@ -430,11 +413,12 @@ byteStringToUInteger bs = sum $ parsedBytes 0 bs
 -- persist them on disk so they can be used for all following bootstraps
 
 -- | configuration values used for initialising the FediChord DHT
-data FediChordConf = FediChordConf {
+data FediChordConf = FediChordConf
-    confDomain  :: String
+    { confDomain  :: String
     , confIP      :: HostAddress6
     , confDhtPort :: Int
-                                   } deriving (Show, Eq)
+    }
+    deriving (Show, Eq)
 
 -- | initialise data structures, compute own IDs and bind to listening socket
 -- ToDo: load persisted state, thus this function already operates in IO

src/Hash2Pub/ProtocolTypes.hs

@@ -5,26 +5,21 @@ import Data.Time.Clock.POSIX (POSIXTime)
 
 import           Hash2Pub.FediChord
 
-data QueryResponse = FORWARD (Set.Set RemoteCacheEntry) -- ^return closest nodes from local cache.
+data QueryResponse = FORWARD (Set.Set RemoteCacheEntry)
-                                          -- whole cache entry is returned for making
+    | FOUND NodeState
-                                          -- the entry time stamp available to the
-                                          -- protocol serialiser
-                   | FOUND NodeState     -- ^node is the responsible node for queried ID
     deriving (Show, Eq)
 
 -- === protocol serialisation data types
 
-data Action =
+data Action = QueryID
-    QueryID 
     | Join
     | Leave
     | Stabilise
     | Ping
     deriving (Show, Eq, Enum)
 
-data FediChordMessage =
+data FediChordMessage = Request
-    Request {
+    { requestID :: Integer
-    requestID       :: Integer
     , sender    :: NodeState
     , parts     :: Integer
     , part      :: Integer
@@ -32,42 +27,42 @@ data FediChordMessage =
     , action    :: Action
     , payload   :: Maybe ActionPayload
     }
-  | Response {
+    | Response
-    responseTo      :: Integer
+    { responseTo :: Integer
     , senderID   :: NodeID
     , parts      :: Integer
     , part       :: Integer
     , action     :: Action
     , payload    :: Maybe ActionPayload
-             } deriving (Show, Eq)
+    }
+    deriving (Show, Eq)
 
-data ActionPayload = 
+data ActionPayload = QueryIDRequestPayload
-    QueryIDRequestPayload {
+    { queryTargetID   :: NodeID
-        queryTargetID   :: NodeID
     , queryLBestNodes :: Integer
     }
     | JoinRequestPayload
-  | LeaveRequestPayload {
+    | LeaveRequestPayload
-        leaveSuccessors     :: [NodeID]
+    { leaveSuccessors   :: [NodeID]
     , leavePredecessors :: [NodeID]
     }
     | StabiliseRequestPayload
     | PingRequestPayload
-  | QueryIDResponsePayload {
+    | QueryIDResponsePayload
-        queryResult     :: QueryResponse
+    { queryResult :: QueryResponse
     }
-  | JoinResponsePayload {
+    | JoinResponsePayload
-        joinSuccessors      :: [NodeID]
+    { joinSuccessors   :: [NodeID]
     , joinPredecessors :: [NodeID]
     , joinCache        :: [RemoteCacheEntry]
     }
     | LeaveResponsePayload
-  | StabiliseResponsePayload {
+    | StabiliseResponsePayload
-        stabiliseSuccessors     :: [NodeID]
+    { stabiliseSuccessors   :: [NodeID]
     , stabilisePredecessors :: [NodeID]
     }
-  | PingResponsePayload {
+    | PingResponsePayload
-        pingNodeStates  :: [NodeState]
+    { pingNodeStates :: [NodeState]
     }
     deriving (Show, Eq)