Пример #1
0
def create_app(settings_name: str, additional_handlers: list) -> Application:
    log.info("Starting web server")

    handlers = [
        url(r"/", IndexHandler, name="index"),
        url(r"/setup/(.*)", SetupHandler, name="setup"),
        url(r"/create_wallet", WalletCreationHandler, name="create_wallet"),
        url(r"/account/(.*)", AccountDetailHandler, name="account"),
        url(r"/keystore/(.*)/(.*)", KeystoreHandler, name="keystore"),
        url(r"/launch/(.*)", LaunchHandler, name="launch"),
        url(r"/gas_price/(.*)", GasPriceHandler, name="gas_price"),
        url(
            r"/api/configuration/(.*)",
            ConfigurationItemAPIHandler,
            name="api-configuration-detail",
        ),
    ]

    settings = load_settings(settings_name)

    return Application(handlers + additional_handlers,
                       debug=DEBUG,
                       static_path=os.path.join(RESOURCE_FOLDER_PATH,
                                                "static"),
                       template_path=os.path.join(RESOURCE_FOLDER_PATH,
                                                  "templates"),
                       installer_settings=settings)
Пример #2
0
 def _send_task_complete(self, message_text):
     self.write_message(
         json.dumps({
             "type": "task-complete",
             "text": message_text
         }))
     log.info(message_text)
Пример #3
0
    def wait_for_web_ui_ready(self, status_callback: Callable = None):
        """
        Params:
            status_callback:  A function, that will receive the /status API responses before the
                              status is `ready`.
        """
        if not self.is_running:
            raise RuntimeError("Raiden is not running")

        uri = urlparse(self.WEB_UI_INDEX_URL)

        while True:
            self._process_id = self.get_process_id()
            if not self.is_running or self.is_zombie:
                raise RaidenClientError(
                    "client process terminated while waiting for web ui")

            log.info("Waiting for raiden to start...")

            while not self.check_status_api(status_callback=status_callback):
                time.sleep(1)

            with closing(socket.socket(socket.AF_INET,
                                       socket.SOCK_STREAM)) as sock:
                try:
                    connected = sock.connect_ex((uri.hostname, uri.port)) == 0
                    if connected:
                        return
                except socket.gaierror:
                    pass
                time.sleep(1)
Пример #4
0
 def _send_status_update(self, message_text):
     self.write_message(
         json.dumps({
             "type": "status-update",
             "text": message_text
         }))
     log.info(message_text)
Пример #5
0
 def _send_redirect(self, redirect_url):
     self.write_message(
         json.dumps({
             "type": "redirect",
             "redirect_url": redirect_url
         }))
     log.info(f"Redirecting to {redirect_url}")
Пример #6
0
 def _send_status_update(self, message_text, icon=None):
     if not isinstance(message_text, list):
         message_text = [message_text]
     body = {"type": "status-update", "text": message_text}
     if icon:
         body["icon"] = icon
     self.write_message(json.dumps(body))
     log.info(" ".join(message_text))
Пример #7
0
 def kill(self):
     process = self._process_id and psutil.Process(self._process_id)
     if process is not None:
         log.info(f"Killing process {self._process_id}")
         process.kill()
         process.wait()
         self._process_id = self.get_process_id()
         assert self._process_id is None
Пример #8
0
 def _send_summary(self, text, **kw):
     if not isinstance(text, list):
         text = [text]
     message = {"type": "summary", "text": text}
     icon = kw.get("icon")
     if icon:
         message["icon"] = icon
     self.write_message(message)
     log.info(" ".join(text))
Пример #9
0
 def _send_next_step(self, message_text, title, step):
     if not isinstance(message_text, list):
         message_text = [message_text]
     body = {
         "type": "next-step",
         "text": message_text,
         "title": title,
         "step": step
     }
     self.write_message(json.dumps(body))
     log.info(" ".join(message_text))
     log.info(f"Update progress to step {step}: {title}")
