silly mistakes of not assigning proper weight, proper size of tou_step should...

 silly mistakes of not assigning proper weight, proper size of tou_step should be 20 , dictionary update of count value

Config.py

@@ -2,7 +2,7 @@ lambda_proposer = 30# wait time for priority messages to be received
 tou_proposer = 20 # proposer rolecount
 ROLE_BLOCK_PROPOSER = 'BLOCK_PROPOSER'
 
-tou_step = 3 # tou is expected number of users that sortition selects for committee
+tou_step = 20 # tou is expected number of users that sortition selects for committee
 ROLE_COMMITEE_FOR_VOTE = 'committee'
 
 lambda_block = 300 #seconds

Network.py

@@ -6,13 +6,14 @@ from OverlayNode import OverlayNode
 import logging
 import random
 from numpy.random import randint
-logger = logging.getLogger(__name__)
+
 import numpy as np
 import Config
 
 
 class Network():
     def __init__(self):
+        self.logger = logging.getLogger(__name__)
         self.nodes = {}#{1 : Node(1),2:Node(2)}
         self.links = {} #{(1,2):Link(1-2),(2,1):Link(2,1),(3,2):Link(3*2)}      linkID = tuple(1,2)
         self.networkClockTime = 0
@@ -42,6 +43,7 @@ class Network():
                 self.pk_weight_map.update({xnode[node].pk:w[i]})
                 self.nodes.update(xnode)#added node to network
                 # print(self.nodes.get('1')) #keys are strings
+                i = i+1
 
 
         with open('Links1.dat', 'r') as f:
@@ -61,6 +63,8 @@ class Network():
                 self.nodes.get(link[0]).adjacentNodes.append(link[1])
                 self.nodes.get(link[1]).adjacentNodes.append(link[0])
                 # print(self.links.get(('1', '2'))) #keys are strings
+        for node in self.nodes.values():
+            self.logger.info("node {}".format((node.id,node.adjacentNodes)))
 
 
         pass

OverlayNode.py

@@ -57,7 +57,9 @@ class OverlayNode(Node):
         seed = self.currentSeed
         role= (Config.ROLE_COMMITEE_FOR_VOTE, round, step)
         # Todo something is wrong here not getting correct votes back
+        self.logger.info("inputs to verify sort : {}".format((pk, sorthash, proof, seed, tou, role, self.network.pk_weight_map.get(pk), self.network.badaW)))
         votes = Utility.verifySort(pk, sorthash, proof, seed, tou, role, self.network.pk_weight_map.get(pk), self.network.badaW)
+        self.logger.info("outpusts of veifysort : {}".format(votes))
         if votes :
             self.logger.info("THese are valid committee votes with votes : "+str(votes))
         print("why votes be zero :",role)
@@ -82,7 +84,8 @@ class OverlayNode(Node):
                     print(self.id + " continuing")
                     continue
                 voters.append(msg_pk)
-                counts[value] = counts[value]+ votes
+                print("yup its wrong here")
+                counts[value] = counts.get(value, votes)
                 print('--------------counts-------------',self.id)
                 print(counts)
                 if counts[value] > T*tou :
@@ -107,11 +110,12 @@ class OverlayNode(Node):
             previousHash = hashlib.sha256(self.blockchain[-1].encode('utf-8')).hexdigest()
             seed = ( previousHash,self.currentRound,0)
             self.currentSeed= (previousHash, self.currentRound, 0)
+            self.logger.info("priority sortiion ip : {}".format((self.sk,seed,Config.tou_proposer, Config.ROLE_BLOCK_PROPOSER, self.weight, self.network.badaW, self.pk)))
             hash, proof, j = Utility.sortition(self.sk,seed,Config.tou_proposer, Config.ROLE_BLOCK_PROPOSER, self.weight, self.network.badaW, self.pk)
-
+            self.logger.info("priority sortition op : {}".format(( hash, proof, j )))
 
             if j > 0 : # only the block proposer commity mebers can enter here
