def toBeScheduled():
for i in iterList:
bc = bcList[i] # makeBroadcast(i)
sd = sdList[i]
recv = servers[0].get
th = Greenlet(honestParty, i, N, t, controlChannels[i], bc,
recv, sd, options.B)
th.parent_args = (N, t)
th.name = 'client_test_freenet.honestParty(%d)' % i
controlChannels[i].put(('IncludeTransaction', transactionSet))
th.start()
mylog('Summoned party %i at time %f' % (i, time.time()),
verboseLevel=-1)
ts.append(th)
try:
gevent.joinall(ts)
except ACSException:
gevent.killall(ts)
except finishTransactionLeap: ### Manually jump to this level
print 'msgCounter', msgCounter
print 'msgTypeCounter', msgTypeCounter
# message id 0 (duplicated) for signatureCost
logChannel.put(StopIteration)
mylog("=====", verboseLevel=-1)
for item in logChannel:
mylog(item, verboseLevel=-1)
mylog("=====", verboseLevel=-1)
except gevent.hub.LoopExit: # Manual fix for early stop
while True:
gevent.sleep(1)
checkExceptionPerGreenlet()
finally:
print "Consensus Finished"
def toBeScheduled():
for i in iterList:
bc = bcList[i] # makeBroadcast(i)
sd = sdList[i]
recv = servers[0].get
th = Greenlet(honestParty, i, N, t, controlChannels[i], bc, recv, sd, options.B)
th.parent_args = (N, t)
th.name = 'client_test_freenet.honestParty(%d)' % i
controlChannels[i].put(('IncludeTransaction',
transactionSet))
th.start()
mylog('Summoned party %i at time %f' % (i, time.time()), verboseLevel=-1)
ts.append(th)
try:
gevent.joinall(ts)
except ACSException:
gevent.killall(ts)
except finishTransactionLeap: ### Manually jump to this level
print 'msgCounter', msgCounter
print 'msgTypeCounter', msgTypeCounter
# message id 0 (duplicated) for signatureCost
logChannel.put(StopIteration)
mylog("=====", verboseLevel=-1)
for item in logChannel:
mylog(item, verboseLevel=-1)
mylog("=====", verboseLevel=-1)
except gevent.hub.LoopExit: # Manual fix for early stop
while True:
gevent.sleep(1)
checkExceptionPerGreenlet()
finally:
print "Consensus Finished"
def client_test_freenet(N, t, options):
'''
Test for the client with random delay channels
command list
i [target]: send a transaction to include for some particular party
h [target]: stop some particular party
m [target]: manually make particular party send some message
help: show the help screen
:param N: the number of parties
:param t: the number of malicious parties
:return None:
'''
initiateThresholdSig(open(options.threshold_keys, 'r').read())
initiateECDSAKeys(open(options.ecdsa, 'r').read())
initiateThresholdEnc(open(options.threshold_encs, 'r').read())
initializeGIPC(PK=getKeys()[0])
global logGreenlet
logGreenlet = Greenlet(logWriter, open('msglog.TorMultiple', 'w'))
logGreenlet.parent_args = (N, t)
logGreenlet.name = 'client_test_freenet.logWriter'
logGreenlet.start()
# query amazon meta-data
localIP = check_output(
['curl', 'http://169.254.169.254/latest/meta-data/public-ipv4'])
myID = IP_LIST.index(localIP)
N = len(IP_LIST)
initiateRND(options.tx)
def makeBroadcast(i):
chans = []
# First establish N connections (including a self connection)
for j in range(N):
host, port = IP_MAPPINGS[j] # TOR_MAPPINGS[j]
chans.append(connect_to_channel(host, port, i))
def _broadcast(v):
for j in range(N):
chans[j].put((j, i, v)) # from i to j
def _send(j, v):
chans[j].put((j, i, v))
return _broadcast, _send
iterList = [myID]
servers = []
for i in iterList:
_, port = IP_MAPPINGS[i]
servers.append(listen_to_channel(port))
print 'servers started'
gevent.sleep(WAITING_SETUP_TIME_IN_SEC) # wait for set-up to be ready
print 'sleep over'
if True: # We only test for once
initBeforeBinaryConsensus()
ts = []
controlChannels = [Queue() for _ in range(N)]
bcList = dict()
sdList = dict()
tList = []
def _makeBroadcast(x):
bc, sd = makeBroadcast(x)
bcList[x] = bc
sdList[x] = sd
for i in iterList:
tmp_t = Greenlet(_makeBroadcast, i)
tmp_t.parent_args = (N, t)
tmp_t.name = 'client_test_freenet._makeBroadcast(%d)' % i
tmp_t.start()
tList.append(tmp_t)
gevent.joinall(tList)
rnd = Random()
rnd.seed(123123)
# This makes sure that all the EC2 instances have the same transaction pool
transactionSet = set([
encodeTransaction(randomTransaction(rnd), randomGenerator=rnd)
for trC in range(int(options.tx))
]) # we are using the same one
def toBeScheduled():
for i in iterList:
bc = bcList[i] # makeBroadcast(i)
sd = sdList[i]
recv = servers[0].get
th = Greenlet(honestParty, i, N, t, controlChannels[i], bc,
recv, sd, options.B)
th.parent_args = (N, t)
th.name = 'client_test_freenet.honestParty(%d)' % i
controlChannels[i].put(('IncludeTransaction', transactionSet))
th.start()
mylog('Summoned party %i at time %f' % (i, time.time()),
verboseLevel=-1)
ts.append(th)
try:
gevent.joinall(ts)
except ACSException:
gevent.killall(ts)
except finishTransactionLeap: ### Manually jump to this level
print 'msgCounter', msgCounter
print 'msgTypeCounter', msgTypeCounter
# message id 0 (duplicated) for signatureCost
logChannel.put(StopIteration)
mylog("=====", verboseLevel=-1)
for item in logChannel:
mylog(item, verboseLevel=-1)
mylog("=====", verboseLevel=-1)
except gevent.hub.LoopExit: # Manual fix for early stop
while True:
gevent.sleep(1)
checkExceptionPerGreenlet()
finally:
print "Consensus Finished"
s = sched.scheduler(time.time, time.sleep)
time_now = time.time()
delay = options.delaytime - time_now
s.enter(delay, 1, toBeScheduled, ())
print myID, "waits for", time_now + delay, 'now is', time_now
s.run()
mylog('retrying (%s, %d) caused by %s...' %
(hostname, port, str(e)),
verboseLevel=-1)
q = Queue()
def _handle():
while True:
obj = q.get()
content = encode(obj)
try:
s.sendall(struct.pack('<I', len(content)) + content)
except SocketError:
print '!! [to %d] sending %d bytes' % (party, len(content))
gtemp = Greenlet(_handle)
gtemp.parent_args = (hostname, port, party)
gtemp.name = 'connect_to_channel._handle'
gtemp.start()
return q
BASE_PORT = 49500
def getAddrFromEC2Summary(s):
return [
x.split('ec2.')[-1]
for x in s.replace('.compute.amazonaws.com', '').replace(
'.us-west-1',
'' # Later we need to add more such lines
).replace('-', '.').strip().split('\n')
def client_test_freenet(N, t, options):
'''
Test for the client with random delay channels
command list
i [target]: send a transaction to include for some particular party
h [target]: stop some particular party
m [target]: manually make particular party send some message
help: show the help screen
:param N: the number of parties
:param t: the number of malicious parties
:return None:
'''
initiateThresholdSig(open(options.threshold_keys, 'r').read())
initiateECDSAKeys(open(options.ecdsa, 'r').read())
initiateThresholdEnc(open(options.threshold_encs, 'r').read())
initializeGIPC(PK=getKeys()[0])
global logGreenlet
logGreenlet = Greenlet(logWriter, open('msglog.TorMultiple', 'w'))
logGreenlet.parent_args = (N, t)
logGreenlet.name = 'client_test_freenet.logWriter'
logGreenlet.start()
# query amazon meta-data
localIP = check_output(['curl', 'http://169.254.169.254/latest/meta-data/public-ipv4'])
myID = IP_LIST.index(localIP)
N = len(IP_LIST)
initiateRND(options.tx)
def makeBroadcast(i):
chans = []
# First establish N connections (including a self connection)
for j in range(N):
host, port = IP_MAPPINGS[j] # TOR_MAPPINGS[j]
chans.append(connect_to_channel(host, port, i))
def _broadcast(v):
for j in range(N):
chans[j].put((j, i, v)) # from i to j
def _send(j, v):
chans[j].put((j, i, v))
return _broadcast, _send
iterList = [myID]
servers = []
for i in iterList:
_, port = IP_MAPPINGS[i]
servers.append(listen_to_channel(port))
print 'servers started'
gevent.sleep(WAITING_SETUP_TIME_IN_SEC) # wait for set-up to be ready
print 'sleep over'
if True: # We only test for once
initBeforeBinaryConsensus()
ts = []
controlChannels = [Queue() for _ in range(N)]
bcList = dict()
sdList = dict()
tList = []
def _makeBroadcast(x):
bc, sd = makeBroadcast(x)
bcList[x] = bc
sdList[x] = sd
for i in iterList:
tmp_t = Greenlet(_makeBroadcast, i)
tmp_t.parent_args = (N, t)
tmp_t.name = 'client_test_freenet._makeBroadcast(%d)' % i
tmp_t.start()
tList.append(tmp_t)
gevent.joinall(tList)
rnd = Random()
rnd.seed(123123)
# This makes sure that all the EC2 instances have the same transaction pool
transactionSet = set([encodeTransaction(randomTransaction(rnd), randomGenerator=rnd) for trC in range(int(options.tx))]) # we are using the same one
def toBeScheduled():
for i in iterList:
bc = bcList[i] # makeBroadcast(i)
sd = sdList[i]
recv = servers[0].get
th = Greenlet(honestParty, i, N, t, controlChannels[i], bc, recv, sd, options.B)
th.parent_args = (N, t)
th.name = 'client_test_freenet.honestParty(%d)' % i
controlChannels[i].put(('IncludeTransaction',
transactionSet))
th.start()
mylog('Summoned party %i at time %f' % (i, time.time()), verboseLevel=-1)
ts.append(th)
try:
gevent.joinall(ts)
except ACSException:
gevent.killall(ts)
except finishTransactionLeap: ### Manually jump to this level
print 'msgCounter', msgCounter
print 'msgTypeCounter', msgTypeCounter
# message id 0 (duplicated) for signatureCost
logChannel.put(StopIteration)
mylog("=====", verboseLevel=-1)
for item in logChannel:
mylog(item, verboseLevel=-1)
mylog("=====", verboseLevel=-1)
except gevent.hub.LoopExit: # Manual fix for early stop
while True:
gevent.sleep(1)
checkExceptionPerGreenlet()
finally:
print "Consensus Finished"
s = sched.scheduler(time.time, time.sleep)
time_now = time.time()
delay = options.delaytime - time_now
s.enter(delay, 1, toBeScheduled, ())
print myID, "waits for", time_now + delay, 'now is', time_now
s.run()
def client_test_freenet(N, t, options):
'''
Test for the client with random delay channels
command list
i [target]: send a transaction to include for some particular party
h [target]: stop some particular party
m [target]: manually make particular party send some message
help: show the help screen
:param N: the number of parties
:param t: the number of malicious parties
:return None:
'''
initTorConfiguration(options.hosts)
initiateThresholdSig(open(options.threshold_keys, 'r').read())
initiateECDSAKeys(open(options.ecdsa, 'r').read())
initiateThresholdEnc(open(options.threshold_encs, 'r').read())
initializeGIPC(getKeys()[0])
global logGreenlet
logGreenlet = Greenlet(logWriter, open('msglog.TorMultiple', 'w'))
logGreenlet.parent_args = (N, t)
logGreenlet.name = 'client_test_freenet.logWriter'
logGreenlet.start()
servers = []
for i in range(N):
_, port = TOR_MAPPINGS[i]
servers.append(listen_to_channel(port))
# Instantiate the "broadcast" instruction
def makeBroadcast(i):
chans = []
# First establish N connections (including a self connection)
for j in range(N):
host, port = TOR_MAPPINGS[j]
chans.append(connect_to_channel(host, port, i))
def _broadcast(v):
for j in range(N):
if j != i:
chans[j].put((j, i, v)) # from i to j
servers[i].put(
(i,
v)) # this is what the reader see. We are doing a shortcut.
def _delivery(j, v):
chans[j].put((j, i, v))
return _broadcast, _delivery
gevent.sleep(2)
print 'servers started'
# while True:
if True: # We only test for once
initBeforeBinaryConsensus()
ts = []
controlChannels = [Queue() for _ in range(N)]
bcList = dict()
sdList = dict()
tList = []
transactionSet = set([
encodeTransaction(randomTransaction())
for trC in range(int(options.tx))
]) # we are using the same one
def _makeBroadcast(x):
bc, sd = makeBroadcast(x)
bcList[x] = bc
sdList[x] = sd
for i in range(N):
tmp_t = Greenlet(_makeBroadcast, i)
tmp_t.parent_args = (N, t)
tmp_t.name = 'client_test_freenet._makeBroadcast(%d)' % i
tmp_t.start()
tList.append(tmp_t)
gevent.joinall(tList)
for i in range(N):
recv = servers[i].get
th = Greenlet(honestParty, i, N, t, controlChannels[i], bcList[i],
recv, sdList[i], options.B)
th.parent_args = (N, t)
th.name = 'client_test_freenet.honestParty(%d)' % i
th.start()
mylog('Summoned party %i at time %f' % (i, time.time()),
verboseLevel=-1)
ts.append(th)
for i in range(N):
controlChannels[i].put(('IncludeTransaction', transactionSet))
try:
gevent.joinall(ts)
except ACSException:
gevent.killall(ts)
except finishTransactionLeap: ### Manually jump to this level
print 'msgCounter', msgCounter
print 'msgTypeCounter', msgTypeCounter
# message id 0 (duplicated) for signatureCost
logChannel.put(StopIteration)
mylog("=====", verboseLevel=-1)
for item in logChannel:
mylog(item, verboseLevel=-1)
mylog("=====", verboseLevel=-1)
# checkExceptionPerGreenlet()
# print getSignatureCost()
pass
except gevent.hub.LoopExit: # Manual fix for early stop
while True:
gevent.sleep(1)
checkExceptionPerGreenlet()
finally:
print "Concensus Finished"
retry = True
gevent.sleep(1)
s.close()
mylog('retrying (%s, %d) caused by %s...' % (hostname, port, str(e)) , verboseLevel=-1)
q = Queue()
def _handle():
while True:
obj = q.get()
content = encode(obj)
try:
s.sendall(struct.pack('<I', len(content)) + content)
except SocketError:
print '!! [to %d] sending %d bytes' % (party, len(content))
gtemp = Greenlet(_handle)
gtemp.parent_args = (hostname, port, party)
gtemp.name = 'connect_to_channel._handle'
gtemp.start()
return q
BASE_PORT = 49500
def getAddrFromEC2Summary(s):
return [
x.split('ec2.')[-1] for x in s.replace(
'.compute.amazonaws.com', ''
).replace(
'.us-west-1', '' # Later we need to add more such lines
).replace(
'-', '.'
).strip().split('\n')]
def client_test_freenet(N, t, options):
'''
Test for the client with random delay channels
command list
i [target]: send a transaction to include for some particular party
h [target]: stop some particular party
m [target]: manually make particular party send some message
help: show the help screen
:param N: the number of parties
:param t: the number of malicious parties
:return None:
'''
maxdelay = 0.01
initiateThresholdSig(open(options.threshold_keys, 'r').read())
initiateECDSAKeys(open(options.ecdsa, 'r').read())
initiateThresholdEnc(open(options.threshold_encs, 'r').read())
initializeGIPC(getKeys()[0])
buffers = map(lambda _: Queue(1), range(N))
global logGreenlet
logGreenlet = Greenlet(logWriter, open('msglog.TorMultiple', 'w'))
logGreenlet.parent_args = (N, t)
logGreenlet.name = 'client_test_freenet.logWriter'
logGreenlet.start()
# Instantiate the "broadcast" instruction
def makeBroadcast(i):
def _broadcast(v):
def _deliver(j):
buffers[j].put(encode((j, i, v)))
for j in range(N):
Greenlet(_deliver, j).start()
return _broadcast
def recvWithDecode(buf):
def recv():
s = buf.get()
return decode(s)[1:]
return recv
def makeSend(i): # point to point message delivery
def _send(j, v):
buffers[j].put(encode((j, i, v)))
return _send
# while True:
#if True:
initBeforeBinaryConsensus()
ts = []
controlChannels = [Queue() for _ in range(N)]
# transactionSet = set([encodeTransaction(randomTransaction()) for trC in range(int(options.tx))]) # we are using the same one
transaction = Transaction()
transaction.envelope = receive_envelope()
for i in range(N):
bc = makeBroadcast(i)
recv = recvWithDecode(buffers[i])
th = Greenlet(honestParty, i, N, t, controlChannels[i], bc, recv,
makeSend(i), socket, options.B)
controlChannels[i].put(('IncludeTransaction', transaction))
th.start_later(random.random() * maxdelay)
ts.append(th)
while True:
transaction = Transaction()
transaction.envelope = receive_envelope()
for i in range(N):
controlChannels[i].put(('IncludeTransaction', transaction))
try:
gevent.joinall(ts)
except ACSException:
gevent.killall(ts)
except finishTransactionLeap: ### Manually jump to this level
print 'msgCounter', msgCounter
print 'msgTypeCounter', msgTypeCounter
# message id 0 (duplicated) for signatureCost
logChannel.put(StopIteration)
mylog("=====", verboseLevel=-1)
for item in logChannel:
mylog(item, verboseLevel=-1)
mylog("=====", verboseLevel=-1)
continue
except gevent.hub.LoopExit: # Manual fix for early stop
while True:
gevent.sleep(1)
checkExceptionPerGreenlet()
finally:
print "Concensus Finished"
def client_test_freenet(N, t, options):
'''
Test for the client with random delay channels
command list
i [target]: send a transaction to include for some particular party
h [target]: stop some particular party
m [target]: manually make particular party send some message
help: show the help screen
:param N: the number of parties
:param t: the number of malicious parties
:return None:
'''
initTorConfiguration(options.hosts)
initiateThresholdSig(open(options.threshold_keys, 'r').read())
initiateECDSAKeys(open(options.ecdsa, 'r').read())
initiateThresholdEnc(open(options.threshold_encs, 'r').read())
initializeGIPC(getKeys()[0])
global logGreenlet
logGreenlet = Greenlet(logWriter, open('msglog.TorMultiple', 'w'))
logGreenlet.parent_args = (N, t)
logGreenlet.name = 'client_test_freenet.logWriter'
logGreenlet.start()
servers = []
for i in range(N):
_, port = TOR_MAPPINGS[i]
servers.append(listen_to_channel(port))
# Instantiate the "broadcast" instruction
def makeBroadcast(i):
chans = []
# First establish N connections (including a self connection)
for j in range(N):
host, port = TOR_MAPPINGS[j]
chans.append(connect_to_channel(host, port, i))
def _broadcast(v):
for j in range(N):
if j != i:
chans[j].put((j, i, v)) # from i to j
servers[i].put((i, v)) # this is what the reader see. We are doing a shortcut.
def _delivery(j, v):
chans[j].put((j, i, v))
return _broadcast, _delivery
gevent.sleep(2)
print 'servers started'
# while True:
if True: # We only test for once
initBeforeBinaryConsensus()
ts = []
controlChannels = [Queue() for _ in range(N)]
bcList = dict()
sdList = dict()
tList = []
transactionSet = set([encodeTransaction(randomTransaction()) for trC in range(int(options.tx))]) # we are using the same one
def _makeBroadcast(x):
bc, sd = makeBroadcast(x)
bcList[x] = bc
sdList[x] = sd
for i in range(N):
tmp_t = Greenlet(_makeBroadcast, i)
tmp_t.parent_args = (N, t)
tmp_t.name = 'client_test_freenet._makeBroadcast(%d)' % i
tmp_t.start()
tList.append(tmp_t)
gevent.joinall(tList)
for i in range(N):
recv = servers[i].get
th = Greenlet(honestParty, i, N, t, controlChannels[i], bcList[i], recv, sdList[i], options.B)
th.parent_args = (N, t)
th.name = 'client_test_freenet.honestParty(%d)' % i
th.start()
mylog('Summoned party %i at time %f' % (i, time.time()), verboseLevel=-1)
ts.append(th)
for i in range(N):
controlChannels[i].put(('IncludeTransaction', transactionSet))
try:
gevent.joinall(ts)
except ACSException:
gevent.killall(ts)
except finishTransactionLeap: ### Manually jump to this level
print 'msgCounter', msgCounter
print 'msgTypeCounter', msgTypeCounter
# message id 0 (duplicated) for signatureCost
logChannel.put(StopIteration)
mylog("=====", verboseLevel=-1)
for item in logChannel:
mylog(item, verboseLevel=-1)
mylog("=====", verboseLevel=-1)
# checkExceptionPerGreenlet()
# print getSignatureCost()
pass
except gevent.hub.LoopExit: # Manual fix for early stop
while True:
gevent.sleep(1)
checkExceptionPerGreenlet()
finally:
print "Concensus Finished"
def client_test_freenet(N, t, options):
'''
Test for the client with random delay channels
command list
i [target]: send a transaction to include for some particular party
h [target]: stop some particular party
m [target]: manually make particular party send some message
help: show the help screen
:param N: the number of parties
:param t: the number of malicious parties
:return None:
'''
maxdelay = 0.01
initiateThresholdSig(open(options.threshold_keys, 'r').read())
initiateECDSAKeys(open(options.ecdsa, 'r').read())
initiateThresholdEnc(open(options.threshold_encs, 'r').read())
initializeGIPC(getKeys()[0])
buffers = map(lambda _: Queue(1), range(N))
global logGreenlet
logGreenlet = Greenlet(logWriter, open('msglog.TorMultiple', 'w'))
logGreenlet.parent_args = (N, t)
logGreenlet.name = 'client_test_freenet.logWriter'
logGreenlet.start()
# Instantiate the "broadcast" instruction
def makeBroadcast(i):
def _broadcast(v):
def _deliver(j):
buffers[j].put(encode((j, i, v)))
for j in range(N):
Greenlet(_deliver, j).start()
return _broadcast
def recvWithDecode(buf):
def recv():
s = buf.get()
return decode(s)[1:]
return recv
def makeSend(i): # point to point message delivery
def _send(j, v):
buffers[j].put(encode((j, i, v)))
return _send
while True:
#if True:
initBeforeBinaryConsensus()
ts = []
controlChannels = [Queue() for _ in range(N)]
transactionSet = set([encodeTransaction(randomTransaction()) for trC in range(int(options.tx))]) # we are using the same one
for i in range(N):
bc = makeBroadcast(i)
recv = recvWithDecode(buffers[i])
th = Greenlet(honestParty, i, N, t, controlChannels[i], bc, recv, makeSend(i), options.B)
controlChannels[i].put(('IncludeTransaction', transactionSet))
th.start_later(random.random() * maxdelay)
ts.append(th)
try:
gevent.joinall(ts)
except ACSException:
gevent.killall(ts)
except finishTransactionLeap: ### Manually jump to this level
print 'msgCounter', msgCounter
print 'msgTypeCounter', msgTypeCounter
# message id 0 (duplicated) for signatureCost
logChannel.put(StopIteration)
mylog("=====", verboseLevel=-1)
for item in logChannel:
mylog(item, verboseLevel=-1)
mylog("=====", verboseLevel=-1)
continue
except gevent.hub.LoopExit: # Manual fix for early stop
while True:
gevent.sleep(1)
checkExceptionPerGreenlet()
finally:
print "Concensus Finished"
def run_badger_node(myID, N, f, sPK, sSK, ePK, eSK, sendPath, receivePath):
'''
Test for the client with random delay channels
:param i: the current node index
:param N: the number of parties
:param t: the number of malicious parties toleranted
:return None:
'''
assert type(sPK) is boldyreva.TBLSPublicKey
assert type(sSK) is boldyreva.TBLSPrivateKey
assert type(ePK) is tpke.TPKEPublicKey
assert type(eSK) is tpke.TPKEPrivateKey
# Create the listening channel
recv_queue = listen_to_channel(BASE_PORT + myID)
recv = recv_queue.get
print 'server started'
# Create the sending channels
send_queues = []
for i in range(N):
port = BASE_PORT + i
send_queues.append(connect_to_channel('127.0.0.1', port, myID))
def send(j, obj):
send_queues[j].put(obj)
# Start the honeybadger instance
tx_submit = Queue()
def send_to_hyperledger(transactions):
global sendConnection
for tx in transactions:
if os.path.exists(sendPath):
if sendConnection is None:
print "Opening sending socket at path " + sendPath
sendConnection = socket.socket(socket.AF_UNIX,
socket.SOCK_STREAM)
sendConnection.connect(sendPath)
print "sending length " + str(len(tx))
sendConnection.send(struct.pack('!Q', len(tx)))
print "sending tx " + tx
sendConnection.send(tx)
hbbft = HoneyBadgerBFT("sid",
myID,
8,
N,
f,
sPK,
sSK,
ePK,
eSK,
send,
recv,
tx_submit.get,
send_to_hyperledger,
encode=repr,
decode=ast.literal_eval)
th = Greenlet(hbbft.run)
th.parent_args = (N, f)
th.name = __file__ + '.honestParty(%d)' % i
th.start()
if os.path.exists(receivePath):
os.remove(receivePath)
print "Opening listening socket at path " + receivePath
server = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
server.bind(receivePath)
# Listen for incoming connections
server.listen(1)
while True:
# Wait for a connection
connection, client_address = server.accept()
try:
while True:
message = connection.recv(8)
if message:
print "Message " + message
length, = struct.unpack('!Q', message)
print length
message = connection.recv(length)
print message
tx_submit.put([message])
else:
print >> sys.stderr, 'no more data from', client_address
break
finally:
# Clean up the connection
connection.close()
os.remove(receivePath)
th.join()
while True:
obj = q.get()
try:
content = encode((myID, obj))
except TypeError:
print obj
raise
try:
s.sendall(struct.pack('<I', len(content)) + content)
except SocketError:
print '!! [to %d] sending %d bytes' % (myID, len(content))
break
print 'closed channel'
gtemp = Greenlet(_run)
gtemp.parent_args = (hostname, port, myID)
gtemp.name = 'connect_to_channel._handle'
gtemp.start()
return q
def exception(msg):
print "Exception: %s" % msg
os.exit(1)
def encode(m):
return pickle.dumps(m)
def decode(s):
