def run_command_check(options, **kwargs):
"""
Subcommand "crossbar check".
"""
from crossbar.common.checkconfig import check_config_file, color_json
configfile = os.path.join(options.cbdir, options.config)
print("\nChecking node configuration file '{}':\n".format(configfile))
color = color_json
with open(configfile, 'r') as f:
print(color(f.read().decode('utf8')))
old_dir = os.path.abspath(os.path.curdir)
os.chdir(options.cbdir)
try:
check_config_file(configfile)
except Exception as e:
print("\nError: {}\n".format(e))
sys.exit(1)
else:
print("Ok, node configuration looks good!\n")
sys.exit(0)
finally:
os.chdir(old_dir)
def run_command_check(options, **kwargs):
"""
Subcommand "crossbar check".
"""
from crossbar.common.checkconfig import check_config_file, color_json
configfile = os.path.join(options.cbdir, options.config)
print("\nChecking node configuration file '{}':\n".format(configfile))
color = color_json
with open(configfile, 'r') as f:
print(color(f.read().decode('utf8')))
old_dir = os.path.abspath(os.path.curdir)
os.chdir(options.cbdir)
try:
check_config_file(configfile)
except Exception as e:
print("\nError: {}\n".format(e))
sys.exit(1)
else:
print("Ok, node configuration looks good!\n")
sys.exit(0)
finally:
os.chdir(old_dir)
def run_command_check(options, **kwargs):
"""
Subcommand "crossbar check".
"""
from crossbar.common.checkconfig import check_config_file, color_json
configfile = os.path.join(options.cbdir, options.config)
print("\nChecking node configuration file '{}':\n".format(configfile))
if False:
with open(configfile, 'rb') as f:
print(color_json(f.read().decode('utf8')))
try:
config = check_config_file(configfile)
except Exception as e:
print("\nError: {}\n".format(e))
sys.exit(1)
else:
print("Ok, node configuration looks good!\n")
import json
config_content = json.dumps(
config,
skipkeys=False,
sort_keys=False,
ensure_ascii=False,
separators=(',', ': '),
indent=4,
)
print(color_json(config_content))
sys.exit(0)
def run_command_check(options, **kwargs):
"""
Subcommand "crossbar check".
"""
from crossbar.common.checkconfig import check_config_file, color_json
configfile = os.path.join(options.cbdir, options.config)
verbose = False
try:
print("Checking local node configuration file: {}".format(configfile))
config = check_config_file(configfile)
except Exception as e:
print("Error: {}".format(e))
sys.exit(1)
else:
print("Ok, node configuration looks good!")
if verbose:
import json
config_content = json.dumps(
config,
skipkeys=False,
sort_keys=False,
ensure_ascii=False,
separators=(',', ': '),
indent=4,
)
print(color_json(config_content))
sys.exit(0)
def load(self, configfile=None):
"""
Check and load the node configuration (usually, from ".crossbar/config.json")
or load built-in empty config.
"""
if configfile:
configpath = os.path.abspath(os.path.join(self._cbdir, configfile))
self.log.debug('Loading node configuration from "{configpath}" ..',
configpath=configpath)
# the following will read the config, check the config and replace
# environment variable references in configuration values ("${MYVAR}") and
# finally return the parsed configuration object
self._config = checkconfig.check_config_file(configpath, self._native_workers)
self.log.info('Node configuration loaded from "{configpath}"',
configpath=configpath)
else:
self._config = {
u'version': 2,
u'controller': {},
u'workers': []
}
checkconfig.check_config(self._config, self._native_workers)
self.log.info('Node configuration loaded from built-in config.')
def load(self, configfile=None):
"""
Check and load the node configuration (usually, from ".crossbar/config.json")
or load built-in CDC default config.
"""
if configfile:
configpath = os.path.join(self._cbdir, configfile)
self.log.debug("Loading node configuration from '{configpath}' ..",
configpath=configpath)
# the following will read the config, check the config and replace
# environment variable references in configuration values ("${MYVAR}") and
# finally return the parsed configuration object
self._config = checkconfig.check_config_file(configpath)
self.log.info("Node configuration loaded from '{configfile}'",
configfile=configfile)
else:
self._config = {
u"controller": {
u"cdc": {
u"enabled": True
}
}
}
checkconfig.check_config(self._config)
self.log.info("Node configuration loaded from built-in CDC config.")
def load(self, configfile=None):
"""
Check and load the node configuration (usually, from ".crossbar/config.json")
or load built-in CDC default config.
"""
if configfile:
configpath = os.path.join(self._cbdir, configfile)
self.log.debug("Loading node configuration from '{configpath}' ..",
configpath=configpath)
# the following will read the config, check the config and replace
# environment variable references in configuration values ("${MYVAR}") and
# finally return the parsed configuration object
self._config = checkconfig.check_config_file(configpath)
self.log.info("Node configuration loaded from '{configfile}'",
configfile=configfile)
else:
self._config = {
u"controller": {
u"cdc": {
u"enabled": True
}
}
}
checkconfig.check_config(self._config)
self.log.info("Node configuration loaded from built-in CDC config.")
def run_command_check(options, **kwargs):
"""
Subcommand "crossbar check".
"""
from crossbar.common.checkconfig import check_config_file, color_json
configfile = os.path.join(options.cbdir, options.config)
print("\nChecking node configuration file '{}':\n".format(configfile))
if False:
with open(configfile, 'rb') as f:
print(color_json(f.read().decode('utf8')))
try:
config = check_config_file(configfile)
except Exception as e:
print("\nError: {}\n".format(e))
sys.exit(1)
else:
print("Ok, node configuration looks good!\n")
import json
config_content = json.dumps(config, skipkeys=False, sort_keys=False, ensure_ascii=False, separators=(',', ': '), indent=3)
print(color_json(config_content))
sys.exit(0)
def run_command_check(options, **kwargs):
"""
Subcommand "crossbar check".
"""
from crossbar.controller.node import default_native_workers
configfile = os.path.join(options.cbdir, options.config)
verbose = False
try:
print("Checking local node configuration file: {}".format(configfile))
config = check_config_file(configfile, default_native_workers())
except Exception as e:
print("Error: {}".format(e))
sys.exit(1)
else:
print("Ok, node configuration looks good!")
if verbose:
config_content = json.dumps(
config,
skipkeys=False,
sort_keys=False,
ensure_ascii=False,
separators=(',', ': '),
indent=4,
)
print(color_json(config_content))
sys.exit(0)
def run_command_check(options):
"""
Subcommand "crossbar check".
"""
from crossbar.common.checkconfig import check_config_file
configfile = os.path.join(options.cbdir, options.config)
print("Checking local configuration file {}".format(configfile))
try:
check_config_file(configfile)
except Exception as e:
print("\nError: {}\n".format(e))
sys.exit(1)
else:
print("Ok, configuration file looks good.")
sys.exit(0)
def run_command_check(options):
"""
Subcommand "crossbar check".
"""
from crossbar.common.checkconfig import check_config_file
configfile = os.path.join(options.cbdir, options.config)
print("Checking local configuration file {}".format(configfile))
try:
check_config_file(configfile)
except Exception as e:
print("\nError: {}\n".format(e))
sys.exit(1)
else:
print("Ok, configuration file looks good.")
sys.exit(0)
def check_config(self):
"""
Check the configuration of this node.
"""
# for now, a node is always started from a local configuration
#
configfile = os.path.join(self.options.cbdir, self.options.config)
self.log.info("Loading node configuration file '{configfile}'",
configfile=configfile)
self._config = check_config_file(configfile, silence=True)
def check_config(self):
"""
Check the configuration of this node.
"""
# for now, a node is always started from a local configuration
#
configfile = os.path.join(self.options.cbdir, self.options.config)
self.log.info("Loading node configuration file '{configfile}'",
configfile=configfile)
self._config = check_config_file(configfile, silence=True)
def start(self):
"""
Starts this node. This will start a node controller and then spawn new worker
processes as needed.
"""
## for now, a node is always started from a local configuration
##
configfile = os.path.join(self.options.cbdir, self.options.config)
log.msg("Starting from local configuration '{}'".format(configfile))
config = checkconfig.check_config_file(configfile, silence = True)
self.start_from_config(config)
def start(self):
"""
Starts this node. This will start a node controller and then spawn new worker
processes as needed.
"""
# for now, a node is always started from a local configuration
#
configfile = os.path.join(self.options.cbdir, self.options.config)
log.msg("Starting from local configuration '{}'".format(configfile))
config = check_config_file(configfile, silence=True)
self.start_from_config(config)
def _start_from_local_config(self, configfile):
"""
Start Crossbar.io node from local configuration file.
"""
configfile = os.path.abspath(configfile)
log.msg("Starting from local config file '{}'".format(configfile))
try:
config = check_config_file(configfile, silence=True)
except Exception as e:
log.msg("Fatal: {}".format(e))
sys.exit(1)
else:
self.run_node_config(config)
def _start_from_local_config(self, configfile):
"""
Start Crossbar.io node from local configuration file.
"""
configfile = os.path.abspath(configfile)
log.msg("Starting from local config file '{}'".format(configfile))
try:
config = check_config_file(configfile, silence=True)
except Exception as e:
log.msg("Fatal: {}".format(e))
sys.exit(1)
else:
self.run_node_config(config)
def load(self, configfile=None):
"""
Check and load the node configuration (usually, from ".crossbar/config.json")
or load built-in empty config.
"""
if configfile:
configpath = os.path.abspath(os.path.join(self._cbdir, configfile))
self.log.debug('Loading node configuration from "{configpath}" ..',
configpath=configpath)
# the following will read the config, check the config and replace
# environment variable references in configuration values ("${MYVAR}") and
# finally return the parsed configuration object
self._config = checkconfig.check_config_file(configpath)
self.log.info('Node configuration loaded from "{configpath}"',
configpath=configpath)
else:
self._config = {u'version': 2, u'controller': {}, u'workers': []}
checkconfig.check_config(self._config)
self.log.info('Node configuration loaded from built-in config.')
def start(self):
"""
Starts this node. This will start a node controller and then spawn new worker
processes as needed.
"""
# for now, a node is always started from a local configuration
#
configfile = os.path.join(self.options.cbdir, self.options.config)
self.log.info("Starting from node configuration file '{configfile}'",
configfile=configfile)
self._config = check_config_file(configfile, silence=True)
controller_config = self._config.get('controller', {})
controller_options = controller_config.get('options', {})
controller_title = controller_options.get('title', 'crossbar-controller')
try:
import setproctitle
except ImportError:
self.log.warn("Warning, could not set process title (setproctitle not installed)")
else:
setproctitle.setproctitle(controller_title)
# the node's name (must be unique within the management realm)
if 'manager' in self._config:
self._node_id = self._config['manager']['id']
else:
if 'id' in controller_config:
self._node_id = controller_config['id']
else:
self._node_id = socket.gethostname()
if 'manager' in self._config:
extra = {
'onready': Deferred()
}
runner = ApplicationRunner(url=u"ws://localhost:9000", realm=u"cdc-oberstet-1", extra=extra)
runner.run(NodeManagementSession, start_reactor=False)
# wait until we have attached to the uplink CDC
self._management_session = yield extra['onready']
self.log.info("Connected to Crossbar.io Management Cloud: {management_session}",
management_session=self._management_session)
else:
self._management_session = None
# the node's management realm
self._realm = controller_config.get('realm', 'crossbar')
# router and factory that creates router sessions
#
self._router_factory = RouterFactory()
self._router_session_factory = RouterSessionFactory(self._router_factory)
rlm = RouterRealm(None, {'name': self._realm})
# create a new router for the realm
router = self._router_factory.start_realm(rlm)
# add a router/realm service session
cfg = ComponentConfig(self._realm)
rlm.session = RouterServiceSession(cfg, router)
self._router_session_factory.add(rlm.session, authrole=u'trusted')
if self._management_session:
self._bridge_session = NodeManagementBridgeSession(cfg, self._management_session)
self._router_session_factory.add(self._bridge_session, authrole=u'trusted')
else:
self._bridge_session = None
# the node controller singleton WAMP application session
#
# session_config = ComponentConfig(realm = options.realm, extra = options)
self._controller = NodeControllerSession(self)
# add the node controller singleton session to the router
#
self._router_session_factory.add(self._controller, authrole=u'trusted')
# Detect WAMPlets
#
wamplets = self._controller._get_wamplets()
if len(wamplets) > 0:
self.log.info("Detected {wamplets} WAMPlets in environment:",
wamplets=len(wamplets))
for wpl in wamplets:
self.log.info("WAMPlet {dist}.{name}",
dist=wpl['dist'], name=wpl['name'])
else:
self.log.info("No WAMPlets detected in enviroment.")
try:
if 'manager' in self._config:
yield self._startup_managed(self._config)
else:
yield self._startup_standalone(self._config)
except:
traceback.print_exc()
try:
self._reactor.stop()
except twisted.internet.error.ReactorNotRunning:
pass
def start(self):
"""
Starts this node. This will start a node controller and then spawn new worker
processes as needed.
"""
# for now, a node is always started from a local configuration
#
configfile = os.path.join(self.options.cbdir, self.options.config)
self.log.info("Starting from node configuration file '{configfile}'",
configfile=configfile)
self._config = check_config_file(configfile, silence=True)
controller_config = self._config.get('controller', {})
controller_options = controller_config.get('options', {})
controller_title = controller_options.get('title', 'crossbar-controller')
try:
import setproctitle
except ImportError:
self.log.warn("Warning, could not set process title (setproctitle not installed)")
else:
setproctitle.setproctitle(controller_title)
# the node's name (must be unique within the management realm)
if 'id' in controller_config:
self._node_id = controller_config['id']
else:
self._node_id = socket.gethostname()
if 'manager' in controller_config:
extra = {
'onready': Deferred()
}
realm = controller_config['manager']['realm']
transport = controller_config['manager']['transport']
runner = ApplicationRunner(url=transport['url'], realm=realm, extra=extra)
runner.run(NodeManagementSession, start_reactor=False)
# wait until we have attached to the uplink CDC
self._management_session = yield extra['onready']
self.log.info("Node is connected to Crossbar.io DevOps Center (CDC)")
else:
self._management_session = None
# the node's management realm
self._realm = controller_config.get('realm', 'crossbar')
# router and factory that creates router sessions
#
self._router_factory = RouterFactory()
self._router_session_factory = RouterSessionFactory(self._router_factory)
rlm = RouterRealm(None, {'name': self._realm})
# create a new router for the realm
router = self._router_factory.start_realm(rlm)
# add a router/realm service session
cfg = ComponentConfig(self._realm)
rlm.session = RouterServiceSession(cfg, router)
self._router_session_factory.add(rlm.session, authrole=u'trusted')
if self._management_session:
self._bridge_session = NodeManagementBridgeSession(cfg, self._management_session)
self._router_session_factory.add(self._bridge_session, authrole=u'trusted')
else:
self._bridge_session = None
# the node controller singleton WAMP application session
#
self._controller = NodeControllerSession(self)
# add the node controller singleton session to the router
#
self._router_session_factory.add(self._controller, authrole=u'trusted')
# Detect WAMPlets
#
wamplets = self._controller._get_wamplets()
if len(wamplets) > 0:
self.log.info("Detected {wamplets} WAMPlets in environment:",
wamplets=len(wamplets))
for wpl in wamplets:
self.log.info("WAMPlet {dist}.{name}",
dist=wpl['dist'], name=wpl['name'])
else:
self.log.info("No WAMPlets detected in enviroment.")
try:
yield self._startup(self._config)
except:
traceback.print_exc()
try:
self._reactor.stop()
except twisted.internet.error.ReactorNotRunning:
pass