-                self.logger.info("selection for BLOCK PROPOSAL with  J ="+str( j))
+                self.logger.info("selection for BLOCK PROPOSAL with  J ={}".format(j))
                 min_sha_priority = None
                 # min_sub_user_index = None
                 # msg_to_broadcast = ( currentRound, hash , min_sub_user_index , min_sha_priority )
@@ -127,7 +131,7 @@ class OverlayNode(Node):
 
 
                 priority_msg_to_broadcast = ( Config.PRIORITY_MSG_type,self.currentRound, hash , min_sub_user_index , min_sha_priority,proof )
-                self.logger.info("broadcsting priority message : "+str(priority_msg_to_broadcast))
+                self.logger.info("broadcsting priority message : {}".format(priority_msg_to_broadcast))
                 self.broadcast(self.network.time, priority_msg_to_broadcast)
 
 
@@ -137,6 +141,10 @@ class OverlayNode(Node):
                 greater_flag = True
 
                 msgs = self.uniqueReceivedMessages.pop(Config.PRIORITY_MSG_type)
+                msgs.sort(key=lambda priority_msg_other: priority_msg_other[4])
+                # list(map(lambda x: x[4], msgs)) # list only priorities
+                self.logger.info("Priority proposals from other nodes (number of proposal, proposals) : {}".format((len(msgs),list(map(lambda x: x[4], msgs)))))
+                # self.logger.info("Priority proposals from other nodes (number of proposal, proposals) : {}".format((len(msgs),msgs)))
                 for priority_msg_other in msgs :
                     if min_sha_priority > priority_msg_other[4]:
                         greater_flag = False
