def __dataHandle(self, data):
if data['No'] == 1:
# logcontent = 'Handle a random number:' + str(data['content']['genrandom'])
# self.logger.info(logcontent)
# if str(data['content']['genrandom']) not in glovar.RanList:
glovar.newRanLock.acquire()
glovar.NewRanList.append(str(data['content']['genrandom']))
glovar.newRanLock.release()
broadMessage(data)
# logcontent = ' Broad this committee random number again: ' + str(data['genrandom'])
# self.logger.info(logcontent)
# Receive a hashseed
if data['No'] == 2:
# logcontent = ' Receive a hashvalue:' + str(data['content']['ranhash'])
# self.logger.info(logcontent)
# if data['ranhash'] not in glovar.HashList:
glovar.newHashLock.acquire()
glovar.NewHashList.append(data['content']['ranhash'])
glovar.newHashLock.release()
if (glovar.NewHashSeed == 0
or data['content']['ranhash'] < glovar.NewHashSeed):
glovar.newHashLock.acquire()
glovar.NewHashSeed = data['content']['ranhash']
glovar.newHashLock.release()
broadMessage(data)
def broadFirstCommitBlock(self):
for each in glovar.ComList:
if self.cominfo[1] == each[1]:
if len(each[3]['newblock']):
content = {'block':each[3]['newblock'][0],'incomno':each[0],\
'comid':each[1],'commitnum':each[3]['commit'],\
'comlist':each[3]['commitlist']}
else:
return
beforesend = {
'type': 'firstblock',
'No': 3,
'content': content
}
temp = str(beforesend)
hashvalue = hashlib.sha256(temp.encode('utf-8')).hexdigest()
senddata = {
'messageid': hashvalue,
'type': 'firstblock',
'No': 3,
'content': content
}
for each in glovar.ComList:
if each[0] == self.cominfo[0] and each[1] != self.cominfo[1]:
each[5].acquire()
each[4].put(senddata)
each[5].release()
if each[0] == glovar.Firstcomno + 1:
each[5].acquire()
each[4].put(senddata)
each[5].release()
glovar.messageLock.acquire()
glovar.MessageList.append(hashvalue)
glovar.messageLock.release()
broadMessage(senddata)
logcontent = 'Broad a commit firstblock:' + \
str(senddata['content']['block'][4])
self.logger.info(logcontent)
def broadSecondCommitBlock(self):
for each in glovar.ComList:
if each[1] == self.cominfo[1]:
content = {'block':each[3]['newsecondblock'][0],'incomno':self.cominfo[0],'comid':self.cominfo[1],'commitnum':each[3]['secondcommit'],'comlist':each[3]['secondcommitlist']}
beforesend = {'type':'secondblock','No':3,'content':content}
temp = str(beforesend)
hashvalue = hashlib.sha256(temp.encode('utf-8')).hexdigest()
senddata = {'messageid':hashvalue,'type':'secondblock','No':3,'content':content}
for each in glovar.ComList:
if each[1] != self.cominfo[1]:
each[5].acquire()
each[4].put(senddata)
each[5].release()
glovar.messageLock.acquire()
glovar.MessageList.append(hashvalue)
glovar.messageLock.release()
broadMessage(senddata)
logcontent = 'Broad a second commit block:' + str(senddata['content']['block'][1])
self.logger.info(logcontent)
def com_formation(self):
# initial global status
glovar.newComLock.acquire()
glovar.NewComList.clear()
glovar.newComLock.release()
glovar.newRanLock.acquire()
glovar.NewRanList.clear()
glovar.newRanLock.release()
glovar.newHashLock.acquire()
glovar.NewHashList.clear()
glovar.NewHashSeed = 0
glovar.newHashLock.release()
glovar.NewPosList.clear()
self.logger.info('--------------------------------------------------')
# Start committee formation
random.seed()
genrandom = random.uniform(0, 1)
logcontent = 'Send a random number: ' + str(genrandom)
self.logger.info(logcontent)
glovar.newRanLock.acquire()
glovar.NewRanList.append(str(genrandom))
glovar.newRanLock.release()
timestamp = time.time()
content = {'genrandom': genrandom}
beforesend = {
'type': 'newcommittee',
'No': 1,
'timestamp': timestamp,
'content': content
}
temp = str(beforesend)
hashvalue = hashlib.sha256(temp.encode('utf-8')).hexdigest()
senddata = {
'messageid': hashvalue,
'type': 'newcommittee',
'No': 1,
'timestamp': timestamp,
'content': content
}
glovar.messageLock.acquire()
glovar.MessageList.append(hashvalue)
glovar.messageLock.release()
broadMessage(senddata)
# Wait one or two RANBROAD_TIME duration for generating hashvalue
starttime = int(time.time())
curtime = starttime
while curtime < starttime + RANBROAD_TIME:
try:
glovar.newComqueueLock.acquire()
data = glovar.newcomqueue.get_nowait()
glovar.newComqueueLock.release()
# logcontent = 'Get a message:' + str(data['messageid'])
# self.logger.info(logcontent)
self.__dataHandle(data)
except queue.Empty:
glovar.newComqueueLock.release()
time.sleep(0.1)
finally:
curtime = int(time.time())
logcontent = 'Received new committee random numbers: ' + str(
len(glovar.NewRanList))
self.logger.info(logcontent)
self.logger.info(glovar.NewRanList)
# self.logger.info('Generate hash value of random numbers.')
glovar.newRanLock.acquire()
randomstring = "".join(glovar.NewRanList)
glovar.newRanLock.release()
hashvalue = int(
hashlib.sha256(randomstring.encode('utf-8')).hexdigest(), 16)
glovar.newHashLock.acquire()
glovar.NewHashSeed = hashvalue
glovar.NewHashList.append(hashvalue)
glovar.newHashLock.release()
content = {'ranhash': hashvalue, 'ranlist': glovar.NewRanList}
beforesend = {'type': 'newcommittee', 'No': 2, 'content': content}
temp = str(beforesend)
hashvalue = hashlib.sha256(temp.encode('utf-8')).hexdigest()
senddata = {
'messageid': hashvalue,
'type': 'newcommittee',
'No': 2,
'content': content
}
glovar.messageLock.acquire()
glovar.MessageList.append(hashvalue)
glovar.messageLock.release()
broadMessage(senddata)
# Wait one or two RANBROAD_TIME duration for agree on the smallest hashvalue
starttime = int(time.time())
curtime = starttime
while curtime < starttime + RANBROAD_TIME:
try:
data = glovar.newcomqueue.get_nowait()
# logcontent = 'Get a message:' + str(data['messageid'])
# self.logger.info(logcontent)
self.__dataHandle(data)
except queue.Empty:
time.sleep(0.1)
finally:
curtime = int(time.time())
logcontent = 'Received new committee hashvalue list numbers: ' + str(
len(glovar.NewHashList))
self.logger.info(logcontent)
# self.logger.info(glovar.HashList)
logcontent = 'The final new committee HashSeed is:\n' + str(
glovar.NewHashSeed)
self.logger.info(logcontent)
# Generate random number to choose members for each committee
nodenum = glovar.Firstcommem * glovar.Firstcomno + glovar.Secondcommem
comnum = glovar.Firstcomno + 1
random.seed(glovar.NewHashSeed)
for i in range(nodenum):
glovar.NewPosList.append(random.uniform(0, glovar.Stakesum))
logcontent = 'NewPosList:' + str(len(glovar.NewPosList)) + '\n' + str(
glovar.NewPosList)
self.logger.info(logcontent)
# logcontent = 'NodeId: ' + str(glovar.NodeId)
# self.logger.info(logcontent)
# logcontent = 'Stakemin: ' + str(glovar.Stakemin)
# self.logger.info(logcontent)
# logcontent = 'Stakemax: ' + str(glovar.Stakemax)
# self.logger.info(logcontent)
# logcontent = 'Firstcommem: ' + str(glovar.Firstcommem)
# self.logger.info(logcontent)
# logcontent = 'Firstcomno: ' + str(glovar.Firstcomno)
# self.logger.info(logcontent)
# logcontent = 'Secondcommem: ' + str(glovar.Secondcommem)
# self.logger.info(logcontent)
# Record the status of committee
for i in range(nodenum):
if (glovar.NewPosList[i] > glovar.Stakemin
and glovar.NewPosList[i] <= glovar.Stakemax):
incomno = i // glovar.Firstcommem + 1
if (incomno < comnum):
commember = glovar.NewPosList[(incomno - 1) *
glovar.Firstcommem:incomno *
glovar.Firstcommem]
else:
commember = glovar.NewPosList[(incomno - 1) *
glovar.Firstcommem:]
newblock = []
commitlist = []
commitblocklist = []
comstatus = {
'genblock': 0,
'blockhash': '0',
'stage': 0,
'commit': 0,
'commitlist': commitlist,
'newblock': newblock,
'verify': 0,
'commitblock': 0,
'commitblocklist': commitblocklist
}
comnodequeue = queue.Queue()
cominfo = [
incomno, glovar.NewPosList[i], commember, comstatus,
comnodequeue
]
glovar.NewComList.append(cominfo)
self.logger.info('--------------------------------------------')
if len(glovar.NewComList):
logcontent = 'Next new committee nodes:\n'
for each in glovar.NewComList:
logcontent += str(each) + '\n'
self.logger.info(logcontent)
def run(self):
# Config the directory of log file
filename = self.logdirectory + 'DelayMeasurelog.txt'
self.logger = logging.getLogger('DelayMeasure')
self.logger.setLevel(level=logging.INFO)
handler = logging.FileHandler(filename)
handler.setLevel(logging.INFO)
formatter = logging.Formatter('%(asctime)s - %(name)s - %(message)s')
handler.setFormatter(formatter)
self.logger.addHandler(handler)
self.logger.info('Start delay measurement process')
firstdelayname = self.logdirectory + '/firstdelay.txt'
seconddelayname = self.logdirectory + '/seconddelay.txt'
time.sleep(INIWAIT_TIME + 2 * RANBROAD_TIME + 10)
testtime = 10
# for i in range(10):
while True:
self.firstconfirm = 0
trans_input_no = 1
trans_input_item = ['123']
trans_input = [trans_input_no, trans_input_item]
trans_output_no = 1
trans_output_output1 = ['456', 1]
trans_output_item = [trans_output_output1]
trans_output = [trans_output_no, trans_output_item]
timestamp = time.time()
temptransaction = [trans_input, trans_output, timestamp]
temp = str(temptransaction)
hashvalue = hashlib.sha256(temp.encode('utf-8')).hexdigest()
newtransaction = [hashvalue, trans_input, trans_output, timestamp]
glovar.TransactionList.append(newtransaction)
senddata = {
'messageid': hashvalue,
'type': 'transaction',
'No': 1,
'content': newtransaction
}
glovar.messageLock.acquire()
glovar.MessageList.append(hashvalue)
glovar.messageLock.release()
start_length = len(glovar.BLOCKCHAIN)
start_time = time.time()
# Start the firstblock confirmation process
firstthread = threading.Thread(target=self.__firstCheck,
args=(start_time, hashvalue,
firstdelayname))
firstthread.start()
broadMessage(senddata)
end_time = start_time - 1
notfind = True
while notfind:
cur_time = time.time()
if len(glovar.BLOCKCHAIN) > start_length:
block = glovar.BLOCKCHAIN[start_length]
for each in block[7]:
if hashvalue == each[0]:
end_time = time.time()
notfind = False
break
start_length += 1
if notfind:
if int(cur_time) - int(start_time) > 60:
logcontent = "Transction:" + str(hashvalue) + \
" second comfirmation has surpassed 60 seconds."
self.logger.info(logcontent)
break
else:
time.sleep(0.05)
if not notfind:
latency = end_time - start_time
logcontent = "Transaction:" + str(
hashvalue) + " final latency:" + str(latency)
self.logger.info(logcontent)
ftps = open(seconddelayname, 'a')
output = str(latency) + "\n"
ftps.write(output)
ftps.close()
firstthread.join()
self.logger.info("The second confirmation is finishied")
# while not self.firstconfirm:
# time.sleep(0.1)
self.logger.info("Transaction delay measurement is over")
def __dataHandle(self, data):
if data['type'] == 'firstblock' and data['No'] == 3:
# Verify whether it is commited by the committee member
if (data['content']['commitnum'] >= glovar.Firstcommem//2+1):
# logcontent = 'A valid commit firstblock:' + str(data['content']['block'][4])
# self.logger.info(logcontent)
for each in glovar.ComList:
if self.cominfo[1] == each[1]:
if data['content']['block'][4] not in each[3]['addfirstlist']:
each[3]['commitblocklist'].append(data['content']['block'][4])
each[3]['transactionlist'].extend(data['content']['block'][5])
# logcontent = 'Save a commit firstblock:' + str(data['content']['block'][4])
# self.logger.info(logcontent)
if data['type'] == 'secondblock' and data['No'] == 1:
# logcontent = 'Handle a secondblock:' + str(data['messageid'])
# self.logger.info(logcontent)
blockdata = data['content']
# Verify if the node is in our committee
if blockdata[3] in self.cominfo[2]:
logcontent = 'Verify a secondblock:' + str(blockdata[1]) + ' from comid:' + str(blockdata[3])
self.logger.info(logcontent)
# Send a commitment message
content = {'blockhash':blockdata[1],'incomno':self.cominfo[0],'comid':self.cominfo[1],'commit':1}
beforesend = {'type':'secondblock','No':2,'content':content}
temp = str(beforesend)
hashvalue = hashlib.sha256(temp.encode('utf-8')).hexdigest()
senddata = {'messageid':hashvalue,'type':'secondblock','No':2,'content':content}
glovar.messageLock.acquire()
glovar.MessageList.append(hashvalue)
glovar.messageLock.release()
broadMessage(senddata)
logcontent = 'Send a second commitment for block:' + str(senddata['content']['blockhash'])
self.logger.info(logcontent)
# Check if there is another PoS in the same committee
for each in glovar.ComList:
if each[0] == self.cominfo[0] and each[1] != self.cominfo[1]:
each[5].acquire()
each[4].put(senddata)
each[5].release()
if data['type'] == 'secondblock' and data['No'] == 2:
# logcontent = 'Handle a second commitment:' + str(data['messageid'])
# self.logger.info(logcontent)
# Verify whether it is commited by the committee member
if data['content']['comid'] in self.cominfo[2]:
logcontent = 'Verify a second commitment for block:' + str(data['content']['blockhash']) + ' from comid:' + str(data['content']['comid'])
self.logger.info(logcontent)
for each in glovar.ComList:
if each[1] == self.cominfo[1]:
if each[3]['verify']:
if each[3]['secondblockhash'] == data['content']['blockhash']:
each[3]['secondcommit'] += 1
each[3]['secondcommitlist'].append(data['content']['comid'])
logcontent = 'Secondblock:' + str(each[3]['secondblockhash']) + ' receive a commit. Total:' + str(each[3]['secondcommit'])
self.logger.info(logcontent)
# Receive enough commitment
if (each[3]['secondcommit'] >= glovar.Secondcommem//2+1):
logcontent = 'Receive enough commitment for blocblock:' + str(each[3]['secondblockhash'])
self.logger.info(logcontent)
self.broadSecondCommitBlock()
self.addBlock(each[3]['newsecondblock'][0])
if data['type'] == 'secondblock' and data['No'] == 3:
# logcontent = 'Handle a commit secondblock:' + str(data['content']['block'][1])
# self.logger.info(logcontent)
# Verify if the firstblock has received enough commitment from its committee
listisin = True
for each in data['content']['comlist']:
if each not in self.cominfo[2]:
listisin = False
break
if listisin:
logcontent = 'Verified the commit secondblock:' + str(data['content']['block'][1])
self.logger.info(logcontent)
for each in glovar.ComList:
if each[1] == self.cominfo[1]:
# Delate the blockhash has been included in the
# secondblock from commitblocklist
each[5].acquire()
# logcontent = "each[3]['commitblocklist']:" + str(each[3]['commitblocklist'])
# self.logger.info(logcontent)
# logcontent = "data['content']['block'][6]:" + str(data['content']['block'][6])
# self.logger.info(logcontent)
templist = []
for every in each[3]['commitblocklist']:
if every not in data['content']['block'][6]:
templist.append(every)
each[3]['commitblocklist'] = templist.copy()
temptranslist = []
for every in each[3]['transactionlist']:
if every not in data['content']['block'][7]:
temptranslist.append(every)
each[3]['transactionlist'] = temptranslist.copy()
each[3]['addfirstlist'].extend(data['content']['block'][6])
# logcontent = "each[3]['addfirstlist']:" + str(each[3]['addfirstlist'])
# self.logger.info(logcontent)
# logcontent = "each[3]['commitblocklist']:" + str(each[3]['commitblocklist'])
# self.logger.info(logcontent)
each[5].release()
self.addBlock(data['content']['block'])
def __gendatablock(self):
# stillin = True
time.sleep(5)
cur_time = int(time.time())
prev_time = cur_time - ( cur_time % BLOCK_INTERVAL ) + BLOCK_INTERVAL
while True:
cur_time = int(time.time())
if cur_time > prev_time:
# Select a leader to generate block
self.logger.info('----------------------------------------')
# logcontent = 'Choose a new leader to generate a secondblock'
# self.logger.info(logcontent)
randomstring = "".join(str(self.cominfo[2]))
glovar.blockchainLock.acquire()
if len(glovar.BLOCKCHAIN):
prevhash = glovar.BLOCKCHAIN[len(glovar.BLOCKCHAIN)-1][1]
else:
prevhash = 0
blockheight = len(glovar.BLOCKCHAIN) +1
glovar.blockchainLock.release()
randomstring += str(prevhash)
logcontent = "randomstring:" + str(randomstring)
self.logger.info(logcontent)
idchoose = int(hashlib.sha256(randomstring.encode('utf-8')).hexdigest(), 16) % len(self.cominfo[2])
logcontent = str(idchoose+1) + ' member: ' + \
str(self.cominfo[2][idchoose]) + ' is chosen to generate a second block'
self.logger.info(logcontent)
# Self is selected
if self.cominfo[1] == self.cominfo[2][idchoose]:
for each in glovar.ComList:
if self.cominfo[1] == each[1]:
each[5].acquire()
commitblocklist = each[3]['commitblocklist'].copy()
transactionlist = each[3]['transactionlist'].copy()
each[3]['commitblocklist'].clear()
each[3]['transactionlist'].clear()
each[3]['verify'] = 1
# logcontent = "each[3]['commitblocklist']:" + str(len(each[3]['commitblocklist']))
# self.logger.info(logcontent)
each[5].release()
timestamp = time.time()
temp = str(prevhash) + str(self.cominfo[0]) + str(self.cominfo[1]) + str(self.cominfo[2]) + str(timestamp) + str(commitblocklist) + str(len(transactionlist))
hashvalue = hashlib.sha256(temp.encode('utf-8')).hexdigest()
newblock = [prevhash,hashvalue,self.cominfo[0],self.cominfo[1],self.cominfo[2],timestamp,commitblocklist,transactionlist, blockheight]
for each in glovar.ComList:
if self.cominfo[1] == each[1]:
each[5].acquire()
each[3]['secondblockhash'] = hashvalue
each[3]['newsecondblock'].append(newblock)
each[5].release()
senddata = {'messageid':hashvalue,'type':'secondblock','No':1,'content':newblock}
glovar.messageLock.acquire()
glovar.MessageList.append(hashvalue)
glovar.messageLock.release()
broadMessage(senddata)
self.logger.info('---------------------------------')
logcontent = str(self.cominfo[1]) + ' :broadcast a second block:' + str(hashvalue)
self.logger.info(logcontent)
# Send data to this PoS node process
for each in glovar.ComList:
if each[0] == self.cominfo[0] and each[1] != self.cominfo[1]:
each[5].acquire()
each[4].put(senddata)
each[5].release()
prev_time += BLOCK_INTERVAL
else:
time.sleep(0.2)
# Check if the PoS node is still in the verify committee
if glovar.ComChange:
# for each in glovar.ComList:
# if self.cominfo[1] == each[1]:
# each[6] = 0
# break
break
logcontent = "The secondblock generation pocess is ended"
self.logger.info(logcontent)
def addBlock(self, block):
glovar.firstchainLock.acquire()
if len(glovar.FIRSTBLOCKCHAIN):
if glovar.FIRSTBLOCKCHAIN[len(glovar.FIRSTBLOCKCHAIN) -
1][4] != block[4]:
glovar.FIRSTBLOCKCHAIN.append(block)
# logcontent = 'Add a firstblock to the chain'
# self.logger.info(logcontent)
else:
glovar.FIRSTBLOCKCHAIN.append(block)
# logcontent = 'Add a firstblock to the chain'
# self.logger.info(logcontent)
glovar.firstchainLock.release()
# Change the status of committee member
for each in glovar.ComList:
if each[1] == self.cominfo[1]:
# each[5].acquire()
each[3]['genblock'] = 0
each[3]['blockhash'] = '0'
each[3]['commit'] = 0
each[3]['commitlist'].clear()
each[3]['newblock'].clear()
# each[5].release()
# self.logger.info('----------------------------------------------')
# logcontent = 'Choose a new leader to Generate a block'
# self.logger.info(logcontent)
incomno = self.cominfo[0]
comid = self.cominfo[1]
commember = self.cominfo[2]
# Select a leader to generate block
randomstring = "".join(str(self.cominfo[2])) + str(block[1]) + str(
block[4])
idchoose = int(
hashlib.sha256(randomstring.encode('utf-8')).hexdigest(),
16) % len(commember)
logcontent = 'The ' + str(idchoose + 1) + ' member: ' + str(
commember[idchoose]) + ' is chosen to generate a block'
self.logger.info(logcontent)
# Self is selected
transactions = []
if comid == commember[idchoose]:
# Add transactions into the new block
for each in glovar.ComList:
if comid == each[1]:
# If the PoS node has received transactions
if len(each[3]['transactionlist']):
for every in each[3]['transactionlist']:
transactions.append(every)
each[3]['transactionlist'].clear()
# Create a new transaction to add
else:
trans_input_no = 1
trans_input_item = ['abc']
trans_input = [trans_input_no, trans_input_item]
trans_output_no = 1
trans_output_output1 = ['efg', 5]
trans_output_item = [trans_output_output1]
trans_output = [trans_output_no, trans_output_item]
timestamp = time.time()
temptransaction = [
trans_input, trans_output, timestamp
]
temp = str(temptransaction)
hashvalue = hashlib.sha256(
temp.encode('utf-8')).hexdigest()
newtransaction = [
hashvalue, trans_input, trans_output, timestamp
]
transactions.append(newtransaction)
timestamp = time.time()
temp = str(incomno) + str(comid) + str(commember) + str(
timestamp) + str(transactions)
hashvalue = hashlib.sha256(temp.encode('utf-8')).hexdigest()
newblock = [
incomno, comid, commember, timestamp, hashvalue, transactions
]
json_block = json.dumps(newblock)
senddata = {
'messageid': hashvalue,
'type': 'firstblock',
'No': 1,
'content': json_block
}
glovar.messageLock.acquire()
glovar.MessageList.append(hashvalue)
glovar.messageLock.release()
broadMessage(senddata)
self.logger.info('---------------------------------')
logcontent = str(incomno) + ' :broadcast a block:' + str(hashvalue)
self.logger.info(logcontent)
# Change the corresponding global status
for each in glovar.ComList:
if comid == each[1]:
glovar.ComlistLock.acquire()
each[3]['genblock'] = 1
each[3]['blockhash'] = hashvalue
each[3]['newblock'].append(newblock)
glovar.ComlistLock.release()
# Check if there is another PoS in the same committee
for every in glovar.ComList:
if (every[0] == incomno and every[1] != comid):
# Send data to this PoS node process
each[5].acquire()
every[4].put(senddata)
each[5].release()
def run(self):
filename = self.logdirectory + 'Blockgenlog.txt'
self.logger = logging.getLogger(str(self.cominfo[1]))
self.logger.setLevel(level=logging.INFO)
handler = logging.FileHandler(filename)
handler.setLevel(logging.INFO)
formatter = logging.Formatter('%(asctime)s - %(name)s - %(message)s')
handler.setFormatter(formatter)
self.logger.addHandler(handler)
incomno = self.cominfo[0]
comid = self.cominfo[1]
commember = self.cominfo[2]
logcontent = 'Start committee ' + str(incomno)
self.logger.info(logcontent)
# Select a leader to generate block
randomstring = "".join(str(commember))
idchoose = int(
hashlib.sha256(randomstring.encode('utf-8')).hexdigest(),
16) % len(commember)
logcontent = 'The ' + str(idchoose + 1) + ' member: ' + str(
commember[idchoose]) + ' is chosen to generate a block'
self.logger.info(logcontent)
# Self is selected
transactions = []
if comid == commember[idchoose]:
# Add transactions into the new block
for each in glovar.ComList:
if comid == each[1]:
# If the PoS node has received transactions
if len(each[3]['transactionlist']):
for every in each[3]['transactionlist']:
transactions.append(every)
each[3]['transactionlist'].clear()
# Create a new transaction to add
else:
trans_input_no = 1
trans_input_item = ['abc']
trans_input = [trans_input_no, trans_input_item]
trans_output_no = 1
trans_output_output1 = ['efg', 5]
trans_output_item = [trans_output_output1]
trans_output = [trans_output_no, trans_output_item]
timestamp = time.time()
temptransaction = [
trans_input, trans_output, timestamp
]
temp = str(temptransaction)
hashvalue = hashlib.sha256(
temp.encode('utf-8')).hexdigest()
newtransaction = [
hashvalue, trans_input, trans_output, timestamp
]
transactions.append(newtransaction)
timestamp = time.time()
temp = str(incomno) + str(comid) + str(commember) + str(
timestamp) + str(transactions)
hashvalue = hashlib.sha256(temp.encode('utf-8')).hexdigest()
newblock = [
incomno, comid, commember, timestamp, hashvalue, transactions
]
json_block = json.dumps(newblock)
senddata = {
'messageid': hashvalue,
'type': 'firstblock',
'No': 1,
'content': json_block
}
# Wait for other Pos node to start up receive process
time.sleep(5)
glovar.messageLock.acquire()
glovar.MessageList.append(hashvalue)
glovar.messageLock.release()
broadMessage(senddata)
self.logger.info('---------------------------------')
logcontent = str(incomno) + ' :broadcast a block:' + str(hashvalue)
self.logger.info(logcontent)
# Change the corresponding global status
for each in glovar.ComList:
if comid == each[1]:
glovar.ComlistLock.acquire()
each[3]['genblock'] = 1
each[3]['blockhash'] = hashvalue
each[3]['stage'] = 1
each[3]['newblock'].append(newblock)
glovar.ComlistLock.release()
# Check if there is another PoS in the same committee
for every in glovar.ComList:
if (every[0] == incomno and every[1] != comid):
# Send data to this PoS node process
glovar.ComlistLock.acquire()
every[4].put(senddata)
glovar.ComlistLock.release()
# Get message from its queue belong to this PoS node
for each in glovar.ComList:
if comid == each[1]:
while True:
try:
data = each[4].get_nowait()
# logcontent = 'Get a data'
# self.logger.info(logcontent)
#broadMessage(data)
self.dataHandle(data)
except queue.Empty:
time.sleep(0.05)
# Check if the committee has changed
if glovar.ComChange:
each[6] = 0
break
# End the process
logcontent = 'The process is ended.'
self.logger.info(logcontent)
def dataHandle(self, data):
if data['type'] == 'transaction':
# logcontent = "Handle a transaction:" + str(data['messageid'])
# self.logger.info(logcontent)
for each in glovar.ComList:
if self.cominfo[1] == each[1]:
each[3]['transactionlist'].append(data['content'])
elif data['type'] == 'firstblock':
# Verify whether it is commited by the committee member
if data['No'] == 1:
# logcontent = 'Handle a firstblock:' + str(data['messageid'])
# self.logger.info(logcontent)
blockdata = json.loads(data['content'])
# Verify if the node is in our committee
if blockdata[1] in self.cominfo[2]:
logcontent = 'Verify a firstblock:' + str(
blockdata[4]) + ' from comid:' + str(
blockdata[1]) + ' in committee:' + str(
self.cominfo[0])
self.logger.info(logcontent)
# Change the corresponding global status
for each in glovar.ComList:
if self.cominfo[1] == each[1]:
# glovar.ComlistLock.acquire()
each[3]['newblock'].append(blockdata)
# glovar.ComlistLock.release()
# Send a commitment message
content = {
'blockhash': blockdata[4],
'incomno': blockdata[0],
'comid': self.cominfo[1],
'commit': 1
}
beforesend = {
'type': 'firstblock',
'No': 2,
'content': content
}
temp = str(beforesend)
hashvalue = hashlib.sha256(
temp.encode('utf-8')).hexdigest()
senddata = {
'messageid': hashvalue,
'type': 'firstblock',
'No': 2,
'content': content
}
glovar.messageLock.acquire()
glovar.MessageList.append(hashvalue)
glovar.messageLock.release()
broadMessage(senddata)
logcontent = 'Send a commitment for block:' + str(
senddata['content']['blockhash'])
self.logger.info(logcontent)
# Check if there is another PoS in the same committee
for each in glovar.ComList:
if each[0] == self.cominfo[
0] and each[1] != self.cominfo[1]:
each[5].acquire()
each[4].put(senddata)
each[5].release()
elif data['No'] == 2:
# logcontent = 'Handle a commitment:' + str(data['messageid'])
# self.logger.info(logcontent)
# Verify whether it is commited by the committee member
if data['content']['comid'] in self.cominfo[2]:
logcontent = 'Verify a commitment for block:' + str(
data['content']['blockhash']) + ' from comid:' + str(
data['content']['comid'])
self.logger.info(logcontent)
for each in glovar.ComList:
if each[1] == self.cominfo[1]:
if each[3]['genblock']:
if data['content']['blockhash'] == each[3][
'blockhash']:
each[3]['commit'] += 1
each[3]['commitlist'].append(
data['content']['comid'])
logcontent = 'Block:' + str(
each[3]['blockhash']
) + ' receive a commit. Total:' + str(
each[3]['commit'])
self.logger.info(logcontent)
# Receive enough commitment
if (each[3]['commit'] >=
glovar.Firstcommem // 2 + 1):
logcontent = 'Receive enough commitment for blocblock:' + str(
each[3]['blockhash'])
self.logger.info(logcontent)
self.broadFirstCommitBlock()
self.addBlock(each[3]['newblock'][0])
## logcontent = 'Run a new round to Generate a block'
## self.logger.info(logcontent)
elif data['No'] == 3:
# logcontent = 'Handle a commit firstblock:' + str(data['content']['block'][4])
# self.logger.info(logcontent)
# Verify the commit firstblock
listisin = True
for each in data['content']['comlist']:
if each not in self.cominfo[2]:
listisin = False
break
if listisin:
logcontent = 'Verified the commit firstblock:' + str(
data['content']['block'][4])
self.logger.info(logcontent)
for each in glovar.ComList:
if each[1] == self.cominfo[1]:
if len(each[3]['transactionlist']):
each[5].acquire()
temptransactions = []
for every in each[3]['transactionlist']:
if every not in data['content']['block'][
5]:
temptransactions.append(every)
each[3][
'transactionlist'] = temptransactions.copy(
)
each[5].release()
self.addBlock(data['content']['block'])
else:
logcontent = "Unkown data with data['type']:firstblock"
self.logger.info(logcontent)
# Receive a commit secondblock
elif data['type'] == 'secondblock' and data['No'] == 3:
logcontent = 'Handle a commit secondblock:'
self.logger.info(logcontent)
for each in glovar.ComList:
if each[1] == self.cominfo[1]:
if len(each[3]['transactionlist']):
each[5].acquire()
temptransactions = []
for every in each[3]['transactionlist']:
if every not in data['content']['block'][7]:
temptransactions.append(every)
each[3]['transactionlist'] = temptransactions.copy()
each[5].release()
glovar.blockchainLock.acquire()
if len(glovar.BLOCKCHAIN):
if glovar.BLOCKCHAIN[len(glovar.BLOCKCHAIN) -
1][1] != data['content']['block'][1]:
glovar.BLOCKCHAIN.append(data['content']['block'])
logcontent = 'Add a secondblock to the chain'
self.logger.info(logcontent)
else:
glovar.BLOCKCHAIN.append(data['content']['block'])
logcontent = 'Add a secondblock to the chain'
self.logger.info(logcontent)
glovar.blockchainLock.release()
else:
logcontent = 'Handle an unkown data:' + str(data)
self.logger.info(logcontent)
def comformation(self):
# glovar.ComList.clear()
# Inform other PoS node process to stop
glovar.ComChange = 1
notend = True
while notend:
notend = False
for each in glovar.ComList:
if each[6]:
notend = True
break
time.sleep(0.05)
glovar.ComList.clear()
# glovar.broadLock.acquire()
# broadnum = glovar.broadqueue.qsize()
# glovar.broadqueue.queue.clear()
# broadnumafter = glovar.broadqueue.qsize()
# glovar.broadLock.release()
#
# logcontent = "broadqueue number:" + str(broadnum) + " braodqueue number after:" + str(broadnumafter)
# self.logger.info(logcontent)
#
# # Clear messages generated by last committees
# glovar.msgLock.acquire()
# msgnum = glovar.msgqueue.qsize()
# glovar.msgqueue.queue.clear()
# msgnumafter = glovar.msgqueue.qsize()
# glovar.msgLock.release()
# logcontent = "message queue number:" + str(msgnum) + " message queue after number:" + str(msgnumafter)
# self.logger.info(logcontent)
# Send the last block
if len(glovar.BLOCKCHAIN):
newblock = glovar.BLOCKCHAIN[len(glovar.BLOCKCHAIN)-1]
beforesend = {'type':'syncblock','No':1,'content':newblock}
temp = str(beforesend)
hashvalue = hashlib.sha256(temp.encode('utf-8')).hexdigest()
senddata = {'messageid':hashvalue,'type':'syncblock','No':1,'content':newblock}
glovar.messageLock.acquire()
glovar.MessageList.append(newblock[1])
glovar.messageLock.release()
broadMessage(senddata)
logcontent = "Send a syncblock:" + str(newblock[8])
self.logger.info(logcontent)
time.sleep(RANBROAD_TIME)
cur_time = int(time.time())
prev_time = cur_time - (cur_time % CLEAR_TIME)
while True:
cur_time = int(time.time())
if cur_time > prev_time + CLEAR_TIME:
break
else:
time.sleep(0.5)
glovar.ComChange = 0
self.logger.info('--------------------------------------------------')
# Start committee formation
random.seed()
genrandom = random.uniform(0,1)
glovar.ranLock.acquire()
glovar.RanList.append(str(genrandom))
glovar.ranLock.release()
# self.logger.info('put random number to RanList.')
content = {'genrandom':genrandom}
beforesend = {'type':'comrandom','No':1,'content':content}
temp = str(beforesend)
hashvalue = hashlib.sha256(temp.encode('utf-8')).hexdigest()
senddata = {'messageid':hashvalue,'type':'comrandom','No':1,'content':content}
glovar.messageLock.acquire()
glovar.MessageList.append(hashvalue)
glovar.messageLock.release()
# glovar.broadLock.acquire()
# broadnum = glovar.broadqueue.qsize()
# glovar.broadqueue.queue.clear()
# broadnumafter = glovar.broadqueue.qsize()
# glovar.broadLock.release()
broadMessage(senddata)
logcontent = 'Send a random number: ' + str(genrandom)
self.logger.info(logcontent)
# Wait one or two RANBROAD_TIME duration for generating hashvalue
time.sleep(RANBROAD_TIME)
logcontent = 'Received random numbers: ' + str(len(glovar.RanList))
self.logger.info(logcontent)
# self.logger.info(glovar.RanList)
# self.logger.info('Generate hash value of random numbers.')
glovar.ranLock.acquire()
randomstring = "".join(glovar.RanList)
glovar.ranLock.release()
hashvalue = int(hashlib.sha256(randomstring.encode('utf-8')).hexdigest(), 16)
glovar.hashLock.acquire()
glovar.HashList.append(hashvalue)
if ( glovar.HashSeed == 0 or hashvalue < glovar.HashSeed ):
logcontent = "Replace HashSeed:\n" +str(glovar.HashSeed) + \
" with hashvalue:\n" + str(hashvalue)
self.logger.info(logcontent)
glovar.HashSeed = hashvalue
glovar.hashLock.release()
content = {'ranhash':hashvalue,'ranlist':glovar.RanList}
beforesend = {'type':'comrandom','No':2,'content':content}
temp = str(beforesend)
hashvalue = hashlib.sha256(temp.encode('utf-8')).hexdigest()
senddata = {'messageid':hashvalue,'type':'comrandom','No':2,'content':content}
glovar.messageLock.acquire()
glovar.MessageList.append(hashvalue)
glovar.messageLock.release()
broadMessage(senddata)
# Wait one or two RANBROAD_TIME duration for agree on the smallest hashvalue
time.sleep(RANBROAD_TIME)
logcontent = 'Received hashvalue list numbers: ' + str(len(glovar.HashList))
self.logger.info(logcontent)
# self.logger.info(glovar.HashList)
logcontent = 'The final HashSeed is:\n' + str(glovar.HashSeed)
self.logger.info(logcontent)
# Generate random number to choose members for each committee
nodenum = glovar.Firstcommem * glovar.Firstcomno + glovar.Secondcommem
comnum = glovar.Firstcomno + 1
random.seed(glovar.HashSeed)
for i in range(nodenum):
glovar.PosList.append(random.uniform(0,glovar.Stakesum))
logcontent = 'PosList:' + str(len(glovar.PosList)) + '\n' + str(glovar.PosList)
self.logger.info(logcontent)
# logcontent = 'NodeId: ' + str(glovar.NodeId)
# self.logger.info(logcontent)
# logcontent = 'Stakemin: ' + str(glovar.Stakemin)
# self.logger.info(logcontent)
# logcontent = 'Stakemax: ' + str(glovar.Stakemax)
# self.logger.info(logcontent)
# logcontent = 'Firstcommem: ' + str(glovar.Firstcommem)
# self.logger.info(logcontent)
# logcontent = 'Firstcomno: ' + str(glovar.Firstcomno)
# self.logger.info(logcontent)
# logcontent = 'Secondcommem: ' + str(glovar.Secondcommem)
# self.logger.info(logcontent)
# Inform other PoS node process to stop
# glovar.ComChange = 1
# notend = True
# while notend:
# notend = False
# for each in glovar.ComList:
# if each[6]:
# notend = True
# break
#
# time.sleep(0.05)
#
# glovar.ComList.clear()
# glovar.ComChange = 0
# Record the status of committee
for i in range (nodenum):
if (glovar.PosList[i] > glovar.Stakemin and glovar.PosList[i] <= glovar.Stakemax):
incomno = i // glovar.Firstcommem + 1
if (incomno < comnum):
commember = glovar.PosList[(incomno-1)*glovar.Firstcommem:incomno*glovar.Firstcommem]
else:
commember = glovar.PosList[(incomno-1)*glovar.Firstcommem:]
newblock = []
commitlist = []
commitblocklist = []
addfirstlist = []
transactionlist = []
secondcommitlist = []
newsecondblock = []
comstatus = {'genblock':0, 'blockhash':'0', 'stage':0, 'commit':0, 'commitlist':commitlist, \
'newblock':newblock, 'verify':0, 'commitblocklist':commitblocklist, \
'transactionlist':transactionlist, 'secondblockhash':'0', \
'secondcommit':0, 'secondcommitlist':secondcommitlist, \
'newsecondblock':newsecondblock, 'addfirstlist':addfirstlist}
comnodequeue = queue.Queue()
commemberLock = threading.Lock()
process = 1
cominfo = [incomno, glovar.PosList[i], commember, comstatus, comnodequeue, commemberLock, process]
glovar.ComList.append(cominfo)
self.logger.info('--------------------------------------------')
if len(glovar.ComList):
logcontent = 'Node is selected in committee:\n'
for each in glovar.ComList:
logcontent += str(each) + '\n'
self.logger.info(logcontent)
for each in glovar.ComList:
# Run the node in Firstcommittee
if each[0] <= glovar.Firstcomno:
block_generation = BlockProcessing(each, self.logdirectory)
block_generation.start()
else:
block_verify = VerifyProcessing(each, self.logdirectory)
block_verify.start()
# Clear global status
glovar.ranLock.acquire()
glovar.RanList.clear()
glovar.ranLock.release()
glovar.hashLock.acquire()
glovar.HashSeed = 0
glovar.HashList.clear()
glovar.hashLock.release()
glovar.PosList.clear()
