private NodeContact[] PickClosestContacts(List <NodeContact> availableContacts, int count) { if (availableContacts.Count < count) { count = availableContacts.Count; } NodeContact[] closestContacts = KBucket.GetClosestContacts(availableContacts, _currentNode.NodeID, count); //remove selected contacts from available contacts foreach (NodeContact closestContact in closestContacts) { availableContacts.Remove(closestContact); } return(closestContacts); }
private object QueryFind(NodeContact[] initialContacts, BinaryID nodeID, RpcQueryType queryType) { List <NodeContact> availableContacts = new List <NodeContact>(initialContacts); List <NodeContact> respondedContacts = new List <NodeContact>(); List <NodeContact> failedContacts = new List <NodeContact>(); NodeContact[] alphaContacts; int alpha = KADEMLIA_ALPHA; bool finalRound = false; while (true) { //pick alpha contacts to query from available contacts lock (availableContacts) { alphaContacts = PickClosestContacts(availableContacts, alpha); } if (alphaContacts.Length < 1) { //no contacts available to query further lock (respondedContacts) { if (respondedContacts.Count > KADEMLIA_K) { return(KBucket.GetClosestContacts(respondedContacts, nodeID, KADEMLIA_K)); } else if (respondedContacts.Count > 0) { return(respondedContacts.ToArray()); } } return(null); } object lockObj = new object(); List <NodeContact> receivedContacts = new List <NodeContact>(); List <PeerEndPoint> receivedPeers = null; if (queryType == RpcQueryType.FIND_PEERS) { receivedPeers = new List <PeerEndPoint>(); } lock (lockObj) { //query each alpha contact async foreach (NodeContact alphaContact in alphaContacts) { ThreadPool.QueueUserWorkItem(QueryFindAsync, new object[] { lockObj, queryType, alphaContact, nodeID, availableContacts, respondedContacts, failedContacts, receivedContacts, receivedPeers }); } //wait for any of the contact to return new contacts if (Monitor.Wait(lockObj, QUERY_TIMEOUT)) { //got reply! if (queryType == RpcQueryType.FIND_PEERS) { lock (receivedPeers) { if (receivedPeers.Count > 0) { return(receivedPeers.ToArray()); } } } lock (receivedContacts) { if (receivedContacts.Count < 1) { //current round failed to return any new closer nodes if (finalRound) { if (queryType == RpcQueryType.FIND_PEERS) { return(null); } lock (respondedContacts) { if (respondedContacts.Count > KADEMLIA_K) { return(KBucket.GetClosestContacts(respondedContacts, nodeID, KADEMLIA_K)); } else { return(respondedContacts.ToArray()); } } } else { //resend query to k closest node not already queried finalRound = true; alpha = KADEMLIA_K; } } else { finalRound = false; alpha = KADEMLIA_ALPHA; } } } } } }
private object QueryFind(NodeContact[] initialContacts, BinaryNumber nodeID, DhtRpcType queryType) { if (initialContacts.Length < 1) { return(null); } List <NodeContact> seenContacts = new List <NodeContact>(initialContacts); List <NodeContact> learnedNotQueriedContacts = new List <NodeContact>(initialContacts); List <NodeContact> respondedContacts = new List <NodeContact>(); List <PeerEndPoint> receivedPeers = null; int alpha = KADEMLIA_ALPHA; bool finalRound = false; bool checkTerminationCondition = false; if (queryType == DhtRpcType.FIND_PEERS) { receivedPeers = new List <PeerEndPoint>(); } NodeContact previousClosestSeenContact = KBucket.GetClosestContacts(seenContacts, nodeID, 1)[0]; while (true) { NodeContact[] alphaContacts; //pick alpha contacts to query from learned contacts lock (learnedNotQueriedContacts) { alphaContacts = KBucket.GetClosestContacts(learnedNotQueriedContacts, nodeID, alpha); //remove selected alpha contacts from learned not queries contacts list foreach (NodeContact alphaContact in alphaContacts) { learnedNotQueriedContacts.Remove(alphaContact); } } if (alphaContacts.Length < 1) { checkTerminationCondition = true; } else { object lockObj = new object(); lock (lockObj) { //query each alpha contact async foreach (NodeContact alphaContact in alphaContacts) { Thread t = new Thread(delegate(object state) { DhtRpcPacket response; if (queryType == DhtRpcType.FIND_NODE) { response = Query(DhtRpcPacket.CreateFindNodePacketQuery(_currentNode, nodeID), alphaContact); } else { response = Query(DhtRpcPacket.CreateFindPeersPacketQuery(_currentNode, nodeID), alphaContact); } if ((response == null) || (response.Type != queryType)) { //time out or error //ignore contact by removing from seen contacts list lock (seenContacts) { seenContacts.Remove(alphaContact); } return; } //got reply! if ((queryType == DhtRpcType.FIND_PEERS) && (response.Peers.Length > 0)) { lock (receivedPeers) { foreach (PeerEndPoint peer in response.Peers) { if (!receivedPeers.Contains(peer)) { receivedPeers.Add(peer); } } } } //add alpha contact to responded contacts list lock (respondedContacts) { if (!respondedContacts.Contains(alphaContact)) { respondedContacts.Add(alphaContact); } } //add received contacts to learned contacts list lock (seenContacts) { lock (learnedNotQueriedContacts) { foreach (NodeContact contact in response.Contacts) { if (!seenContacts.Contains(contact)) { seenContacts.Add(contact); learnedNotQueriedContacts.Add(contact); } } } } //no pulse for final round to wait for all k contacts to respond. this allows any failed node contact to be removed from seen contacts list during the wait. lock (lockObj) { Monitor.Pulse(lockObj); } }); t.IsBackground = true; t.Start(); } //wait for any of the node contact to return new contacts if (Monitor.Wait(lockObj, QUERY_TIMEOUT)) { //got reply or final round! NodeContact currentClosestSeenContact; lock (seenContacts) { currentClosestSeenContact = KBucket.GetClosestContacts(seenContacts, nodeID, 1)[0]; } BinaryNumber previousDistance = nodeID ^ previousClosestSeenContact.NodeID; BinaryNumber currentDistance = nodeID ^ currentClosestSeenContact.NodeID; if (previousDistance <= currentDistance) { //current round failed to return a node contact any closer than the closest already seen if (finalRound) { //final round over, check for termination condition checkTerminationCondition = true; } else { //resend query to k closest node not already queried finalRound = true; alpha = KADEMLIA_K; } } else { //current closest seen contact is closer than previous closest seen contact previousClosestSeenContact = currentClosestSeenContact; finalRound = false; alpha = KADEMLIA_ALPHA; } } } } if (checkTerminationCondition) { checkTerminationCondition = false; //reset if (queryType == DhtRpcType.FIND_PEERS) { //check only in final round to get most peers lock (receivedPeers) { if (receivedPeers.Count > 0) { return(receivedPeers.ToArray()); } return(null); } } //lookup terminates when k closest seen contacts have responded NodeContact[] kClosestSeenContacts; lock (seenContacts) { kClosestSeenContacts = KBucket.GetClosestContacts(seenContacts, nodeID, KADEMLIA_K); } lock (respondedContacts) { bool success = true; foreach (NodeContact contact in kClosestSeenContacts) { if (!respondedContacts.Contains(contact)) { success = false; break; } } if (success) { return(kClosestSeenContacts); } if (alphaContacts.Length < 1) { return(KBucket.GetClosestContacts(respondedContacts, nodeID, KADEMLIA_K)); } } } } }