Пример #10
0
def run_server(app: Application, port: int):  # pragma: no cover
    sockets = bind_sockets(port, "localhost")
    server = HTTPServer(app)
    server.add_sockets(sockets)

    _, socket_port = sockets[0].getsockname()
    local_url = f"http://localhost:{socket_port}"
    log.info(f"Installer page ready on {local_url}")

    if not DEBUG:
        log.info("Should open automatically in browser...")
        recover_ld_library_env_path()
        webbrowser.open_new(local_url)

    tornado.ioloop.IOLoop.current().start()
Пример #11
0
    def _run_launch(self, **kw):
        configuration_file_name = kw.get("configuration_file_name")
        configuration_file = RaidenConfigurationFile.get_by_filename(
            configuration_file_name)
        account = configuration_file.account
        try_unlock(account)
        if account.passphrase is None:
            self._send_error_message(
                "Failed to unlock account! Please reload page")
            return

        raiden_client = RaidenClient.get_client(self.installer_settings)
        if not raiden_client.is_installed:
            self._send_status_update(
                f"Downloading and installing raiden {raiden_client.release}")
            raiden_client.install()
            self._send_status_update("Installation complete")

        self._send_status_update(
            "Launching Raiden, this might take a couple of minutes, do not close the browser"
        )

        with temporary_passphrase_file(get_passphrase()) as passphrase_file:
            if not raiden_client.is_running:
                raiden_client.launch(configuration_file, passphrase_file)

            try:
                raiden_client.wait_for_web_ui_ready(
                    status_callback=lambda stat: log.info(str(stat)))
                self._send_task_complete("Raiden is ready!")
                self._send_redirect(RaidenClient.WEB_UI_INDEX_URL)
            except (RaidenClientError, RuntimeError) as exc:
                self._send_error_message(
                    f"Raiden process failed to start: {exc}")
                raiden_client.kill()
Пример #12
0
    def get(self, configuration_file_name):
        configuration_file = RaidenConfigurationFile.get_by_filename(
            configuration_file_name)
        keystore_path = configuration_file.configuration_data["keystore-path"]
        filename = ""
        for file in glob(f"{keystore_path}/UTC--*"):
            file_path = Path(file)
            if file_path.is_file():
                keystore_content = json.loads(file_path.read_text())
                if (to_checksum_address(keystore_content["address"]) ==
                        configuration_file.account.address):
                    filename = os.path.basename(file)
                    break

        w3 = make_web3_provider(
            configuration_file.ethereum_client_rpc_endpoint,
            configuration_file.account)
        required = RequiredAmounts.for_network(configuration_file.network.name)
        eth_balance = configuration_file.account.get_ethereum_balance(w3)
        log.info(f"Checking balance {eth_balance} > {required.eth}")
        if eth_balance < required.eth:
            log.info(
                f"funding tx {configuration_file._initial_funding_txhash}")
            if configuration_file._initial_funding_txhash is not None:
                return self.render(
                    "account.html",
                    configuration_file=configuration_file,
                    keystore=filename,
                )
        else:
            configuration_file._initial_funding_txhash = None
            configuration_file.save()

        if PASSPHRASE is not None:
            self.render("account.html",
                        configuration_file=configuration_file,
                        keystore=filename)
        else:
            self.render(
                "account_unlock.html",
                keystore_file_path=configuration_file.account.
                keystore_file_path,
                return_to=f"/account/{configuration_file_name}",
            )
