From 8d349212b4cb84a62ed657ac014af7a7de3470b2 Mon Sep 17 00:00:00 2001 From: Trolli Schmittlauch Date: Wed, 1 Jul 2020 18:22:28 +0200 Subject: [PATCH 1/2] prevent cache invariant querying when not joined --- src/Hash2Pub/DHTProtocol.hs | 9 +++++---- src/Hash2Pub/FediChord.hs | 11 ++++++++--- 2 files changed, 13 insertions(+), 7 deletions(-) diff --git a/src/Hash2Pub/DHTProtocol.hs b/src/Hash2Pub/DHTProtocol.hs index 83e32d4..230f7df 100644 --- a/src/Hash2Pub/DHTProtocol.hs +++ b/src/Hash2Pub/DHTProtocol.hs @@ -32,6 +32,7 @@ module Hash2Pub.DHTProtocol , ackRequest , isPossibleSuccessor , isPossiblePredecessor + , isJoined , closestCachePredecessors ) where @@ -213,8 +214,8 @@ markCacheEntryAsVerified timestamp nid = RingMap . Map.adjust adjustFunc nid . g -- | uses the successor and predecessor list of a node as an indicator for whether a -- node has properly joined the DHT -isJoined_ :: LocalNodeState -> Bool -isJoined_ ns = not . all null $ [successors ns, predecessors ns] +isJoined :: LocalNodeState -> Bool +isJoined ns = not . all null $ [successors ns, predecessors ns] -- | the size limit to be used when serialising messages for sending sendMessageSize :: Num i => i @@ -260,8 +261,8 @@ handleIncomingRequest nsSTM sendQ msgSet sourceAddr = do -- ToDo: figure out what happens if not joined QueryID -> Just <$> respondQueryID nsSTM msgSet -- only when joined - Leave -> if isJoined_ ns then Just <$> respondLeave nsSTM msgSet else pure Nothing - Stabilise -> if isJoined_ ns then Just <$> respondStabilise nsSTM msgSet else pure Nothing + Leave -> if isJoined ns then Just <$> respondLeave nsSTM msgSet else pure Nothing + Stabilise -> if isJoined ns then Just <$> respondStabilise nsSTM msgSet else pure Nothing ) -- for single part request, response starts with part number 1. For multipart requests, response starts with part number n+1. diff --git a/src/Hash2Pub/FediChord.hs b/src/Hash2Pub/FediChord.hs index 95617fc..061a74f 100644 --- a/src/Hash2Pub/FediChord.hs +++ b/src/Hash2Pub/FediChord.hs @@ -253,7 +253,9 @@ checkCacheSliceInvariants :: LocalNodeState -> NodeCache -> [NodeID] -- ^ list of middle IDs of slices not -- ^ fulfilling the invariant -checkCacheSliceInvariants ns = checkPredecessorSlice jEntries (getNid ns) startBound lastPred <> checkSuccessorSlice jEntries (getNid ns) startBound lastSucc +checkCacheSliceInvariants ns + | isJoined ns = checkPredecessorSlice jEntries (getNid ns) startBound lastPred <> checkSuccessorSlice jEntries (getNid ns) startBound lastSucc + | otherwise = const [] where jEntries = jEntriesPerSlice ns lastPred = getNid <$> lastMay (predecessors ns) @@ -340,7 +342,7 @@ stabiliseThread nsSTM = forever $ do -- try looking up additional neighbours if list too short forM_ [(length $ predecessors updatedNs)..(kNeighbours updatedNs)] (\_ -> do ns' <- readTVarIO nsSTM - nextEntry <- requestQueryID ns' $ pred . getNid $ atDef (toRemoteNodeState ns') (predecessors ns') (-1) + nextEntry <- requestQueryID ns' $ pred . getNid $ lastDef (toRemoteNodeState ns') (predecessors ns') atomically $ do latestNs <- readTVar nsSTM writeTVar nsSTM $ addPredecessors [nextEntry] latestNs @@ -348,7 +350,7 @@ stabiliseThread nsSTM = forever $ do forM_ [(length $ successors updatedNs)..(kNeighbours updatedNs)] (\_ -> do ns' <- readTVarIO nsSTM - nextEntry <- requestQueryID ns' $ succ . getNid $ atDef (toRemoteNodeState ns') (successors ns') (-1) + nextEntry <- requestQueryID ns' $ succ . getNid $ lastDef (toRemoteNodeState ns') (successors ns') atomically $ do latestNs <- readTVar nsSTM writeTVar nsSTM $ addSuccessors [nextEntry] latestNs @@ -460,6 +462,9 @@ fediMessageHandler :: TQueue (BS.ByteString, SockAddr) -- ^ send queue -> LocalNodeStateSTM -- ^ acting NodeState -> IO () fediMessageHandler sendQ recvQ nsSTM = do + -- Read node state just once, assuming that all relevant data for this function does + -- not change. + -- Other functions are passed the nsSTM reference and thus can get the latest state. nsSnap <- readTVarIO nsSTM -- handling multipart messages: -- Request parts can be insert into a map (key: (sender IP against spoofing, request ID), value: timestamp + set of message parts, handle all of them when size of set == parts) before being handled. This map needs to be purged periodically by a separate thread and can be protected by an MVar for fairness. From f6481996d777a33c95d2a43dcdc7e54a4e9486f0 Mon Sep 17 00:00:00 2001 From: Trolli Schmittlauch Date: Thu, 2 Jul 2020 00:54:14 +0200 Subject: [PATCH 2/2] Change default response to QueryID for unjoined nodes reason: allow unjoined nodes to find bootstrap node in local cache, while always advertising itself to incoming requests for bootstrapping. --- src/Hash2Pub/DHTProtocol.hs | 10 ++++++++-- test/FediChordSpec.hs | 18 +++++++++++++++--- 2 files changed, 23 insertions(+), 5 deletions(-) diff --git a/src/Hash2Pub/DHTProtocol.hs b/src/Hash2Pub/DHTProtocol.hs index 230f7df..e562b98 100644 --- a/src/Hash2Pub/DHTProtocol.hs +++ b/src/Hash2Pub/DHTProtocol.hs @@ -90,7 +90,9 @@ import Debug.Trace (trace) queryLocalCache :: LocalNodeState -> NodeCache -> Int -> NodeID -> QueryResponse queryLocalCache ownState nCache lBestNodes targetID -- as target ID falls between own ID and first predecessor, it is handled by this node - | targetID `isInOwnResponsibilitySlice` ownState = FOUND . toRemoteNodeState $ ownState + -- This only makes sense if the node is part of the DHT by having joined. + -- A default answer to nodes querying an unjoined node is provided by 'respondQueryID'. + | isJoined ownState && targetID `isInOwnResponsibilitySlice` ownState = FOUND . toRemoteNodeState $ ownState -- my interpretation: the "l best next hops" are the l-1 closest preceding nodes and -- the closest succeeding node (like with the p initiated parallel queries | otherwise = FORWARD $ closestSuccessor `Set.union` closestCachePredecessors (lBestNodes-1) targetID nCache @@ -296,7 +298,11 @@ respondQueryID nsSTM msgSet = do cache <- readTVar $ nodeCacheSTM nsSnap let responsePayload = QueryIDResponsePayload { - queryResult = queryLocalCache nsSnap cache (fromIntegral $ queryLBestNodes senderPayload') (queryTargetID senderPayload') + queryResult = if isJoined nsSnap + then queryLocalCache nsSnap cache (fromIntegral $ queryLBestNodes senderPayload') (queryTargetID senderPayload') + -- if not joined yet, attract responsibility for + -- all keys to make bootstrapping possible + else FOUND (toRemoteNodeState nsSnap) } queryResponseMsg = Response { requestID = requestID aRequestPart diff --git a/test/FediChordSpec.hs b/test/FediChordSpec.hs index 4f05e72..545c3dd 100644 --- a/test/FediChordSpec.hs +++ b/test/FediChordSpec.hs @@ -132,10 +132,11 @@ spec = do cacheWith2Entries :: NodeCache cacheWith2Entries = addCacheEntryPure 10 (RemoteCacheEntry node5 10) (addCacheEntryPure 10 (RemoteCacheEntry node2 10) emptyCache) cacheWith4Entries = addCacheEntryPure 10 (RemoteCacheEntry node3 10) (addCacheEntryPure 10 (RemoteCacheEntry node4 10) cacheWith2Entries) - it "nodes not joined provide the default answer FOUND" $ do + it "unjoined nodes should never return themselfs" $ do exampleLocalNodeAsRemote <- toRemoteNodeState <$> exampleLocalNode - queryLocalCache <$> exampleLocalNode <*> pure emptyCache <*> pure 3 <*> pure (toNodeID 2^(9::Integer)+5) `shouldReturn` FOUND exampleLocalNodeAsRemote - queryLocalCache <$> exampleLocalNode <*> pure cacheWith4Entries <*> pure 1 <*> pure (toNodeID 2342) `shouldReturn` FOUND exampleLocalNodeAsRemote + queryLocalCache <$> exampleLocalNode <*> pure emptyCache <*> pure 3 <*> pure (toNodeID 2^(9::Integer)+5) `shouldReturn` FORWARD Set.empty + (FORWARD fwSet) <- queryLocalCache <$> exampleLocalNode <*> pure cacheWith4Entries <*> pure 1 <*> (getNid <$> exampleLocalNode) + remoteNode (head $ Set.elems fwSet) `shouldBe` node4 it "joined nodes do not fall back to the default" $ queryLocalCache <$> node1 <*> pure emptyCache <*> pure 1 <*> pure (toNodeID 3) `shouldReturn` FORWARD Set.empty it "works on a cache with less entries than needed" $ do @@ -265,6 +266,17 @@ spec = do let startAt5 = serialiseMessage 600 (largeMessage {part = 5}) Map.lookup 1 startAt5 `shouldBe` Nothing part <$> (deserialiseMessage . fromJust) (Map.lookup 5 startAt5) `shouldBe` Right 5 + describe "join cache lookup" $ + it "A bootstrap cache initialised with just one node returns that one." $ do + let + bootstrapNid = toNodeID 34804191837661041451755206127000721433747285589603756490902196113256157045194 + bootstrapNode = setNid bootstrapNid exampleNodeState + bootstrapCache = addCacheEntryPure 10 (RemoteCacheEntry bootstrapNode 19) initCache + ownId = toNodeID 34804191837661041451755206127000721433707928516052624394829818586723613390165 + ownNode <- setNid ownId <$> exampleLocalNode + let (FORWARD qResult) = queryLocalCache ownNode bootstrapCache 2 ownId + remoteNode (head $ Set.elems qResult) `shouldBe` bootstrapNode + -- some example data