@@ -147,9 +155,11 @@ class OverlayNode(Node):
                     BLOCK_PROPOSAL_MSG_to_broadcast : ("BLOCK_PROPOSAL_MSG", previousblockhash,A random string as txns,Nod`s priority payload)
                     '''
                     BLOCK_PROPOSAL_MSG_to_broadcast = (Config.BLOCK_PROPOSAL_MSG_type, previousHash,Utility.pseudoRandomGenerator(random.randint(0,1000)),priority_msg_to_broadcast[1:])
-                    self.logger.info("broadcsting BLOCK Proposal Message : " + str(BLOCK_PROPOSAL_MSG_to_broadcast))
+                    self.logger.info("broadcsting BLOCK Proposal Message : {}".format(BLOCK_PROPOSAL_MSG_to_broadcast))
                     self.broadcast(self.network.time, BLOCK_PROPOSAL_MSG_to_broadcast)
                     blockForBA = (previousHash,BLOCK_PROPOSAL_MSG_to_broadcast[2])
+                    self.logger.info('Proposed block : {}'.format(blockForBA))
+
                 else:  # others than block proposers
                     # everybody except highest priority block proposer is waiting for lambda_proposer+ lambda_block 33 seconds
                     yield "resume", Config.lambda_proposer + Config.lambda_block
@@ -180,7 +190,7 @@ class OverlayNode(Node):
 
                 j = Utility.verifySort(pk, hash, proof, seed, Config.tou_proposer, Config.ROLE_BLOCK_PROPOSER, w, self.network.badaW)
                 if j :
-                    self.logger.info("it is a valid block proposed message with j : "+str(j))
+                    self.logger.info("it is a valid block proposed message with j : {}".format(j))
 
             #todo : DONE : drop block proposal msges
             try :
@@ -202,16 +212,18 @@ class OverlayNode(Node):
             # reduct_seed = (previousHash, self.currentRound, reduct_step_1)
             reduct_seed = self.currentSeed
             reduct_role_1 = (Config.ROLE_COMMITEE_FOR_VOTE,self.currentRound,reduct_step_1)
+            self.logger.info("sortition inside reduction step 1 ip : {}".format((self.sk, reduct_seed, Config.tou_step, reduct_role_1,
+                                               self.weight, self.network.badaW, self.pk)))
             reduct_sorthash, reduct_proof, reduct_j = Utility.sortition(self.sk, reduct_seed, Config.tou_step, reduct_role_1,
                                                self.weight, self.network.badaW, self.pk)
-            # print("Reduction algo " + self.id," : ",reduct_j)
+            self.logger.info("sortition inside reduction step 1 op : {}".format((reduct_sorthash, reduct_proof, reduct_j )))
 
             if reduct_j > 0:
-                self.logger.info("selection for VOTING COMMITEE with  J =" + str(reduct_j))
+                self.logger.info("selection for VOTING COMMITEE with  J ={}".format(reduct_j))
                 payload = (self.currentRound,reduct_step_1,reduct_sorthash,reduct_proof,previousHash,hashof_blockForBA)
                 committeeVoteMsg = (Config.COMMITTEE_VOTE_MSG_type,(self.pk,payload,self.sk.sign(bytes(str(payload).encode('UTF8')))))
                 self.broadcast(self.network.time,committeeVoteMsg)
-                self.logger.info("Broadcasting commitee messgae"+str(committeeVoteMsg))
+                self.logger.info("Broadcasting commitee messgae : {}".format(committeeVoteMsg))
 
             # print(self.uniqueReceivedMessages[Config.COMMITTEE_VOTE_MSG_type])
             yield "resume",Config.lambda_block+Config.lambda_step
@@ -242,26 +254,32 @@ class OverlayNode(Node):
                         hblock1 = temp_return
                         break
                 yield "resume",1 # this is to allow other nodes to be simulated and not get this node into infinite waiting on single node
-            self.logger.info("returning from first count values with return value : "+str(hblock1))
+            self.logger.info("returning from first count values with return value : {}".format(hblock1))
             print("returning from first count values with return value",hblock1)
 
+            self.logger.info("votes count reduction step 1 : {}".format(counts))
+
             ######## END : count votes for hblock1 ###########
 
             '''    END : COmmitte vote reduction step 1'''
-            #
-            # ''' Start : COmmitte vote reduction step 2 '''
-            # empty_hash = Utility.pseudoRandomGenerator((previousHash, "Empty"))
-            #
-            # # which block to vote empty or hblock1
-            # reduct_step2_block_to_vote = None
-            # if hblock1 == Config.TIMEOUT :
-            #     reduct_step2_block_to_vote = empty_hash
-            #     pass
-            # else:
-            #     reduct_step2_block_to_vote = hblock1
-            #     pass
-            #
-            # '''    COmmitte vote reduction step2 : reduct_step2_block_to_vote'''
+
+            ''' Start : COmmitte vote reduction step 2 '''
+            empty_hash = Utility.pseudoRandomGenerator((previousHash, "Empty"))
+
+            # which block to vote empty or hblock1
+            reduct_step2_block_to_vote = None
+            if hblock1 == Config.TIMEOUT :
+                reduct_step2_block_to_vote = empty_hash
+                self.logger.info("consensus for block in reduction step 1 : {}".format((previousHash, "Empty")))
+                pass
+            else:
+                reduct_step2_block_to_vote = hblock1
+                self.logger.info("consensus for block in reduction step 1 : {}".format(reduct_step2_block_to_vote))
+                pass
+
+
+
+            '''    COmmitte vote reduction step2 : reduct_step2_block_to_vote'''
             #
             # variables_reduct_step_2 = {}
             #
@@ -400,14 +418,24 @@ class OverlayNode(Node):
 def m(v):
     v.append('ganesh')
 
+
+
+def takeSecond(elem):
+   return elem[1]
+
+
 if __name__ == '__main__':
-    x = 2
-    if True:
-        x = 3
-        print(x)
+    d = {}
+    key = 2
+    value =5
+    d[key] = d.get(key, value)
+
+    print(d[2])
 
-    print(x)
+    v = 7
+    d[key] = d.get(key, v)
 
+    print(d[2])
 
 
 

searching

+
+Received proposal from other nodes : Priority proposals from other nodes
+
+listing block proposals : broadcsting BLOCK Proposal Message
+
+To search votes in reduction step 1 : votes count reduction step 1
+
+reduction step 1 consensus : consensus for block in reduction step 1
+