def test_init(self, sandbox: Sandbox): """Run a node and a baker. The node runs in archive mode to get metadata in `client.get_block()`. The protocol is activated in the past so the baker can submit blocks immediately without waiting for current time.""" node_params = constants.NODE_PARAMS + ['--history-mode', 'archive'] for i in range(NUM_NODES): sandbox.add_node(i, params=node_params) # client setup parameters = protocol.get_parameters() parameters['round_durations'] = ROUND_DURATIONS protocol.activate(sandbox.client(0), parameters=parameters) # baker setup # delegated_accounts = [f'bootstrap{i}' for i in range(1, 6)] for i in range(NUM_NODES): sandbox.add_baker( i, [f"bootstrap{i + 1}"], proto=protocol.DAEMON, log_levels=constants.TENDERBAKE_BAKER_LOG_LEVELS, )
def test_setup_network(self, sandbox: Sandbox): parameters = dict(protocol.PARAMETERS) # each priority has a delay of 1 sec parameters["time_between_blocks"] = ["1"] sandbox.add_node(0, params=constants.NODE_PARAMS) protocol.activate(sandbox.client(0), parameters) sandbox.add_baker(0, ['bootstrap1'], proto=protocol.DAEMON)
def test_init(self, sandbox: Sandbox): for i in range(10): sandbox.add_node(i, params=constants.NODE_PARAMS) utils.activate_alpha(sandbox.client(0)) for i in range(5): sandbox.add_baker(i, f'bootstrap{i + 1}', proto=constants.ALPHA_DAEMON)
def test_init(self, sandbox: Sandbox): sandbox.add_node(0, params=constants.NODE_PARAMS) parameters = dict(protocol.PARAMETERS) parameters["time_between_blocks"] = ["1", "0"] protocol.activate(sandbox.client(0), parameters) sandbox.add_baker(0, 'bootstrap1', proto=protocol.DAEMON) sandbox.add_node(1, params=constants.NODE_PARAMS) sandbox.add_baker(1, 'bootstrap2', proto=protocol.DAEMON)
def test_add_tmp_bootstrap_baker(self, sandbox: Sandbox): """ Launch a temporary baker so that 10 and 11 keep broadcasting heads to the future joining nodes and help them bootstrap """ # note we use 'bootstrap1' for all baking, this avoids the issue # of a delegate becoming inactive. For instance, if we want # to bake with 'bootstrap2' later in the test, it may have became # inactive sandbox.add_baker(10, 'bootstrap1', proto=PROTO_A_DAEMON)
def test_setup_network(self, sandbox: Sandbox): sandbox.add_node(0, params=constants.NODE_PARAMS) parameters = protocol.get_parameters() parameters['round_durations'] = { "round0": str(ROUND_DURATION), "round1": str(ROUND_DURATION), } protocol.activate(sandbox.client(0), parameters=parameters) sandbox.add_baker(0, ['bootstrap1'], proto=protocol.DAEMON)
def add_bakers(sandbox: Sandbox, nodes: Iterable[int]) -> None: for node_id in nodes: account = f'bootstrap{node_id + 1}' sandbox.add_baker( node_id, [account], proto=protocol.DAEMON, log_levels=constants.TENDERBAKE_BAKER_LOG_LEVELS, )
def test_network_gen_operations(self, sandbox: Sandbox, session): dead_baker = NUM_NODES - 1 cur_time = datetime.now() cycle = 1 while (datetime.now() - cur_time).total_seconds() < TEST_DURATION: i = random.randrange(NUM_NODES) client = sandbox.client(i) try: random_op(client) except subprocess.CalledProcessError: # some operations may be invalid, e.g. the client sends # several operation with the same counter print('# IGNORED INVALID OPERATION') # test chain progresses every X cycles if cycle % CHECK_PROGRESS == 0: client = sandbox.client(0) level_before = client.get_level() current_time = datetime.now().strftime("%H:%M:%S") print(current_time, "client level: ", level_before) retry = MAX_RETRY while client.get_level() == level_before and retry >= 1: if retry != MAX_RETRY: current_time = datetime.now().strftime("%H:%M:%S") print( current_time, "level did not increase, retries: ", retry, ) time.sleep(TIMEOUT) retry -= 1 msg = f"chain level didn't increase for {MAX_RETRY*TIMEOUT}s" assert retry, msg # cyclically kill bakers if cycle % KILL_BAKER == 0: baker = (dead_baker + 1) % NUM_NODES current_time = datetime.now().strftime("%H:%M:%S") print(current_time, "killing baker on node ", baker) sandbox.rm_baker(baker, proto=protocol.DAEMON) time.sleep(1) # wake up the dead baker current_time = datetime.now().strftime("%H:%M:%S") print(current_time, "starting baker on node ", dead_baker) sandbox.add_baker( dead_baker, [f'bootstrap{dead_baker+1}'], proto=protocol.DAEMON, log_levels=constants.TENDERBAKE_BAKER_LOG_LEVELS, ) # set the next baker to die dead_baker = baker time.sleep(TIME_BETWEEN_CYCLE) cycle += 1 session['dead_baker'] = dead_baker
def test_init(self, sandbox: Sandbox): sandbox.add_node(0, params=params(), log_levels=LOG_LEVEL) parameters = dict(protocol.PARAMETERS) parameters["time_between_blocks"] = ["1", "0"] protocol.activate(sandbox.client(0)) sandbox.add_baker(0, 'bootstrap1', proto=protocol.DAEMON) sandbox.add_node( 1, params=params(), log_levels=LOG_LEVEL, config_client=False )
def test_start_some_bakers(self, sandbox: Sandbox): for i in range(NUM_EARLY_START_NODES): account = f'bootstrap{i + 1}' sandbox.add_baker( i, [account], proto=protocol.DAEMON, log_levels=constants.TENDERBAKE_BAKER_LOG_LEVELS, )
def test_all_nodes_run_proto_b(self, sandbox: Sandbox): # we let a PROTO_A baker bake the last blocks of PROTO_A sandbox.add_baker(0, BAKER, proto=PROTO_A_DAEMON) clients = sandbox.all_clients() all_have_proto = False while not all_have_proto: all_have_proto = all(client.get_protocol() == PROTO_B for client in clients) time.sleep(POLLING_TIME)
def test_init(self, sandbox: Sandbox): sandbox.add_node(0, params=params(), log_levels=LOG_LEVEL) parameters = dict(constants.PARAMETERS) parameters["time_between_blocks"] = ["1", "0"] utils.activate_alpha(sandbox.client(0), parameters) sandbox.add_baker(0, 'bootstrap1', proto=constants.ALPHA_DAEMON) sandbox.add_node(1, params=params(), log_levels=LOG_LEVEL, config_client=False)
def test_add_bakers_and_endorsers(self, sandbox: Sandbox): for i in range(NUM_NODES): sandbox.add_baker(i, [f'bootstrap{i+1}'], proto=protocol.DAEMON) for i in range(NUM_NODES): sandbox.add_endorser( i, account=f'bootstrap{i+1}', endorsement_delay=0, proto=protocol.DAEMON, )
def test_setup_network(self, sandbox: Sandbox): parameters = protocol.get_parameters() # each priority has a delay of 1 sec # parameters["time_between_blocks"] = ["1"] for i in range(NUM_NODES): sandbox.add_node(i, params=constants.NODE_PARAMS) protocol.activate(sandbox.client(0), parameters=parameters) time.sleep(3) for i in range(NUM_NODES - 1): sandbox.add_baker(i, [f'bootstrap{5 - i}'], protocol.DAEMON)
def test_start_remaining_bakers(self, sandbox: Sandbox): for i in range(NUM_EARLY_START_NODES, NUM_NODES): account = f'bootstrap{i + 1}' sandbox.add_baker( i, [account], proto=protocol.DAEMON, log_levels=constants.TENDERBAKE_BAKER_LOG_LEVELS, ) time.sleep(ROUND_DURATION)
def test_init(self, sandbox: Sandbox): """Run a node and a baker. The node runs in archive mode to get metadata in `client.get_block()`. The protocol is activated in the past so the baker can submit blocks immediately without waiting for current time.""" node_params = constants.NODE_PARAMS + ['--history-mode', 'archive'] sandbox.add_node(0, params=node_params) protocol.activate(sandbox.client(0), activate_in_the_past=True) sandbox.add_baker(0, 'bootstrap1', proto=protocol.DAEMON)
def test_init(self, sandbox: Sandbox): sandbox.add_node(0, params=constants.NODE_PARAMS) parameters = dict(protocol.PARAMETERS) # smaller threshold to make (almost sure) that 3/5 of the delegates # have enough endorsing power parameters['consensus_threshold'] = 5 parameters['round_durations'] = {"round0": '3', "round1": '3'} protocol.activate(sandbox.client(0), parameters) for i in range(1, NEW_NODES): sandbox.add_node(i, params=constants.NODE_PARAMS) for i in range(3): sandbox.add_baker(i, [f'bootstrap{i + 1}'], proto=protocol.DAEMON)
def test_setup_network(self, sandbox: Sandbox): sandbox.add_node(0, params=params(), log_levels=LOG_LEVEL) protocol.activate(sandbox.client(0)) sandbox.add_node(1, params=params(), config_client=False, log_levels=LOG_LEVEL) sandbox.add_node(2, params=params(2), config_client=False, log_levels=LOG_LEVEL) sandbox.add_baker(0, 'bootstrap5', proto=protocol.DAEMON)
def test_setup_network(self, sandbox: Sandbox): sandbox.add_node(0, params=params(), log_levels=LOG_LEVEL) utils.activate_alpha(sandbox.client(0)) sandbox.add_node(1, params=params(), config_client=False, log_levels=LOG_LEVEL) sandbox.add_node(2, params=params(2), config_client=False, log_levels=LOG_LEVEL) sandbox.add_baker(0, 'bootstrap5', proto=constants.ALPHA_DAEMON)
def run_vote_file(sandbox: Sandbox, filename: str) -> None: sandbox.rm_baker(0, proto=protocol.DAEMON) sandbox.add_baker( 0, [f'bootstrap{i}' for i in range(1, 6)], proto=protocol.DAEMON, run_params=["--votefile", filename], ) if not sandbox.log_dir: pytest.skip() time.sleep(SLEEP) assert sandbox.logs
def test_setup_network(self, sandbox: Sandbox): parameters = dict(constants.PARAMETERS) # each priority has a delay of 1 sec parameters["time_between_blocks"] = ["1"] for i in range(NUM_NODES): sandbox.add_node(i, params=constants.NODE_PARAMS) utils.activate_alpha(sandbox.client(0), parameters) sandbox.add_baker(0, 'bootstrap5', proto=constants.ALPHA_DAEMON) sandbox.add_baker(1, 'bootstrap4', proto=constants.ALPHA_DAEMON) sandbox.add_endorser(0, account='bootstrap1', endorsement_delay=1, proto=constants.ALPHA_DAEMON) sandbox.add_endorser(1, account='bootstrap2', endorsement_delay=1, proto=constants.ALPHA_DAEMON)
def test_init(self, sandbox: Sandbox): for i in range(NUM_NODES): sandbox.add_node(i, params=constants.NODE_PARAMS) proto_params = dict(protocol.TENDERBAKE_PARAMETERS) parameters = copy.deepcopy(proto_params) parameters['round_durations'] = ROUND_DURATIONS parameters['consensus_threshold'] = ( 2 * (parameters['consensus_threshold'] // 3) + 1) protocol.activate(sandbox.client(0), parameters=parameters) for i in range(NUM_NODES): sandbox.add_baker( i, [f'bootstrap{i + 1}'], proto=protocol.DAEMON, log_levels=constants.TENDERBAKE_BAKER_LOG_LEVELS, )
def test_add_baker(self, sandbox: Sandbox): sandbox.add_baker(0, 'bootstrap1', proto=PROTO_A_DAEMON)
def test_start_proto_b_baker(self, sandbox: Sandbox): """Proto_B will be elected, launch a new Proto_B baker""" sandbox.add_baker(1, 'bootstrap1', proto=PROTO_B_DAEMON)
def test_start_baker_testchain(self, sandbox: Sandbox): sandbox.add_baker(3, 'bootstrap1', proto=PROTO_B_DAEMON, params=['--chain', 'test'])
def test_setup_network(self, sandbox: Sandbox): sandbox.add_node(0, params=params(0), log_levels=LOG_LEVEL) protocol.activate(sandbox.client(0)) time.sleep(3) sandbox.add_baker(0, ['bootstrap5'], proto=protocol.DAEMON)
def test_setup_network(self, sandbox: Sandbox): sandbox.add_node(0, params=params(), log_levels=LOG_LEVEL) sandbox.add_baker(0, ['bootstrap5'], proto=protocol.DAEMON)
def add_fully_delegated_baker(sandbox: Sandbox, node: int, protocol: str): """Add a baker that has all known bootstrap accounts delegated to it.""" sandbox.add_baker(node, [], proto=protocol)
def test_add_bakers(self, sandbox: Sandbox): for i in range(NUM_NODES): sandbox.add_baker(i, [f'bootstrap{i+1}'], proto=protocol.DAEMON)
def test_init(self, sandbox: Sandbox): for i in range(10): sandbox.add_node(i, params=constants.NODE_PARAMS) protocol.activate(sandbox.client(0)) for i in range(5): sandbox.add_baker(i, f'bootstrap{i + 1}', proto=protocol.DAEMON)