def _start_rpc_server(self, host, port): from twisted.internet import reactor from golem.rpc.router import CrossbarRouter self.rpc_router = CrossbarRouter(host=host, port=port, datadir=self.client.datadir) reactor.addSystemEventTrigger("before", "shutdown", self.rpc_router.stop) self.rpc_router.start(reactor, self._router_ready, self._rpc_error)
def _start_router( self, *args, port=CROSSBAR_PORT, path=None, **kwargs, ): # noqa pylint: disable=arguments-differ self.state.subscribe = False path = path if path else self.path with mock.patch( "golem.rpc.cert.CertificateManager.get_secret", side_effect=lambda *_: "secret", ): self.state.router = CrossbarRouter(datadir=path, ssl=False, generate_secrets=False, port=port) # pylint: disable=attribute-defined-outside-init self.Session = Session tx_deferred = self.state.router.start(self.reactor_thread.reactor) tx_deferred.addErrback( # pylint: disable=no-member self.state.add_errors, ) yield tx_deferred try: yield self._start_backend_session() except Exception as e: # pylint: disable=broad-except self.state.add_errors(e)
def _start_rpc(self) -> Deferred: self.rpc_router = rpc = CrossbarRouter( host=self._config_desc.rpc_address, port=self._config_desc.rpc_port, datadir=self._datadir, ) self._reactor.addSystemEventTrigger("before", "shutdown", rpc.stop) deferred = rpc.start(self._reactor) return chain_function(deferred, self._start_session)
def setUp(self): super().setUp() self.cmanager = cert.CertificateManager( os.path.join(self.path, CROSSBAR_DIR)) self.state.router = CrossbarRouter( datadir=self.path, ssl=False, generate_secrets=True, )
def test_init(self): from os.path import join, exists crossbar_dir = join(self.path, 'definitely_not_exists') router = CrossbarRouter(datadir=crossbar_dir) assert exists(crossbar_dir) self.assertIsInstance(router, CrossbarRouter, "Something went really wrong...") self.assertEqual(router.working_dir, join(crossbar_dir, 'crossbar')) router = CrossbarRouter(datadir=self.path, crossbar_dir='crozzbar') self.assertEqual(router.working_dir, join(self.path, 'crozzbar')) self.assertIsNone(router.node) self.assertIsNone(router.pubkey) tmp_file = join(self.path, 'tmp_file') with open(tmp_file, 'w') as f: f.write('tmp data') with self.assertRaises(IOError): CrossbarRouter(crossbar_dir=tmp_file)
def test_init(self): from os.path import join, exists crossbar_dir = join(self.path, 'definitely_not_exists') router = CrossbarRouter(datadir=crossbar_dir, generate_secrets=True) assert exists(crossbar_dir) self.assertIsInstance(router, CrossbarRouter) self.assertEqual(router.working_dir, join(crossbar_dir, 'crossbar')) router = CrossbarRouter(datadir=join(self.path, "crozzbar"), generate_secrets=True) self.assertEqual(router.working_dir, join(self.path, 'crozzbar', CROSSBAR_DIR)) self.assertIsNone(router.node) self.assertIsNone(router.pubkey) tmp_file = join(self.path, 'tmp_file') with open(tmp_file, 'w') as f: f.write('tmp data') with self.assertRaises(IOError): CrossbarRouter(datadir=tmp_file)
def _start_router(self): # pylint: disable=arguments-differ # pylint: disable=no-member self.state.router = CrossbarRouter( datadir=self.path, ssl=False, generate_secrets=self.state.generate_secrets) # set a new role for admin self.state.router.config["workers"][0]["transports"][0]["auth"][ "anonymous"] = { # noqa pylint: disable=line-too-long "type": "static", "role": CrossbarRouter.CrossbarRoles.admin.name } self.state.router.config["workers"][0]["realms"][0]["roles"].append({ "name": 'anonymous', "permissions": [{ "uri": '*', "allow": { "call": True, "register": True, "publish": True, "subscribe": True } }] }) # These methods are for auth, which is not used in this test # and with them, crossbar doesn't work # pylint: disable=attribute-defined-outside-init self.Session = type("Session_no_auth", Session.__bases__, dict(Session.__dict__)) del self.Session.onChallenge del self.Session.onConnect tx_deferred = self.state.router.start(self.reactor_thread.reactor) tx_deferred.addErrback(self.state.add_errors) yield tx_deferred try: yield self._start_backend_session() except Exception as e: # pylint: disable=broad-except self.state.add_errors(e)
def _start_router(self): self.state.router = CrossbarRouter(datadir=self.path) self.state.router.start(self.state.reactor, self._start_backend_session, self.state.add_errors)
class Node(object): """ Simple Golem Node connecting console user interface with Client :type client golem.client.Client: """ def __init__(self, datadir=None, transaction_system=False, **config_overrides): self.default_environments = [] self.client = Client(datadir=datadir, transaction_system=transaction_system, **config_overrides) self.rpc_router = None self.rpc_session = None import logging self.logger = logging.getLogger("app") def initialize(self): self.load_environments(self.default_environments) self.client.sync() self.client.start() def load_environments(self, environments): for env in environments: env.accept_tasks = True self.client.environments_manager.add_environment(env) def connect_with_peers(self, peers): for peer in peers: self.client.connect(peer) def add_tasks(self, tasks): for task_def in tasks: task_builder = self._get_task_builder(task_def) golem_task = Task.build_task( task_builder(self.client.get_node_name(), task_def, self.client.datadir)) self.client.enqueue_new_task(golem_task) def run(self, use_rpc=False): try: from twisted.internet import reactor if use_rpc: config = self.client.config_desc reactor.callWhenRunning(self._start_rpc_server, config.rpc_address, int(config.rpc_port)) reactor.run() except Exception as ex: self.logger.error("Reactor error: {}".format(ex)) finally: self.client.quit() sys.exit(0) def _start_rpc_server(self, host, port): from twisted.internet import reactor from golem.rpc.router import CrossbarRouter self.rpc_router = CrossbarRouter(host=host, port=port, datadir=self.client.datadir) reactor.addSystemEventTrigger("before", "shutdown", self.rpc_router.stop) self.rpc_router.start(reactor, self._router_ready, self._rpc_error) def _router_ready(self, *_): methods = object_method_map(self.client, CORE_METHOD_MAP) self.rpc_session = Session(self.rpc_router.address, methods=methods) self.client.configure_rpc(self.rpc_session) self.rpc_session.connect().addErrback(self._rpc_error) def _rpc_error(self, err): self.logger.error("RPC error: {}".format(err)) def _get_task_builder(self, task_def): raise NotImplementedError
def start_client(start_ranking, datadir=None, transaction_system=False, client=None, reactor=None, **config_overrides): config_logging("client", datadir=datadir) logger = logging.getLogger("golem.client") install_unhandled_error_logger() if not reactor: from twisted.internet import reactor process_monitor = None from golem.core.processmonitor import ProcessMonitor from golem.docker.manager import DockerManager from golem.rpc.router import CrossbarRouter process_monitor = None if not client: client = Client(datadir=datadir, transaction_system=transaction_system, **config_overrides) docker_manager = DockerManager.install(client.config_desc) docker_manager.check_environment() environments = load_environments() client.sync() for env in environments: client.environments_manager.add_environment(env) client.environments_manager.load_config(client.datadir) config = client.config_desc methods = object_method_map(client, CORE_METHOD_MAP) router = CrossbarRouter( host=config.rpc_address, port=config.rpc_port, datadir=client.datadir ) session = Session(router.address, methods=methods) def router_ready(*_): session.connect().addCallbacks(session_ready, start_error) def session_ready(*_): global process_monitor logger.info('Router session ready. Starting client...') try: client.configure_rpc(session) logger.debug('client.start()') client.start() logger.debug('after client.start()') except SystemExit: raise except Exception as exc: logger.exception("Client process error: {}" .format(exc)) logger.info('Starting GUI process...') gui_process = start_gui(router.address) process_monitor = ProcessMonitor(gui_process) process_monitor.add_callbacks(stop_reactor) logger.info('Starting process monitor...') process_monitor.start() reactor.addSystemEventTrigger("before", "shutdown", router.stop) router.start(reactor, router_ready, start_error) if start_ranking: client.ranking.run(reactor) try: reactor.run() except ReactorAlreadyRunning: logger.debug("Client process: reactor is already running") if process_monitor: process_monitor.exit()