Пример #13
0
    def _run_launch(self, **kw):
        configuration_file_name = kw.get("configuration_file_name")
        configuration_file = RaidenConfigurationFile.get_by_filename(
            configuration_file_name)
        network_name = configuration_file.network.name
        raiden_client = RaidenClient.get_client(network_name)
        required = RequiredAmounts.for_network(network_name)

        if not raiden_client.is_installed:
            self._send_status_update(
                f"Downloading and installing raiden {raiden_client.release}")
            raiden_client.install()
            self._send_status_update("Installation complete")

        account = configuration_file.account
        w3 = make_web3_provider(
            configuration_file.ethereum_client_rpc_endpoint, account)
        service_token = Erc20Token.find_by_ticker(
            required.service_token.ticker, network_name)

        service_token_balance = get_token_balance(w3=w3,
                                                  account=account,
                                                  token=service_token)
        service_token_in_deposit = get_token_deposit(w3=w3,
                                                     account=account,
                                                     token=service_token)
        if service_token_balance.as_wei and service_token_in_deposit < required.service_token:
            self._send_status_update(
                f"Making deposit of {service_token_balance.formatted} for Raiden Services"
            )
            deposit_service_tokens(w3=w3,
                                   account=account,
                                   token=service_token,
                                   amount=service_token_balance.as_wei)
            service_token_deposited = get_token_deposit(w3=w3,
                                                        account=account,
                                                        token=service_token)
            self._send_status_update(
                f"Amount deposited at UDC: {service_token_deposited.formatted}"
            )

        self._send_status_update(
            "Launching Raiden, this might take a couple of minutes, do not close the browser"
        )

        if not raiden_client.is_running:
            raiden_client.launch(configuration_file)

        try:
            raiden_client.wait_for_web_ui_ready(
                status_callback=lambda stat: log.info(str(stat)))
            self._send_task_complete("Raiden is ready!")
            self._send_redirect(raiden_client.WEB_UI_INDEX_URL)
        except (RaidenClientError, RuntimeError) as exc:
            self._send_error_message(f"Raiden process failed to start: {exc}")
            raiden_client.kill()
Пример #14
0
 def check_status_api(self, status_callback: Callable = None):
     """
     Params:
         status_callback:  A function, that will receive the /status API responses before the
                           status is `ready`.
     """
     log.info("Checking /status endpoint")
     try:
         response = requests.get(RaidenClient.WEB_UI_INDEX_URL +
                                 RaidenClient.RAIDEN_API_STATUS_ENDPOINT)
         if response and response.status_code == 200:
             result = response.json()
             if result.get("status") == "ready":
                 return True
             else:
                 if status_callback is not None:
                     status_callback(result)
     except ConnectionError:
         pass
     return False
Пример #15
0
    def get(self, configuration_file_name):
        configuration_file = RaidenConfigurationFile.get_by_filename(
            configuration_file_name)
        if get_passphrase() is None:
            self.render(
                "account_unlock.html",
                keystore_file_path=configuration_file.account.
                keystore_file_path,
                return_to=f"/account/{configuration_file_name}",
            )
            return

        keystore_path = configuration_file.configuration_data["keystore-path"]
        filename = ""
        for file in glob(f"{keystore_path}/UTC--*"):
            file_path = Path(file)
            if file_path.is_file():
                keystore_content = json.loads(file_path.read_text())
                if (to_canonical_address(keystore_content["address"]) ==
                        configuration_file.account.address):
                    filename = os.path.basename(file)
                    break

        w3 = make_web3_provider(
            configuration_file.ethereum_client_rpc_endpoint,
            configuration_file.account)
        required = RequiredAmounts.from_settings(self.installer_settings)
        eth_balance = configuration_file.account.get_ethereum_balance(w3)
        log.info(f"funding tx {configuration_file._initial_funding_txhash}")
        log.info(f"Checking balance {eth_balance} >= {required.eth}")
        if eth_balance >= required.eth:
            configuration_file._initial_funding_txhash = None
            configuration_file.save()

        self.render(
            "account.html",
            configuration_file=configuration_file,
            keystore=filename,
            ramp_api_key=RAMP_API_KEY,
        )
Пример #16
0
    def wait_for_web_ui_ready(self):
        if not self.is_running:
            raise RuntimeError("Raiden is not running")

        uri = urlparse(self.WEB_UI_INDEX_URL)

        while True:
            self._process_id = self.get_process_id()
            if not self.is_running or self.is_zombie:
                raise RaidenClientError(
                    "client process terminated while waiting for web ui")

            with closing(socket.socket(socket.AF_INET,
                                       socket.SOCK_STREAM)) as sock:
                log.info("Waiting for raiden to start...")
                try:
                    connected = sock.connect_ex((uri.hostname, uri.port)) == 0
                    if connected:
                        return
                except socket.gaierror:
                    pass
                time.sleep(1)
