async def execute_test(node_builder=process_builder(ByzantineProcess), start_port=8900, tx_receiver_address_start_port=9100):
'''
Executes a test consisting of spawning some number of instances of the Process class, including instances that are
byzantine, generating some number of transactions and syncing all of the nodes until they reach some level of their posets.
:param node_builder: a factory method producing instances of the class Process
:param start_port: start of the port range used by created instances of the Process class for syncing
:param tx_receiver_address_start_port: start of the port range used by created Process instances for receiving transactions
'''
n_processes = 4
txps = 50
n_light_nodes = 100
consts.LEVEL_LIMIT = 10
host_ports = [start_port+i for i in range(n_processes)]
local_ip = socket.gethostbyname(socket.gethostname())
addresses = [(local_ip, port) for port in host_ports]
recv_addresses = [(local_ip, tx_receiver_address_start_port+i) for i in range(n_processes)]
signing_keys = [SigningKey() for _ in range(n_processes)]
public_keys = [VerifyKey.from_SigningKey(sk) for sk in signing_keys]
tasks = []
byzantine_tasks = []
initial_balances_and_indices = []
ln_signing_keys = [SigningKey() for _ in range(n_light_nodes)]
ln_public_keys = [VerifyKey.from_SigningKey(sk) for sk in ln_signing_keys]
for i in range(n_light_nodes):
initial_balances_and_indices.append((ln_public_keys[i].to_hex(),
random.randrange(10000, 100000),
-1))
userDB = UserDB(initial_balances_and_indices)
for process_id in range(n_processes):
sk = signing_keys[process_id]
pk = public_keys[process_id]
recv_address = recv_addresses[process_id]
new_process = node_builder(n_processes, process_id, sk, pk, addresses,
public_keys, recv_address, userDB,
gossip_strategy='unif_random')
if is_process_byzantine(new_process):
byzantine_tasks.append(asyncio.create_task(new_process.run()))
else:
tasks.append(asyncio.create_task(new_process.run()))
await asyncio.sleep(1)
p = multiprocessing.Process(target=tx_generator, args=(recv_addresses, ln_signing_keys, txps))
p.start()
await asyncio.gather(*tasks)
p.kill()
for byzantine_task in byzantine_tasks:
byzantine_task.cancel()
def generate_keys(n_processes):
''' Generate signing keys for the committee.'''
# if file exists check if it is of appropriate size
if os.path.exists('signing_keys'):
with open('signing_keys', 'r') as f:
if n_processes == sum(1 for line in f):
return
priv_keys = [SigningKey() for _ in range(n_processes)]
with open('signing_keys', 'w') as f:
for _ in range(n_processes):
f.write(SigningKey().to_hex().decode() + '\n')
async def run():
# arguments: private keys, public keys, our IP, IP range, whether to produce transactions (0 or 1)
import sys
assert (len(sys.argv) == 6)
priv_keys_file = sys.argv[1]
pub_keys_file = sys.argv[2]
our_ip = sys.argv[3]
ip_range = sys.argv[4]
generate_txs = int(sys.argv[5]) == 1
priv_keys = get_priv_keys(priv_keys_file)
all_pub_keys = get_pub_keys(pub_keys_file)
account_priv_keys = None
if generate_txs:
account_priv_keys = [SigningKey() for _ in range(100)]
discovery_server = make_discovery_server(priv_keys, account_priv_keys)
async def serve():
server = await asyncio.start_server(discovery_server, our_ip,
DISCOVERY_PORT)
async with server:
await server.serve_forever()
server_task = asyncio.create_task(serve())
client_map, database = await discover(all_pub_keys, ip_range)
await run_processes(client_map, priv_keys, database, account_priv_keys)
async def main():
n_processes = 20
consts.USE_TCOIN = 0
consts.UNITS_LIMIT = None
consts.LEVEL_LIMIT = 100
consts.N_PARENTS = n_processes
processes = []
host_ports = [8900 + i for i in range(n_processes)]
local_ip = socket.gethostbyname(socket.gethostname())
addresses = [(local_ip, port) for port in host_ports]
recv_addresses = [(local_ip, 9100 + i) for i in range(n_processes)]
signing_keys = [SigningKey() for _ in range(n_processes)]
public_keys = [VerifyKey.from_SigningKey(sk) for sk in signing_keys]
tasks = []
userDB = None
for process_id in range(n_processes):
sk = signing_keys[process_id]
pk = public_keys[process_id]
new_process = Process(
n_processes, process_id, sk, pk, addresses, public_keys, None,
userDB, tx_source_gen(batch_size=3, txpu=1, seed=process_id))
processes.append(new_process)
tasks.append(asyncio.create_task(new_process.run()))
await asyncio.gather(*tasks)
def generate_crp(n_processes):
'''
Generate the common random permutation to be used to initialize posets.
:returns: a CommonRandomPermutation object
'''
signing_keys = [SigningKey() for _ in range(n_processes)]
public_keys = [VerifyKey.from_SigningKey(sk) for sk in signing_keys]
return CommonRandomPermutation([pk.to_hex() for pk in public_keys])
def _read_signing_keys(signing_keys_path):
with open(signing_keys_path, 'r') as f:
hexes = [line[:-1].encode() for line in f]
return [SigningKey(hexed) for hexed in hexes]
parent_hashes = [V.hash() for V in U.parents]
parents = [hashes_to_units[V] for V in parent_hashes]
U_new = Unit(U.creator_id, parents, U.transactions(), U.signature,
U.coin_shares)
return U_new
n_processes = 16
n_units = 1000
use_tcoin = True
processes = []
host_ports = [8900 + i for i in range(n_processes)]
addresses = [('127.0.0.1', port) for port in host_ports]
recv_addresses = [('127.0.0.1', 9100 + i) for i in range(n_processes)]
signing_keys = [SigningKey() for _ in range(n_processes)]
public_keys = [VerifyKey.from_SigningKey(sk) for sk in signing_keys]
for process_id in range(n_processes):
sk = signing_keys[process_id]
pk = public_keys[process_id]
new_process = Process(n_processes, process_id, sk, pk, addresses,
public_keys, recv_addresses[process_id], None,
use_tcoin)
processes.append(new_process)
for unit_no in range(n_units):
while True:
creator_id = random.choice(range(n_processes))
process = processes[creator_id]
new_unit = create_unit(process.poset, creator_id, [])
def get_priv_keys(keyfile):
result = []
with open(keyfile, "r") as the_file:
for hexed in the_file.readlines():
result.append(SigningKey(hexed[:-1].encode('utf8')))
return result
def get_logs(n_processes, regions, n_parents, adaptive, create_delay,
sync_init_delay, txpu):
'''Retrieves all logs from instances.'''
if not os.path.exists('../results'):
os.makedirs('../results')
l = len(os.listdir('../results'))
if l:
color_print('sth is in dir ../results; aborting')
return
for rn in regions:
color_print(f'collecting logs in {rn}')
for ip in instances_ip_in_region(rn):
run_task_for_ip('get-logs', [ip], parallel=0)
if len(os.listdir('../results')) > l:
l = len(os.listdir('../results'))
break
color_print(f'{len(os.listdir("../results"))} files in ../results')
color_print('reading addresses')
with open('ip_addresses', 'r') as f:
ip_addresses = [line[:-1] for line in f]
color_print('reading signing keys')
with open('signing_keys', 'r') as f:
hexes = [line[:-1].encode() for line in f]
signing_keys = [SigningKey(hexed) for hexed in hexes]
pk_hexes = [VerifyKey.from_SigningKey(sk).to_hex() for sk in signing_keys]
arg_sort = [i for i, _ in sorted(enumerate(pk_hexes), key=lambda x: x[1])]
signing_keys = [signing_keys[i] for i in arg_sort]
ip_addresses = [ip_addresses[i] for i in arg_sort]
color_print('writing addresses')
with open('ip_addresses_sorted', 'w') as f:
for ip in ip_addresses:
f.write(ip + '\n')
color_print('writing signing keys')
with open('signing_keys_sorted', 'w') as f:
for sk in signing_keys:
f.write(sk.to_hex().decode() + '\n')
color_print('generating pid->region mapping')
with open('host_locations', 'w') as f:
for rn in regions:
f.write(rn + ' ')
for ip in instances_ip_in_region(rn):
f.write(str(ip_addresses.index(ip)) + ' ')
f.write('\n')
color_print('renaming logs')
for fp in os.listdir('../results'):
name = fp[-13:-8] # other | aleph
pid = ip_addresses.index(fp.split(f'-{name}.log')[0].replace('-', '.'))
os.rename(f'../results/{fp}', f'../results/{pid}.{name}.log.zip')
result_path = f'../{n_processes}_{n_parents}_{adaptive}_{create_delay}_{sync_init_delay}_{txpu}'
color_print('renaming dir')
os.rename('../results', result_path)
color_print('unzipping downloaded logs')
for path in os.listdir(result_path):
index = path.split('.')[0]
path = os.path.join(result_path, path)
with zipfile.ZipFile(path, 'r') as zf:
zf.extractall(result_path)
os.rename(f'{result_path}/aleph.log',
f'{result_path}/{index}.aleph.log')
os.remove(path)
color_print('zipping logs')
with zipfile.ZipFile(result_path + '.zip', 'w') as zf:
for path in os.listdir(result_path):
path = os.path.join(result_path, path)
zf.write(path)
os.remove(path)
color_print('removing empty dir')
os.rmdir(result_path)
color_print('getting dag')
run_task_for_ip('get-dag', [ip_addresses[0]])
color_print('done')
def save_keys(keys, filename):
with open(filename, "w") as the_file:
for key in keys:
the_file.write(key.decode('utf8') + "\n")
def save_priv_keys(priv_keys, i):
save_keys(priv_keys, "key" + str(i) + ".secret")
def save_pub_keys(pub_keys):
save_keys(pub_keys, "keys.public")
if __name__ == '__main__':
import sys
assert len(sys.argv) == 3
n_machines = int(sys.argv[1])
processes_per_machine = int(sys.argv[2])
pub_keys = []
for i in range(n_machines):
priv_keys = []
for _ in range(processes_per_machine):
priv_key = SigningKey()
pub_keys.append(VerifyKey.from_SigningKey(priv_key).to_hex())
priv_keys.append(priv_key.to_hex())
save_priv_keys(priv_keys, i)
save_pub_keys(pub_keys)