Function run_stress_test

tools/debugging/stress_test_transfers.py:539–606

(
    nursery: Nursery, running_nodes: List[RunningNode], config: StressTestConfiguration
)

def run_stress_test(
    nursery: Nursery, running_nodes: List[RunningNode], config: StressTestConfiguration
) -> None:
    identifier_generator = count(start=FIRST_VALID_PAYMENT_ID)
    profiler_processes: List[Popen] = []

    # TODO: Add tests with fees. This may require changes to the transfer plan,
    # since ATM it depends only in the `capacity_lower_bound` settings.
    for iteration in config.iteration_counter:
        log.info(f"Starting iteration {iteration}")

        # The configuration has to be re-created on every iteration because the
        # port numbers change
        plan = StressTestPlan(
            transfers=paths_for_mediated_transfers(running_nodes),
            concurrency=[50],
            planners=[do_fifty_transfer_up_to],
            schedulers=[scheduler_preserve_order],
        )

        # TODO: Before running the first plan each node should be queried for
        # their channel status. The script should assert the open channels have
        # at least `capacity_lower_bound` together.
        for concurent_paths, concurrency, transfer_planner, scheduler in zip(
            repeat(plan.transfers), plan.concurrency, plan.planners, plan.schedulers
        ):
            log.info(
                f"Starting run {concurent_paths}, {concurrency}, {transfer_planner}, {scheduler}"
            )

            # The plan MUST be executed successfully until exhaustion,
            # otherwise the next plan may try to use an amount that is not
            # available.
            transfer_plan = transfer_planner(config.capacity_lower_bound)
            transfers = list(scheduler(concurent_paths, transfer_plan))

            if config.profiler_data_directory:
                profiler_processes = run_profiler(
                    nursery, running_nodes, config.profiler_data_directory
                )

            wait_for_reachable(plan.transfers, config.token_address, config.retry_timeout)

            # TODO: `do_transfers` should return the amount of tokens
            # transferred with each `(from, to)` pair, and the total amount
            # must be lower than the `capacity_lower_bound`.
            do_transfers(
                transfers=transfers,
                token_address=config.token_address,
                identifier_generator=identifier_generator,
                pool_size=concurrency,
            )

            wait_for_balance(running_nodes)

            # After each `do_transfers` the state of the system must be
            # reset, otherwise there is a bug in the planner or Raiden.
            restarted_nodes = restart_network(