示例#1
0
def api_sut(
        pathfinding_service_mock: PathfindingService,
        reachability_state: SimpleReachabilityContainer,
        free_port: int,
        populate_token_network_case_1,  # pylint: disable=unused-argument
) -> Iterator[PFSApi]:
    pathfinding_service_mock.matrix_listener.user_manager = reachability_state
    api = PFSApi(
        pathfinding_service=pathfinding_service_mock,
        one_to_n_address=Address(bytes([1] * 20)),
        operator="",
    )
    api.run(host=DEFAULT_API_HOST, port=free_port)
    yield api
    api.stop()
示例#2
0
def api_sut(
    pathfinding_service_mock: PathfindingService,
    reachability_state: SimpleReachabilityContainer,
    free_port: int,
    populate_token_network_case_1,  # pylint: disable=unused-argument
) -> Iterator[PFSApi]:
    pathfinding_service_mock.matrix_listener.user_manager = reachability_state
    pathfinding_service_mock.web3.eth.get_block = lambda x: Mock(
        timestamp=pathfinding_service_mock.blockchain_state.latest_committed_block * 15
        if x == "latest"
        else x * 15
    )
    api = PFSApi(
        pathfinding_service=pathfinding_service_mock,
        one_to_n_address=Address(bytes([1] * 20)),
        operator="",
    )
    api.run(host=DEFAULT_API_HOST, port=free_port)
    yield api
    api.stop()
示例#3
0
def main(  # pylint: disable=too-many-arguments,too-many-locals
    private_key: PrivateKey,
    state_db: str,
    web3: Web3,
    contracts: Dict[str, Contract],
    start_block: BlockNumber,
    confirmations: BlockTimeout,
    host: str,
    port: int,
    service_fee: TokenAmount,
    operator: str,
    info_message: str,
    enable_debug: bool,
    matrix_server: List[str],
    accept_disclaimer: bool,
    enable_tracing: bool,
    tracing_sampler: str,
    tracing_param: str,
) -> int:
    """The Pathfinding service for the Raiden Network."""
    log.info("Starting Raiden Pathfinding Service")
    click.secho(PFS_DISCLAIMER, fg="yellow")
    if not accept_disclaimer:
        click.confirm(CONFIRMATION_OF_UNDERSTANDING, abort=True)

    if not confirmations:
        chain_id = ChainID(web3.eth.chain_id)
        confirmations = (BlockTimeout(0) if "arbitrum" in ID_TO_CHAINNAME.get(
            chain_id, "") else DEFAULT_NUMBER_OF_BLOCK_CONFIRMATIONS)
        log.info("Setting number of confirmation blocks",
                 confirmations=confirmations)

    log.info("Using RPC endpoint", rpc_url=get_web3_provider_info(web3))
    hex_addresses = {
        name: to_checksum_address(contract.address)
        for name, contract in contracts.items()
    }
    log.info("Contract information",
             addresses=hex_addresses,
             start_block=start_block)

    if enable_tracing:
        tracing_config = Config(
            config={
                "sampler": {
                    "type": tracing_sampler,
                    "param": tracing_param
                },
                "logging": True
            },
            service_name="pfs",
            scope_manager=GeventScopeManager(),
            validate=True,
        )
        # Tracer is stored in `opentracing.tracer`
        tracing_config.initialize_tracer()

        assert isinstance(web3.provider, HTTPProvider), MYPY_ANNOTATION
        assert web3.provider.endpoint_uri is not None, MYPY_ANNOTATION
        # Set `Web3` requests Session to use `SessionTracing`
        cache_session(
            web3.provider.endpoint_uri,
            SessionTracing(propagate=False, span_tags={"target": "ethnode"}),
        )

    service = None
    api = None
    try:
        service = PathfindingService(
            web3=web3,
            contracts=contracts,
            sync_start_block=start_block,
            required_confirmations=confirmations,
            private_key=private_key,
            poll_interval=DEFAULT_POLL_INTERVALL,
            db_filename=state_db,
            matrix_servers=matrix_server,
            enable_tracing=enable_tracing,
        )
        service.start()
        log.debug("Waiting for service to start before accepting API requests")
        try:
            service.startup_finished.get(timeout=PFS_START_TIMEOUT)
        except gevent.Timeout:
            raise Exception("PFS did not start within time.")

        log.debug("Starting API")
        api = PFSApi(
            pathfinding_service=service,
            service_fee=service_fee,
            debug_mode=enable_debug,
            one_to_n_address=to_canonical_address(
                contracts[CONTRACT_ONE_TO_N].address),
            operator=operator,
            info_message=info_message,
            enable_tracing=enable_tracing,
        )
        api.run(host=host, port=port)

        service.get()
    except (KeyboardInterrupt, SystemExit):
        print("Exiting...")
    finally:
        log.info("Stopping Pathfinding Service...")
        if api:
            api.stop()
        if service:
            service.stop()

    return 0
示例#4
0
def main(  # pylint: disable=too-many-arguments,too-many-locals
    private_key: PrivateKey,
    state_db: str,
    web3: Web3,
    contracts: Dict[str, Contract],
    start_block: BlockNumber,
    confirmations: BlockTimeout,
    host: str,
    port: int,
    service_fee: TokenAmount,
    operator: str,
    info_message: str,
    enable_debug: bool,
    matrix_server: List[str],
    accept_disclaimer: bool,
) -> int:
    """The Pathfinding service for the Raiden Network."""
    log.info("Starting Raiden Pathfinding Service")
    click.secho(PFS_DISCLAIMER, fg="yellow")
    if not accept_disclaimer:
        click.confirm(CONFIRMATION_OF_UNDERSTANDING, abort=True)
    log.info("Using RPC endpoint", rpc_url=get_web3_provider_info(web3))
    hex_addresses = {
        name: to_checksum_address(contract.address)
        for name, contract in contracts.items()
    }
    log.info("Contract information",
             addresses=hex_addresses,
             start_block=start_block)

    service = None
    api = None
    try:
        service = PathfindingService(
            web3=web3,
            contracts=contracts,
            sync_start_block=start_block,
            required_confirmations=confirmations,
            private_key=private_key,
            poll_interval=DEFAULT_POLL_INTERVALL,
            db_filename=state_db,
            matrix_servers=matrix_server,
        )
        service.start()
        log.debug("Waiting for service to start before accepting API requests")
        try:
            service.startup_finished.get(timeout=PFS_START_TIMEOUT)
        except gevent.Timeout:
            raise Exception("PFS did not start within time.")

        log.debug("Starting API")
        api = PFSApi(
            pathfinding_service=service,
            service_fee=service_fee,
            debug_mode=enable_debug,
            one_to_n_address=to_canonical_address(
                contracts[CONTRACT_ONE_TO_N].address),
            operator=operator,
            info_message=info_message,
        )
        api.run(host=host, port=port)

        service.get()
    except (KeyboardInterrupt, SystemExit):
        print("Exiting...")
    finally:
        log.info("Stopping Pathfinding Service...")
        if api:
            api.stop()
        if service:
            service.stop()

    return 0