def __init__(self, config=None, reactor=None, personality=None):
# base ctor
WorkerController.__init__(self, config=config, reactor=reactor, personality=personality)
# factory for producing (per-realm) routers
self._router_factory = self.router_factory_class(None, self)
# factory for producing router sessions
self._router_session_factory = RouterSessionFactory(self._router_factory)
# map: realm ID -> RouterRealm
self.realms = {}
# map: realm URI -> realm ID
self.realm_to_id = {}
# map: component ID -> RouterComponent
self.components = {}
# "global" shared between all components
self.components_shared = {
u'reactor': reactor
}
# map: transport ID -> RouterTransport
self.transports = {}
def __init__(self, config=None, reactor=None, personality=None):
# base ctor
WorkerController.__init__(self,
config=config,
reactor=reactor,
personality=personality)
# factory for producing (per-realm) routers
self._router_factory = self.router_factory_class(None, self)
# factory for producing router sessions
self._router_session_factory = RouterSessionFactory(
self._router_factory)
# map: realm ID -> RouterRealm
self.realms = {}
# map: realm URI -> realm ID
self.realm_to_id = {}
# map: component ID -> RouterComponent
self.components = {}
# "global" shared between all components
self.components_shared = {u'reactor': reactor}
# map: transport ID -> RouterTransport
self.transports = {}
def __init__(self, config=None, reactor=None, personality=None):
# base ctor
WorkerController.__init__(self, config=config, reactor=reactor, personality=personality)
# map: component ID -> ContainerComponent
self.components = {}
# when shall we exit?
self._exit_mode = (config.extra.shutdown or self.SHUTDOWN_MANUAL)
# "global" shared between all components
self.components_shared = {
u'reactor': reactor
}
def __init__(self, config=None, reactor=None, personality=None):
# base ctor
WorkerController.__init__(self, config=config, reactor=reactor, personality=personality)
# map: component ID -> ContainerComponent
self.components = {}
# when shall we exit?
self._exit_mode = (config.extra.shutdown or self.SHUTDOWN_MANUAL)
# "global" shared between all components
self.components_shared = {
u'reactor': reactor
}
def __init__(self, config=None, reactor=None, personality=None):
# WorkerController derives of NativeProcess, which will set self._reactor
WorkerController.__init__(self, config=config, reactor=reactor, personality=personality)
worker_options_extra = dict(config.extra.extra)
self._database_config = worker_options_extra['database']
self._blockchain_config = worker_options_extra['blockchain']
self._ipfs_files_directory = worker_options_extra.get('ipfs_files_directory', './.ipfs_files')
# xbrmm worker status
self._status = None
# map of market makers by ID
self._makers = {}
self._maker_adr2id = {}
# open xbrmm worker database, containing a replicate of xbr on-chain data (other than
# channels, which are market specific and stored in the market maker database of the maker of that market)
self._dbpath = os.path.abspath(
self._database_config.get('dbpath', './.xbrmm-{}-db'.format(config.extra.worker)))
self._db = zlmdb.Database(dbpath=self._dbpath,
maxsize=self._database_config.get('maxsize', 2**30),
readonly=False,
sync=True)
self._db.__enter__()
# generic database object metadata
self._meta = cfxdb.meta.Schema.attach(self._db)
# xbr database schema
self._xbr = cfxdb.xbr.Schema.attach(self._db)
# xbr market maker schema
self._xbrmm = cfxdb.xbrmm.Schema.attach(self._db)
# event object too coordinate exit of blockchain monitor background check
self._run_monitor = None
# blockchain gateway configuration
self._bc_gw_config = self._blockchain_config['gateway']
self.log.info('Initializing Web3 from blockchain gateway configuration\n\n{gateway}\n',
gateway=pformat(self._bc_gw_config))
self._w3 = make_w3(self._bc_gw_config)
xbr.setProvider(self._w3)
self._chain_id = self._blockchain_config.get('chain_id', 1)
self.log.info('Using chain ID {chain_id}', chain_id=hlid(self._chain_id))
# To be initiated once cbdir variable gets available
self._ipfs_files_dir = os.path.join(config.extra.cbdir, self._ipfs_files_directory)
def onJoin(self, details):
"""
Called when worker process has joined the node's management realm.
"""
yield WorkerController.onJoin(self, details, publish_ready=False)
# WorkerController.publish_ready()
yield self.publish_ready()
def onJoin(self, details):
"""
Called when worker process has joined the node's management realm.
"""
yield WorkerController.onJoin(self, details, publish_ready=False)
# WorkerController.publish_ready()
yield self.publish_ready()
def onJoin(self, details):
"""
Called when worker process has joined the node's management realm.
"""
self.log.info('Container worker "{worker_id}" session {session_id} initializing ..', worker_id=self._worker_id, session_id=details.session)
yield WorkerController.onJoin(self, details, publish_ready=False)
self.log.info('Container worker "{worker_id}" session ready', worker_id=self._worker_id)
# WorkerController.publish_ready()
yield self.publish_ready()
def onJoin(self, details):
"""
Called when worker process has joined the node's management realm.
"""
self.log.info('Container worker "{worker_id}" session {session_id} initializing ..', worker_id=self._worker_id, session_id=details.session)
yield WorkerController.onJoin(self, details, publish_ready=False)
self.log.info('Container worker "{worker_id}" session ready', worker_id=self._worker_id)
# WorkerController.publish_ready()
yield self.publish_ready()
def onJoin(self, details, publish_ready=True):
"""
Called when worker process has joined the node's management realm.
"""
self.log.info('Router worker session for "{worker_id}" joined realm "{realm}" on node router {method}',
realm=self._realm,
worker_id=self._worker_id,
session_id=details.session,
method=hltype(RouterController.onJoin))
yield WorkerController.onJoin(self, details, publish_ready=False)
# WorkerController.publish_ready()
self.publish_ready()
self.log.info('Router worker session for "{worker_id}" ready',
worker_id=self._worker_id)
def onJoin(self, details, publish_ready=True):
"""
Called when worker process has joined the node's management realm.
"""
self.log.info('Router worker session for "{worker_id}" joined realm "{realm}" on node router {method}',
realm=self._realm,
worker_id=self._worker_id,
session_id=details.session,
method=hltype(RouterController.onJoin))
yield WorkerController.onJoin(self, details, publish_ready=False)
# WorkerController.publish_ready()
self.publish_ready()
self.log.info('Router worker session for "{worker_id}" ready',
worker_id=self._worker_id)
def onJoin(self, details):
self.log.info('HostMonitor connected (monitors available: {monitors})',
monitors=sorted(MONITORS.keys()))
yield WorkerController.onJoin(self, details, publish_ready=False)
# register monitor procedures
dl = []
for monitor in self._monitors.values():
d = self.register(monitor.get,
u'{}.get_{}'.format(self._prefix, monitor.ID))
dl.append(d)
res = yield DeferredList(dl, fireOnOneErrback=True)
print(res)
self.log.info('HostMonitor {pcnt} procedures registered',
pcnt=len(res))
# signal this worker is done with setup and ready
yield self.publish_ready()
def onJoin(self, details, publish_ready=True):
self.log.info(
'XBR Markets Worker starting (realm={realm}, prefix="{prefix}", session={session}, authid={authid}, authrole={authrole})',
realm=hlid(details.realm),
prefix=hlid(self._uri_prefix),
session=hlid(details.session),
authid=hlid(details.authid),
authrole=hlid(details.authrole))
self.log.info('XBR Markets Worker configuration:\n\n{config}', config=pformat(self.config.extra))
self._status = self.STATUS_STARTING
yield WorkerController.onJoin(self, details, publish_ready=False)
# any special session setup for the market maker goes here ..
# start blockchain monitor is running on a background thread which exits once this gets False
self._run_monitor = threading.Event()
self._stop_monitor = False
# FIXME: check self.xbr.blocks for latest block already processed
# initially begin scanning the blockchain with this block, and subsequently scan from the last
# processed and locally persisted block record in the database
if 'from_block' in self._blockchain_config:
scan_from_block = self._blockchain_config['from_block']
self.log.info('Initial scanning of blockchain beginning with block {scan_from_block} from configuration',
scan_from_block=scan_from_block)
else:
scan_from_block = 1
self.log.info('Initial scanning of blockchain from block 1 (!)')
# monitor/pull blockchain from a background thread
self._monitor_blockchain_thread = self._reactor.callInThread(self._monitor_blockchain, self._bc_gw_config,
scan_from_block)
self._status = self.STATUS_RUNNING
yield self.publish_ready()
self.log.info('XBR Markets Worker ready!')
def __init__(self, config=None, reactor=None, personality=None):
# base ctor
WorkerController.__init__(self, config=config, reactor=reactor, personality=personality)
def __init__(self, config=None, reactor=None, personality=None):
# base ctor
WorkerController.__init__(self,
config=config,
reactor=reactor,
personality=personality)
