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()