Пример #17
0
    def _run_launch(self, **kw):
        configuration_file_name = kw.get("configuration_file_name")
        configuration_file = RaidenConfigurationFile.get_by_filename(
            configuration_file_name)
        network_name = configuration_file.network.name
        raiden_client = RaidenClient.get_client(network_name)

        if not raiden_client.is_installed:
            self._send_status_update(
                f"Downloading and installing raiden {raiden_client.release}")
            raiden_client.install()
            self._send_status_update("Installation complete")

        account = configuration_file.account
        try_unlock(account)
        if account.passphrase is None:
            return self.render(
                "account_unlock.html",
                keystore_file_path=account.keystore_file_path,
                return_to=f"/launch/{configuration_file_name}",
            )

        self._send_status_update(
            "Launching Raiden, this might take a couple of minutes, do not close the browser"
        )

        with temporary_passphrase_file(PASSPHRASE) as passphrase_file:
            if not raiden_client.is_running:
                raiden_client.launch(configuration_file, passphrase_file)

            try:
                raiden_client.wait_for_web_ui_ready(
                    status_callback=lambda stat: log.info(str(stat)))
                self._send_task_complete("Raiden is ready!")
                self._send_redirect(raiden_client.WEB_UI_INDEX_URL)
            except (RaidenClientError, RuntimeError) as exc:
                self._send_error_message(
                    f"Raiden process failed to start: {exc}")
                raiden_client.kill()
Пример #18
0
 def _send_txhash_message(self, text, tx_hash):
     if not isinstance(text, list):
         text = [text]
     message = {"type": "hash", "text": text, "tx_hash": tx_hash}
     self.write_message(message)
     log.info(f"{''.join(text)} {tx_hash}")
Пример #19
0
 def _send_txhash_message(self, text, tx_hash):
     if not isinstance(text, list):
         text = [text]
     message = {"type": "hash", "text": text, "tx_hash": tx_hash}
     self.write_message(message)
     log.info(f"Waiting for confirmation of txhash {tx_hash}")
Пример #20
0
        token_amount = TokenAmount(ex_currency_amt["target_amount"], currency)
        exchange_costs = exchange.calculate_transaction_costs(
            token_amount, account)
        total_cost = exchange_costs["total"]
        self.render_json({
            "exchange": exchange.name,
            "currency": currency.ticker,
            "target_amount": ex_currency_amt["target_amount"],
            "as_wei": total_cost.as_wei,
            "formatted": total_cost.formatted,
            "utc_seconds": int(time.time()),
        })


if __name__ == "__main__":
    log.info("Starting web server")
    app = Application(
        [
            url(r"/", IndexHandler, name="index"),
            url(r"/configurations",
                ConfigurationListHandler,
                name="configuration-list"),
            url(r"/setup/(mainnet|goerli)/(.*)", SetupHandler, name="setup"),
            url(r"/create_wallet/(mainnet|goerli)",
                WalletCreationHandler,
                name="create_wallet"),
            url(r"/account/(.*)", AccountDetailHandler, name="account"),
            url(r"/keystore/(.*)/(.*)", KeystoreHandler, name="keystore"),
            url(r"/launch/(.*)", LaunchHandler, name="launch"),
            url(r"/swap/(.*)/([A-Z]{3})", SwapHandler, name="swap"),
            url(r"/ws", AsyncTaskHandler, name="websocket"),
Пример #21
0
 def make_by_tag(cls, release_tag):
     log.info("Getting list of all nightly releases")
     return {r.release: r
             for r in cls.get_available_releases()}.get(release_tag)
Пример #22
0
 def _send_txhash_message(self, text, tx_hash):
     message = {"type": "hash", "text": text, "tx_hash": tx_hash}
     self.write_message(message)
     log.info(f"Waiting for confirmation of txhash {tx_hash}")