def start_from_config(self, config): controller_config = config.get('controller', {}) controller_options = controller_config.get('options', {}) controller_title = controller_options.get('title', 'crossbar-controller') try: import setproctitle except ImportError: log.msg( "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() ## the node's management realm self._realm = controller_config.get('realm', 'crossbar') ## the node controller singleton WAMP application session ## #session_config = ComponentConfig(realm = options.realm, extra = options) self._controller = NodeControllerSession(self) ## router and factory that creates router sessions ## self._router_factory = RouterFactory(options=wamp.types.RouterOptions( uri_check=wamp.types.RouterOptions.URI_CHECK_LOOSE), debug=False) self._router_session_factory = RouterSessionFactory( self._router_factory) ## add the node controller singleton session to the router ## self._router_session_factory.add(self._controller) ## Detect WAMPlets ## wamplets = self._controller._get_wamplets() if len(wamplets) > 0: log.msg("Detected {} WAMPlets in environment:".format( len(wamplets))) for wpl in wamplets: log.msg("WAMPlet {}.{}".format(wpl['dist'], wpl['name'])) else: log.msg("No WAMPlets detected in enviroment.") self.run_node_config(config)
def setUp(self): """ Setup router and router session factories. """ if USE_ASYNCIO: self.loop = asyncio.new_event_loop() asyncio.set_event_loop(self.loop) self.router_factory = RouterFactory() self.session_factory = RouterSessionFactory(self.router_factory)
class WampServer: def __init__(self, debug = '0'): self.debug = debug log.startLogging(sys.stdout) ## we use an Autobahn utility to install the "best" available Twisted reactor ## from autobahn.twisted.choosereactor import install_reactor self.reactor = install_reactor() print("Running on reactor {}".format(self.reactor)) ## create a WAMP router factory ## from autobahn.twisted.wamp import RouterFactory self.router_factory = RouterFactory() ## create a WAMP router session factory ## from autobahn.twisted.wamp import RouterSessionFactory self.session_factory = RouterSessionFactory(self.router_factory) ## Add embedded WAMP application sessions to the router ## from core.rpc import MyBackendComponent component_config = types.ComponentConfig(realm = "realm1") component_session = MyBackendComponent(component_config) self.session_factory.add(component_session) ## create a WAMP-over-WebSocket transport server factory ## from autobahn.twisted.websocket import WampWebSocketServerFactory self.transport_factory = WampWebSocketServerFactory(self.session_factory, debug = self.debug) self.transport_factory.setProtocolOptions(failByDrop = False) def run(self, config): ## start the server from an endpoint ## enpoint = 'tcp:' + config.PORT print enpoint self.server = serverFromString(self.reactor, enpoint) self.server.listen(self.transport_factory) ## now enter the Twisted reactor loop ## self.reactor.run()
def start(self): """ Starts this node. This will start a node controller and then spawn new worker processes as needed. The node controller will watch spawned processes, communicate via stdio with the worker, and start and restart the worker processes as needed. """ ## the node controller singleton WAMP application session ## self._node_controller_session = NodeControllerSession(self) ## router and factory that creates router sessions ## self._router_factory = RouterFactory() self._router_session_factory = RouterSessionFactory(self._router_factory) ## add the node controller singleton session to the router ## self._router_session_factory.add(self._node_controller_session) if True: ## create a WAMP-over-WebSocket transport server factory ## from autobahn.twisted.websocket import WampWebSocketServerFactory from twisted.internet.endpoints import serverFromString self._router_server_transport_factory = WampWebSocketServerFactory(self._router_session_factory, "ws://localhost:9000", debug = False) self._router_server_transport_factory.setProtocolOptions(failByDrop = False) ## start the WebSocket server from an endpoint ## self._router_server = serverFromString(self._reactor, "tcp:9000") self._router_server.listen(self._router_server_transport_factory) ## factory that creates router session transports. these are for clients ## that talk WAMP-WebSocket over pipes with spawned worker processes and ## for any uplink session to a management service ## self._router_client_transport_factory = WampWebSocketClientFactory(self._router_session_factory, "ws://localhost", debug = False) self._router_client_transport_factory.setProtocolOptions(failByDrop = False) if False: management_session_factory = ApplicationSessionFactory() management_session_factory.session = NodeManagementSession management_session_factory.node_controller_session = node_controller_session management_transport_factory = WampWebSocketClientFactory(management_session_factory, "ws://127.0.0.1:7000") management_transport_factory.setProtocolOptions(failByDrop = False) management_client = clientFromString(self._reactor, "tcp:127.0.0.1:7000") management_client.connect(management_transport_factory) ## startup the node from configuration file ## self._node_controller_session.run_node_config(self._config)
def start_from_config(self, config): controller_config = config.get('controller', {}) controller_options = controller_config.get('options', {}) controller_title = controller_options.get('title', 'crossbar-controller') try: import setproctitle except ImportError: log.msg("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() ## the node's management realm self._realm = controller_config.get('realm', 'crossbar') ## the node controller singleton WAMP application session ## #session_config = ComponentConfig(realm = options.realm, extra = options) self._controller = NodeControllerSession(self) ## router and factory that creates router sessions ## self._router_factory = RouterFactory( options = wamp.types.RouterOptions(uri_check = wamp.types.RouterOptions.URI_CHECK_LOOSE), debug = False) self._router_session_factory = RouterSessionFactory(self._router_factory) ## add the node controller singleton session to the router ## self._router_session_factory.add(self._controller) ## Detect WAMPlets ## wamplets = self._controller._get_wamplets() if len(wamplets) > 0: log.msg("Detected {} WAMPlets in environment:".format(len(wamplets))) for wpl in wamplets: log.msg("WAMPlet {}.{}".format(wpl['dist'], wpl['name'])) else: log.msg("No WAMPlets detected in enviroment.") self.run_node_config(config)
def start(self): """ Starts this node. This will start a node controller and then spawn new worker processes as needed. The node controller will watch spawned processes, communicate via stdio with the worker, and start and restart the worker processes as needed. """ try: import setproctitle except ImportError: log.msg("Warning, could not set process title (setproctitle not installed)") else: setproctitle.setproctitle("Crossbar.io Node Controller") ## the node controller singleton WAMP application session ## self._node_controller_session = NodeControllerSession(self) ## router and factory that creates router sessions ## self._router_factory = RouterFactory( options = types.RouterOptions(uri_check = types.RouterOptions.URI_CHECK_LOOSE), debug = False) self._router_session_factory = RouterSessionFactory(self._router_factory) ## add the node controller singleton session to the router ## self._router_session_factory.add(self._node_controller_session) ## Detect WAMPlets ## for wpl in self._node_controller_session.list_wamplets(): log.msg("WAMPlet detected: {}.{}".format(wpl['dist'], wpl['name'])) yield self.start_from_local_config(configfile = os.path.join(self._cbdir, 'config.json')) self.start_local_management_transport(endpoint_descriptor = "tcp:9000")
def wampServ(wampAddress, wampPort, wampDebug = False): """ Sets up an Autobahn|Python WAMPv2 server. Code modified from WAMP documentation. """ from twisted.internet.endpoints import serverFromString from autobahn.wamp.router import RouterFactory from autobahn.twisted.wamp import RouterSessionFactory from autobahn.twisted.websocket import WampWebSocketServerFactory ## create a WAMP router factory router_factory = RouterFactory() ## create a WAMP router session factory session_factory = RouterSessionFactory(router_factory) ## create a WAMP-over-WebSocket transport server factory transport_factory = WampWebSocketServerFactory(session_factory, wampAddress, debug = wampDebug) transport_factory.setProtocolOptions(failByDrop = False) ## Start websocket server server = serverFromString(reactor, wampPort) server.listen(transport_factory)
counter += 1 yield sleep(1) if __name__ == '__main__': ## 0) start logging to console log.startLogging(sys.stdout) ## 1) create a WAMP router factory router_factory = wamp.RouterFactory() ## 2) create a WAMP router session factory session_factory = RouterSessionFactory(router_factory) ## 3) Optionally, add embedded WAMP application sessions to the router session_factory.add(MyBackendComponent()) ## 4) create a WAMP-over-WebSocket transport server factory transport_factory1 = WampWebSocketServerFactory(session_factory, debug = False) ## 5) start the server from a Twisted endpoint server1 = serverFromString(reactor, "tcp:8080") server1.listen(transport_factory1) ## 6) create a WAMP-over-RawSocket-MsgPack transport server factory serializer = MsgPackSerializer() serializer._serializer.ENABLE_V5 = False transport_factory2 = WampRawSocketServerFactory(session_factory, serializer, debug = True)
class TestEmbeddedSessions(unittest.TestCase): """ Test cases for application session running embedded in router. """ def setUp(self): """ Setup router and router session factories. """ if USE_ASYNCIO: self.loop = asyncio.new_event_loop() asyncio.set_event_loop(self.loop) self.router_factory = RouterFactory() self.session_factory = RouterSessionFactory(self.router_factory) def tearDown(self): if USE_ASYNCIO: self.loop.close() asyncio.set_event_loop(None) gc.collect() def test_add(self): """ Create an application session and add it to a router to run embedded. """ d = FutureMixin._create_future() class TestSession(ApplicationSession): def onJoin(self, details): FutureMixin._resolve_future(d, None) session = TestSession(types.ComponentConfig('realm1')) self.session_factory.add(session) if USE_ASYNCIO: self.loop.run_until_complete(d) elif USE_TWISTED: return d else: raise Exception("logic error") def test_add_and_subscribe(self): """ Create an application session that subscribes to some topic and add it to a router to run embedded. """ d = FutureMixin._create_future() class TestSession(ApplicationSession): def onJoin(self, details): def on_event(*arg, **kwargs): pass d2 = self.subscribe(on_event, u'com.example.topic1') def ok(_): FutureMixin._resolve_future(d, None) def error(err): FutureMixin._reject_future(d, err) FutureMixin._add_future_callbacks(d2, ok, error) session = TestSession(types.ComponentConfig('realm1')) self.session_factory.add(session) if USE_ASYNCIO: self.loop.run_until_complete(d) elif USE_TWISTED: return d else: raise Exception("logic error")
# we use an Autobahn utility to install the "best" available Twisted reactor ## from autobahn.twisted.choosereactor import install_reactor reactor = install_reactor() if args.debug: print("Running on reactor {}".format(reactor)) # create a WAMP router factory ## from autobahn.wamp.router import RouterFactory router_factory = RouterFactory() # create a WAMP router session factory from autobahn.twisted.wamp import RouterSessionFactory session_factory = RouterSessionFactory(router_factory) session_factory.session = WebServiceLoginRouterSession session_factory.add(TimeService(args.realm)) # create a WAMP-over-WebSocket transport server factory transport_factory = WampWebSocketServerFactory( session_factory, args.wsurl, debug_wamp=args.debug) #transport_factory.protocol = ServerProtocol transport_factory.setProtocolOptions(failByDrop=False) from twisted.web.server import Site from twisted.web.static import File from autobahn.twisted.resource import WebSocketResource
from autobahn.twisted.wamp import RouterFactory router_factory = RouterFactory() # create a user DB ## userdb = UserDb() userdb.add(authid=u"peter", authrole=u"user", secret=u"secret1", salt=u"salt123") userdb.add(authid=u"joe", authrole=u"user", secret=u"secret2") # create a WAMP router session factory ## from autobahn.twisted.wamp import RouterSessionFactory session_factory = RouterSessionFactory(router_factory) session_factory.session = MyRouterSession session_factory.userdb = userdb # start an embedded application component .. ## component_config = types.ComponentConfig(realm=u"realm1") component_session = TimeService(component_config) session_factory.add(component_session) # create a WAMP-over-WebSocket transport server factory ## from autobahn.twisted.websocket import WampWebSocketServerFactory transport_factory = WampWebSocketServerFactory(session_factory, args.wsurl, debug=False,
def start_webserver(options, protocol=vtk_wamp.ServerProtocol, disableLogging=False): """ Starts the web-server with the given protocol. Options must be an object with the following members: options.host : the interface for the web-server to listen on options.port : port number for the web-server to listen on options.timeout : timeout for reaping process on idle in seconds options.content : root for web-pages to serve. """ from twisted.internet import reactor from twisted.web.server import Site from twisted.web.static import File import sys if not disableLogging: log.startLogging(sys.stdout) contextFactory = None use_SSL = False if options.sslKey and options.sslCert: use_SSL = True wsProtocol = "wss" from twisted.internet import ssl contextFactory = ssl.DefaultOpenSSLContextFactory( options.sslKey, options.sslCert) else: wsProtocol = "ws" # Create WAMP router factory from autobahn.twisted.wamp import RouterFactory router_factory = RouterFactory() # create a user DB authdb = vtk_wamp.AuthDb() # create a WAMP router session factory from autobahn.twisted.wamp import RouterSessionFactory session_factory = RouterSessionFactory(router_factory) session_factory.session = vtk_wamp.CustomWampCraRouterSession session_factory.authdb = authdb # Create ApplicationSession and register protocols appSession = protocol(types.ComponentConfig(realm="vtkweb")) appSession.setAuthDB(authdb) session_factory.add(appSession) # create a WAMP-over-WebSocket transport server factory transport_factory = vtk_wamp.TimeoutWampWebSocketServerFactory(session_factory, \ url = "%s://%s:%d" % (wsProtocol, options.host, options.port), \ debug = options.debug, \ debug_wamp = options.debug, \ timeout = options.timeout ) root = Resource() # Do we serve static content or just websocket ? if len(options.content) > 0: # Static HTTP + WebSocket root = File(options.content) # Handle possibly complex ws endpoint if not options.nows: wsResource = WebSocketResource(transport_factory) handle_complex_resource_path(options.ws, root, wsResource) # Handle possibly complex lp endpoint if not options.nolp: lpResource = WampLongPollResource(session_factory) handle_complex_resource_path(options.lp, root, lpResource) if options.uploadPath != None: from upload import UploadPage uploadResource = UploadPage(options.uploadPath) root.putChild("upload", uploadResource) site = Site(root) if use_SSL: reactor.listenSSL(options.port, site, contextFactory) else: reactor.listenTCP(options.port, site) # Work around to force the output buffer to be flushed # This allow the process launcher to parse the output and # wait for "Start factory" to know that the WebServer # is running. if options.forceFlush: for i in range(200): log.msg("+" * 80, logLevel=logging.CRITICAL) # Initialize testing: checks if we're doing a test and sets it up testing.initialize(options, reactor, stop_webserver) # Start the reactor if options.nosignalhandlers: reactor.run(installSignalHandlers=0) else: reactor.run() # Give the testing module a chance to finalize, if necessary testing.finalize()
class Node: """ A Crossbar.io node is the running a controller process and one or multiple worker processes. A single Crossbar.io node runs exactly one instance of this class, hence this class can be considered a system singleton. """ def __init__(self, reactor, cbdir, debug = False): """ Ctor. :param reactor: Reactor to run on. :type reactor: obj :param cbdir: Crossbar.io node directory to run from. :type cbdir: str """ self.debug = debug self._reactor = reactor self._cbdir = cbdir self._worker_processes = {} ## node name: FIXME self._node_name = "{}-{}".format(socket.getfqdn(), os.getpid()) self._node_name.replace('-', '_') self._node_name = '918234' ## node management self._management_url = "ws://127.0.0.1:7000" #self._management_url = "wss://cloud.crossbar.io" self._management_realm = "crossbar.cloud.aliceblue" ## load Crossbar.io node configuration ## cf = os.path.join(self._cbdir, 'config.json') with open(cf, 'rb') as infile: self._config = json.load(infile) def start(self): """ Starts this node. This will start a node controller and then spawn new worker processes as needed. The node controller will watch spawned processes, communicate via stdio with the worker, and start and restart the worker processes as needed. """ ## the node controller singleton WAMP application session ## self._node_controller_session = NodeControllerSession(self) ## router and factory that creates router sessions ## self._router_factory = RouterFactory() self._router_session_factory = RouterSessionFactory(self._router_factory) ## add the node controller singleton session to the router ## self._router_session_factory.add(self._node_controller_session) if True: ## create a WAMP-over-WebSocket transport server factory ## from autobahn.twisted.websocket import WampWebSocketServerFactory from twisted.internet.endpoints import serverFromString self._router_server_transport_factory = WampWebSocketServerFactory(self._router_session_factory, "ws://localhost:9000", debug = False) self._router_server_transport_factory.setProtocolOptions(failByDrop = False) ## start the WebSocket server from an endpoint ## self._router_server = serverFromString(self._reactor, "tcp:9000") self._router_server.listen(self._router_server_transport_factory) ## factory that creates router session transports. these are for clients ## that talk WAMP-WebSocket over pipes with spawned worker processes and ## for any uplink session to a management service ## self._router_client_transport_factory = WampWebSocketClientFactory(self._router_session_factory, "ws://localhost", debug = False) self._router_client_transport_factory.setProtocolOptions(failByDrop = False) if False: management_session_factory = ApplicationSessionFactory() management_session_factory.session = NodeManagementSession management_session_factory.node_controller_session = node_controller_session management_transport_factory = WampWebSocketClientFactory(management_session_factory, "ws://127.0.0.1:7000") management_transport_factory.setProtocolOptions(failByDrop = False) management_client = clientFromString(self._reactor, "tcp:127.0.0.1:7000") management_client.connect(management_transport_factory) ## startup the node from configuration file ## self._node_controller_session.run_node_config(self._config)
from autobahn.twisted.choosereactor import install_reactor reactor = install_reactor() if args.debug: print("Running on reactor {}".format(reactor)) ## create a WAMP router factory ## from autobahn.wamp.router import RouterFactory router_factory = RouterFactory() ## create a WAMP router session factory ## from autobahn.twisted.wamp import RouterSessionFactory session_factory = RouterSessionFactory(router_factory) session_factory.add(TestService()) from autobahn.wamp.serializer import MsgPackSerializer serializer = MsgPackSerializer() from autobahn.twisted.rawsocket import WampRawSocketClientFactory, WampRawSocketClientProtocol transport_factory = WampRawSocketClientFactory(session_factory, serializer, debug = args.debug) class WorkerClientProtocol(WampRawSocketClientProtocol): def connectionMade(self): WampRawSocketClientProtocol.connectionMade(self)
def run(): import sys, argparse from twisted.python import log from twisted.internet.endpoints import serverFromString ## parse command line arguments ## def_wsocket = 'ws://127.0.0.1:8080/ws' def_xsocket = None def_user = '******' def_secret = '123test' def_realm = 'realm1' def_topic_base = 'sys' def_dsn = 'dbname=autobahn host=localhost user=autouser' def_endpoint = 'tcp:8080' def_engine = 'PG9_4' p = argparse.ArgumentParser( description="basicrouter example with database") p.add_argument('-w', '--websocket', action='store', dest='wsocket', default=def_wsocket, help='web socket ' + def_wsocket) p.add_argument('-x', '--xsocket', action='store', dest='xsocket', default=def_xsocket, help='x socket definition, default is: None ') p.add_argument('-r', '--realm', action='store', dest='realm', default=def_realm, help='connect to websocket using "realm", default ' + def_realm) p.add_argument('-v', '--verbose', action='store_true', dest='verbose', default=False, help='Verbose logging for debugging') p.add_argument('-u', '--user', action='store', dest='user', default=def_user, help='connect to websocket as user, default is: ' + def_user) p.add_argument('-s', '--secret', action='store', dest='password', default=def_secret, help='users "secret" password') p.add_argument('--debug', action='store_true', dest='debug', default=False, help='Autobahn layer debugging') p.add_argument( '-e', '--engine', action='store', dest='engine', default=def_engine, help= 'if specified, a database engine will be attached. Note engine is rooted on --topic' ) p.add_argument( "--endpoint", type=str, default="tcp:8080", help= 'Twisted server endpoint descriptor, e.g. "tcp:8080" or "unix:/tmp/mywebsocket", default is "' + def_endpoint + '"') p.add_argument( '-d', '--dsn', action='store', dest='dsn', default=def_dsn, help='if specified the database in dsn will be connected and ready') p.add_argument( '-t', '--topic', action='store', dest='topic_base', default=def_topic_base, help= 'if you specify --dsn then you will need a topic to root it on, the default ' + def_topic_base + ' is fine.') args = p.parse_args() if args.verbose: log.startLogging(sys.stdout) ## we use an Autobahn utility to install the "best" available Twisted reactor ## from autobahn.twisted.choosereactor import install_reactor reactor = install_reactor() log.msg("Running on reactor {}".format(reactor)) # database workers... userdb = UserDb(topic_base=args.topic_base + '.db', debug=args.verbose) sessiondb = SessionDb(topic_base=args.topic_base, debug=args.verbose) ## create a WAMP router factory ## component_config = types.ComponentConfig(realm=args.realm) xomponent_config = types.ComponentConfig(realm=args.realm) ai = { 'auth_type': 'wampcra', 'auth_user': args.user, 'auth_password': args.password } from autobahn.twisted.wamp import RouterFactory router_factory = RouterFactory() authorization_session = AuthorizeSession(component_config, topic_base=args.topic_base + '.db', debug=args.verbose, db=sessiondb, router=AuthorizeRouter) router_factory.router = authorization_session.ret_func ## create a WAMP router session factory ## from autobahn.twisted.wamp import RouterSessionFactory session_factory = RouterSessionFactory(router_factory) session_factory.session = MyRouterSession log.msg("session_factory.session") session_factory.userdb = userdb session_factory.sessiondb = sessiondb log.msg("userdb, sessiondb") sessiondb_component = SessionData(component_config, session_factory.sessiondb, topic_base=args.topic_base) session_factory.add(sessiondb_component) session_factory.add(authorization_session) log.msg("session_factory") db_session = DB(component_config, engine=args.engine, topic_base=args.topic_base + '.db', dsn=args.dsn, debug=args.verbose) session_factory.add(db_session) session_factory.userdb.set_session(db_session) session_factory.sessiondb.set_session(db_session) ## create a WAMP-over-WebSocket transport server factory ## from autobahn.twisted.websocket import WampWebSocketServerFactory transport_factory = WampWebSocketServerFactory(session_factory, debug=args.debug) transport_factory.setProtocolOptions(failByDrop=False) ## start the server from an endpoint ## ## this address clash detection was a goody I got from stackoverflow: ## http://stackoverflow.com/questions/12007316/exiting-twisted-application-after-listenfailure server = serverFromString(reactor, args.endpoint) def listen(): srv = server.listen(transport_factory) def ListenFailed(reason): log.msg("On Startup Listen Failed with {}".format(reason)) reactor.stop() srv.addErrback(ListenFailed) def addsession(): log.msg("here are three sessions {} {} {}".format( authorization_session, sessiondb_component, db_session)) qv = { "sessiondb_component": sessiondb_component._session_id, "db_session": db_session._session_id, "authorization_session": authorization_session._session_id } session_factory.sessiondb.set_system_sessions(qv) session_factory.sessiondb.add(0, sessiondb_component._session_id, sessiondb_component) session_factory.sessiondb.add(0, db_session._session_id, db_session) session_factory.sessiondb.add(0, authorization_session._session_id, authorization_session) reactor.callWhenRunning(listen) reactor.callWhenRunning(addsession) # if we set this router to be mastered by another, then start communicating with it if args.xsocket is not None: xdb = Xomponent(config=xomponent_config, authinfo=ai, topic_base=args.topic_base, debug=args.verbose, command='session', action='list', action_args={}) xdb.set_session(db_session) runner = ApplicationRunner(args.xsocket, args.realm) runner.run(lambda _: xdb, start_reactor=False) reactor.run()
class Node: """ A Crossbar.io node is the running a controller process and one or multiple worker processes. A single Crossbar.io node runs exactly one instance of this class, hence this class can be considered a system singleton. """ def __init__(self, reactor, options): """ Ctor. :param reactor: Reactor to run on. :type reactor: obj :param options: Options from command line. :type options: obj """ self.debug = False self.options = options ## the reactor under which we run self._reactor = reactor ## shortname for reactor to run (when given via explicit option) or None self._reactor_shortname = options.reactor ## node directory self._cbdir = options.cbdir ## the node's name (must be unique within the management realm) self._node_id = None ## the node's management realm self._realm = None ## node controller session (a singleton ApplicationSession embedded ## in the node's management router) self._controller = None 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_from_config(self, config): controller_config = config.get('controller', {}) controller_options = controller_config.get('options', {}) controller_title = controller_options.get('title', 'crossbar-controller') try: import setproctitle except ImportError: log.msg("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() ## the node's management realm self._realm = controller_config.get('realm', 'crossbar') ## the node controller singleton WAMP application session ## #session_config = ComponentConfig(realm = options.realm, extra = options) self._controller = NodeControllerSession(self) ## router and factory that creates router sessions ## self._router_factory = RouterFactory( options = wamp.types.RouterOptions(uri_check = wamp.types.RouterOptions.URI_CHECK_LOOSE), debug = False) self._router_session_factory = RouterSessionFactory(self._router_factory) ## add the node controller singleton session to the router ## self._router_session_factory.add(self._controller) ## Detect WAMPlets ## wamplets = self._controller._get_wamplets() if len(wamplets) > 0: log.msg("Detected {} WAMPlets in environment:".format(len(wamplets))) for wpl in wamplets: log.msg("WAMPlet {}.{}".format(wpl['dist'], wpl['name'])) else: log.msg("No WAMPlets detected in enviroment.") 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 = controller.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) @inlineCallbacks def run_node_config(self, config): try: yield self._run_node_config(config) except: traceback.print_exc() self._reactor.stop() @inlineCallbacks def _run_node_config(self, config): """ Setup node according to config provided. """ ## fake call details information when calling into ## remoted procedure locally ## call_details = CallDetails(caller = 0, authid = 'node') controller = config.get('controller', {}) ## start Manhole in node controller ## if 'manhole' in controller: yield self._controller.start_manhole(controller['manhole'], details = call_details) ## start local transport for management router ## if 'transport' in controller: yield self._controller.start_management_transport(controller['transport'], details = call_details) ## startup all workers ## worker_no = 1 for worker in config.get('workers', []): ## worker ID, type and logname ## if 'id' in worker: worker_id = worker.pop('id') else: worker_id = 'worker{}'.format(worker_no) worker_no += 1 worker_type = worker['type'] worker_options = worker.get('options', {}) if worker_type == 'router': worker_logname = "Router '{}'".format(worker_id) elif worker_type == 'container': worker_logname = "Container '{}'".format(worker_id) elif worker_type == 'guest': worker_logname = "Guest '{}'".format(worker_id) else: raise Exception("logic error") ## router/container ## if worker_type in ['router', 'container']: ## start a new native worker process .. ## if worker_type == 'router': yield self._controller.start_router(worker_id, worker_options, details = call_details) elif worker_type == 'container': yield self._controller.start_container(worker_id, worker_options, details = call_details) else: raise Exception("logic error") ## setup native worker generic stuff ## if 'pythonpath' in worker_options: added_paths = yield self._controller.call('crossbar.node.{}.worker.{}.add_pythonpath'.format(self._node_id, worker_id), worker_options['pythonpath']) if self.debug: log.msg("{}: PYTHONPATH extended for {}".format(worker_logname, added_paths)) else: log.msg("{}: PYTHONPATH extended".format(worker_logname)) if 'cpu_affinity' in worker_options: new_affinity = yield self._controller.call('crossbar.node.{}.worker.{}.set_cpu_affinity'.format(self._node_id, worker_id), worker_options['cpu_affinity']) log.msg("{}: CPU affinity set to {}".format(worker_logname, new_affinity)) if 'manhole' in worker: yield self._controller.call('crossbar.node.{}.worker.{}.start_manhole'.format(self._node_id, worker_id), worker['manhole']) log.msg("{}: manhole started".format(worker_logname)) ## setup router worker ## if worker_type == 'router': ## start realms on router ## realm_no = 1 for realm in worker.get('realms', []): if 'id' in realm: realm_id = realm.pop('id') else: realm_id = 'realm{}'.format(realm_no) realm_no += 1 ## extract schema information from WAMP-flavored Markdown ## schemas = None if 'schemas' in realm: schemas = {} schema_pat = re.compile(r"```javascript(.*?)```", re.DOTALL) cnt_files = 0 cnt_decls = 0 for schema_file in realm.pop('schemas'): schema_file = os.path.join(self.options.cbdir, schema_file) log.msg("{}: processing WAMP-flavored Markdown file {} for WAMP schema declarations".format(worker_logname, schema_file)) with open(schema_file, 'r') as f: cnt_files += 1 for d in schema_pat.findall(f.read()): try: o = json.loads(d) if type(o) == dict and '$schema' in o and o['$schema'] == u'http://wamp.ws/schema#': uri = o['uri'] if not uri in schemas: schemas[uri] = {} schemas[uri].update(o) cnt_decls += 1 except Exception as e: log.msg("{}: WARNING - failed to process declaration in {} - {}".format(worker_logname, schema_file, e)) log.msg("{}: processed {} files extracting {} schema declarations and {} URIs".format(worker_logname, cnt_files, cnt_decls, len(schemas))) yield self._controller.call('crossbar.node.{}.worker.{}.start_router_realm'.format(self._node_id, worker_id), realm_id, realm, schemas) log.msg("{}: realm '{}' started".format(worker_logname, realm_id)) ## add roles to realm ## role_no = 1 for role in realm.get('roles', []): if 'id' in role: role_id = role.pop('id') else: role_id = 'role{}'.format(role_no) role_no += 1 yield self._controller.call('crossbar.node.{}.worker.{}.start_router_realm_role'.format(self._node_id, worker_id), realm_id, role_id, role) log.msg("{}: role '{}' started on realm '{}'".format(worker_logname, role_id, realm_id)) ## start components to run embedded in the router ## component_no = 1 for component in worker.get('components', []): if 'id' in component: component_id = component.pop('id') else: component_id = 'component{}'.format(component_no) component_no += 1 yield self._controller.call('crossbar.node.{}.worker.{}.start_router_component'.format(self._node_id, worker_id), component_id, component) log.msg("{}: component '{}' started".format(worker_logname, component_id)) ## start transports on router ## transport_no = 1 for transport in worker['transports']: if 'id' in transport: transport_id = transport.pop('id') else: transport_id = 'transport{}'.format(transport_no) transport_no += 1 yield self._controller.call('crossbar.node.{}.worker.{}.start_router_transport'.format(self._node_id, worker_id), transport_id, transport) log.msg("{}: transport '{}' started".format(worker_logname, transport_id)) ## setup container worker ## elif worker_type == 'container': component_no = 1 for component in worker.get('components', []): if 'id' in component: component_id = component.pop('id') else: component_id = 'component{}'.format(component_no) component_no += 1 yield self._controller.call('crossbar.node.{}.worker.{}.start_container_component'.format(self._node_id, worker_id), component_id, component) log.msg("{}: component '{}' started".format(worker_logname, component_id)) else: raise Exception("logic error") elif worker_type == 'guest': ## start guest worker ## yield self._controller.start_guest(worker_id, worker, details = call_details) log.msg("{}: started".format(worker_logname)) else: raise Exception("logic error")
log.startLogging(sys.stdout) from autobahn.twisted.choosereactor import install_reactor reactor = install_reactor() print("Running on reactor {}".format(reactor)) ## create a WAMP router factory ## from autobahn.wamp.router import RouterFactory router_factory = RouterFactory() ## create a WAMP router session factory ## from autobahn.twisted.wamp import RouterSessionFactory session_factory = RouterSessionFactory(router_factory) ## [ ... ... ] session_factory.add(PubSubComponent()) ## create a WAMP-over-WebSocket transport server factory ## from autobahn.twisted.websocket import WampWebSocketServerFactory # NB: args.wsurl MUST NOT INCLUDE a path; hence it is not really a URL; all it supports is protocol (which must be ws or wss), hostname, and port. anything after that gives a mysterious # File "/usr/lib/python2.7/site-packages/autobahn/websocket/protocol.py", line 3383, in setSessionParameters # raise Exception("path specified for server WebSocket URL") transport_factory = WampWebSocketServerFactory(session_factory, args.wsurl, debug = True) transport_factory.setProtocolOptions(failByDrop = False) ## start the WebSocket server from an endpoint
yield self.register(Sketch_Stop, u"allofw.sketch.stop") yield self.register(Sketch_List, u"allofw.sketch.list") yield self.register(Sketch_GetCode, u"allofw.sketch.get_code") yield self.register(Project_List, u"allofw.project.list") yield self.register(Project_Delete, u"allofw.project.delete") yield self.register(Project_UploadFile, u"allofw.project.upload_file") yield self.register(Project_RenameFile, u"allofw.project.rename_file") yield self.register(Project_ListFiles, u"allofw.project.list_files") yield self.register(Project_LoadProject, u"allofw.project.load_project") yield self.register(Project_SaveProject, u"allofw.project.save_project") root = File("static") session_factory = RouterSessionFactory(RouterFactory()) component_config = types.ComponentConfig(realm="anonymous") session_factory.add(AllofwServer(component_config)) factory = WampWebSocketServerFactory(session_factory) factory.startFactory() resource = WebSocketResource(factory) root.putChild("ws", resource) site = Site(root) reactor.listenTCP(int(config['webserver']['port']), site, interface=config['webserver']['listen']) reactor.run()
debugCodePaths=True) data_endpoint.protocol = JsonDataServer #data_endpoint.setProtocolOptions(allowHixie76 = True) # needed if Hixie76 is to be supported ctl_endpoint = WebSocketServerFactory("ws://localhost:8080", debug=debug, debugCodePaths=True) ctl_endpoint.protocol = CtlProtocol from autobahn.wamp.router import RouterFactory router_factory = RouterFactory() ## create a WAMP router session factory ## from autobahn.twisted.wamp import RouterSessionFactory session_factory = RouterSessionFactory(router_factory) ## [ ... ... ] session_factory.add(ModelServer()) ## create a WAMP-over-WebSocket transport server factory ## from autobahn.twisted.websocket import WampWebSocketServerFactory wamp_factory = WampWebSocketServerFactory(session_factory, "ws://localhost:8080", debug=True) wamp_factory.setProtocolOptions(failByDrop=False) webroot = pathjoin(PROJECT_ROOT, "src", "frontend") assets = pathjoin(PROJECT_ROOT, "assets") if debug:
## we use an Autobahn utility to install the "best" available Twisted reactor ## from autobahn.twisted.choosereactor import install_reactor reactor = install_reactor() if args.debug: print("Running on reactor {}".format(reactor)) ## create a WAMP router factory ## from autobahn.wamp.router import RouterFactory router_factory = RouterFactory() ## create a WAMP router session factory ## from autobahn.twisted.wamp import RouterSessionFactory session_factory = RouterSessionFactory(router_factory) ## .. and create and add an WAMP application session to ## run next to the router ## from autobahn.wamp import types config = types.ComponentConfig(realm=args.realm, extra={'caselog': 'case1.log'}) if False: embedded_components = [Case1_Backend] client_components = [Case1_Frontend] else: embedded_components = [] #client_components = [Case2_Backend]
from autobahn.twisted.choosereactor import install_reactor reactor = install_reactor() if args.debug: print("Running on reactor {}".format(reactor)) ## create a WAMP router factory ## from autobahn.wamp.router import RouterFactory router_factory = RouterFactory() ## create a WAMP router session factory ## from autobahn.twisted.wamp import RouterSessionFactory session_factory = RouterSessionFactory(router_factory) session_factory.session = MyRouterSession ## start an embedded application component .. ## session_factory.add(TimeService()) ## create a WAMP-over-WebSocket transport server factory ## from autobahn.twisted.websocket import WampWebSocketServerFactory transport_factory = WampWebSocketServerFactory(session_factory, args.wsurl, debug_wamp = args.debug) transport_factory.protocol = ServerProtocol transport_factory._cookies = {}
# we use an Autobahn utility to install the "best" available Twisted reactor ## from autobahn.twisted.choosereactor import install_reactor reactor = install_reactor() if args.debug: print("Running on reactor {}".format(reactor)) # create a WAMP router factory ## from autobahn.wamp.router import RouterFactory router_factory = RouterFactory() # create a WAMP router session factory from autobahn.twisted.wamp import RouterSessionFactory session_factory = RouterSessionFactory(router_factory) session_factory.session = WebServiceLoginRouterSession session_factory.add(TimeService(args.realm)) # create a WAMP-over-WebSocket transport server factory transport_factory = WampWebSocketServerFactory(session_factory, args.wsurl, debug_wamp=args.debug) #transport_factory.protocol = ServerProtocol transport_factory.setProtocolOptions(failByDrop=False) from twisted.web.server import Site from twisted.web.static import File from autobahn.twisted.resource import WebSocketResource
## we use an Autobahn utility to install the "best" available Twisted reactor ## from autobahn.twisted.choosereactor import install_reactor reactor = install_reactor() if args.debug: print("Running on reactor {}".format(reactor)) ## create a WAMP router factory ## from autobahn.wamp.router import RouterFactory router_factory = RouterFactory() ## create a WAMP router session factory ## from autobahn.twisted.wamp import RouterSessionFactory session_factory = RouterSessionFactory(router_factory) ## if asked to start an embedded application component .. ## if args.component: ## dynamically load the application component .. ## import importlib c = args.component.split('.') mod, klass = '.'.join(c[:-1]), c[-1] app = importlib.import_module(mod) SessionKlass = getattr(app, klass) ## .. and create and add an WAMP application session to ## run next to the router ##
class Node: """ A Crossbar.io node is the running a controller process and one or multiple worker processes. A single Crossbar.io node runs exactly one instance of this class, hence this class can be considered a system singleton. """ def __init__(self, reactor, options): """ Ctor. :param reactor: Reactor to run on. :type reactor: obj :param options: Options from command line. :type options: obj """ self.debug = False self.options = options ## the reactor under which we run self._reactor = reactor ## shortname for reactor to run (when given via explicit option) or None self._reactor_shortname = options.reactor ## node directory self._cbdir = options.cbdir ## the node's name (must be unique within the management realm) self._node_id = None ## the node's management realm self._realm = None ## node controller session (a singleton ApplicationSession embedded ## in the node's management router) self._controller = None 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_from_config(self, config): controller_config = config.get('controller', {}) controller_options = controller_config.get('options', {}) controller_title = controller_options.get('title', 'crossbar-controller') try: import setproctitle except ImportError: log.msg( "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() ## the node's management realm self._realm = controller_config.get('realm', 'crossbar') ## the node controller singleton WAMP application session ## #session_config = ComponentConfig(realm = options.realm, extra = options) self._controller = NodeControllerSession(self) ## router and factory that creates router sessions ## self._router_factory = RouterFactory(options=wamp.types.RouterOptions( uri_check=wamp.types.RouterOptions.URI_CHECK_LOOSE), debug=False) self._router_session_factory = RouterSessionFactory( self._router_factory) ## add the node controller singleton session to the router ## self._router_session_factory.add(self._controller) ## Detect WAMPlets ## wamplets = self._controller._get_wamplets() if len(wamplets) > 0: log.msg("Detected {} WAMPlets in environment:".format( len(wamplets))) for wpl in wamplets: log.msg("WAMPlet {}.{}".format(wpl['dist'], wpl['name'])) else: log.msg("No WAMPlets detected in enviroment.") 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 = controller.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) @inlineCallbacks def run_node_config(self, config): try: yield self._run_node_config(config) except: traceback.print_exc() self._reactor.stop() @inlineCallbacks def _run_node_config(self, config): """ Setup node according to config provided. """ ## fake call details information when calling into ## remoted procedure locally ## call_details = CallDetails(caller=0, authid='node') controller = config.get('controller', {}) ## start Manhole in node controller ## if 'manhole' in controller: yield self._controller.start_manhole(controller['manhole'], details=call_details) ## start local transport for management router ## if 'transport' in controller: yield self._controller.start_management_transport( controller['transport'], details=call_details) ## startup all workers ## worker_no = 1 for worker in config.get('workers', []): ## worker ID, type and logname ## if 'id' in worker: worker_id = worker.pop('id') else: worker_id = 'worker{}'.format(worker_no) worker_no += 1 worker_type = worker['type'] worker_options = worker.get('options', {}) if worker_type == 'router': worker_logname = "Router '{}'".format(worker_id) elif worker_type == 'container': worker_logname = "Container '{}'".format(worker_id) elif worker_type == 'guest': worker_logname = "Guest '{}'".format(worker_id) else: raise Exception("logic error") ## router/container ## if worker_type in ['router', 'container']: ## start a new native worker process .. ## if worker_type == 'router': yield self._controller.start_router(worker_id, worker_options, details=call_details) elif worker_type == 'container': yield self._controller.start_container( worker_id, worker_options, details=call_details) else: raise Exception("logic error") ## setup native worker generic stuff ## if 'pythonpath' in worker_options: added_paths = yield self._controller.call( 'crossbar.node.{}.worker.{}.add_pythonpath'.format( self._node_id, worker_id), worker_options['pythonpath']) if self.debug: log.msg("{}: PYTHONPATH extended for {}".format( worker_logname, added_paths)) else: log.msg( "{}: PYTHONPATH extended".format(worker_logname)) if 'cpu_affinity' in worker_options: new_affinity = yield self._controller.call( 'crossbar.node.{}.worker.{}.set_cpu_affinity'.format( self._node_id, worker_id), worker_options['cpu_affinity']) log.msg("{}: CPU affinity set to {}".format( worker_logname, new_affinity)) if 'manhole' in worker: yield self._controller.call( 'crossbar.node.{}.worker.{}.start_manhole'.format( self._node_id, worker_id), worker['manhole']) log.msg("{}: manhole started".format(worker_logname)) ## setup router worker ## if worker_type == 'router': ## start realms on router ## realm_no = 1 for realm in worker.get('realms', []): if 'id' in realm: realm_id = realm.pop('id') else: realm_id = 'realm{}'.format(realm_no) realm_no += 1 ## extract schema information from WAMP-flavored Markdown ## schemas = None if 'schemas' in realm: schemas = {} schema_pat = re.compile(r"```javascript(.*?)```", re.DOTALL) cnt_files = 0 cnt_decls = 0 for schema_file in realm.pop('schemas'): schema_file = os.path.join( self.options.cbdir, schema_file) log.msg( "{}: processing WAMP-flavored Markdown file {} for WAMP schema declarations" .format(worker_logname, schema_file)) with open(schema_file, 'r') as f: cnt_files += 1 for d in schema_pat.findall(f.read()): try: o = json.loads(d) if type( o ) == dict and '$schema' in o and o[ '$schema'] == u'http://wamp.ws/schema#': uri = o['uri'] if not uri in schemas: schemas[uri] = {} schemas[uri].update(o) cnt_decls += 1 except Exception as e: log.msg( "{}: WARNING - failed to process declaration in {} - {}" .format( worker_logname, schema_file, e)) log.msg( "{}: processed {} files extracting {} schema declarations and {} URIs" .format(worker_logname, cnt_files, cnt_decls, len(schemas))) yield self._controller.call( 'crossbar.node.{}.worker.{}.start_router_realm'. format(self._node_id, worker_id), realm_id, realm, schemas) log.msg("{}: realm '{}' started".format( worker_logname, realm_id)) ## add roles to realm ## role_no = 1 for role in realm.get('roles', []): if 'id' in role: role_id = role.pop('id') else: role_id = 'role{}'.format(role_no) role_no += 1 yield self._controller.call( 'crossbar.node.{}.worker.{}.start_router_realm_role' .format(self._node_id, worker_id), realm_id, role_id, role) log.msg( "{}: role '{}' started on realm '{}'".format( worker_logname, role_id, realm_id)) ## start components to run embedded in the router ## component_no = 1 for component in worker.get('components', []): if 'id' in component: component_id = component.pop('id') else: component_id = 'component{}'.format(component_no) component_no += 1 yield self._controller.call( 'crossbar.node.{}.worker.{}.start_router_component' .format(self._node_id, worker_id), component_id, component) log.msg("{}: component '{}' started".format( worker_logname, component_id)) ## start transports on router ## transport_no = 1 for transport in worker['transports']: if 'id' in transport: transport_id = transport.pop('id') else: transport_id = 'transport{}'.format(transport_no) transport_no += 1 yield self._controller.call( 'crossbar.node.{}.worker.{}.start_router_transport' .format(self._node_id, worker_id), transport_id, transport) log.msg("{}: transport '{}' started".format( worker_logname, transport_id)) ## setup container worker ## elif worker_type == 'container': component_no = 1 for component in worker.get('components', []): if 'id' in component: component_id = component.pop('id') else: component_id = 'component{}'.format(component_no) component_no += 1 yield self._controller.call( 'crossbar.node.{}.worker.{}.start_container_component' .format(self._node_id, worker_id), component_id, component) log.msg("{}: component '{}' started".format( worker_logname, component_id)) else: raise Exception("logic error") elif worker_type == 'guest': ## start guest worker ## yield self._controller.start_guest(worker_id, worker, details=call_details) log.msg("{}: started".format(worker_logname)) else: raise Exception("logic error")
from autobahn.twisted.choosereactor import install_reactor reactor = install_reactor() print("Running on reactor {}".format(reactor)) ## create a WAMP router factory ## from autobahn.wamp.router import RouterFactory router_factory = RouterFactory() ## create a WAMP router session factory ## from autobahn.twisted.wamp import RouterSessionFactory session_factory = RouterSessionFactory(router_factory) ## [ ... ... ] session_factory.add(PubSubComponent()) ## create a WAMP-over-WebSocket transport server factory ## from autobahn.twisted.websocket import WampWebSocketServerFactory # NB: args.wsurl MUST NOT INCLUDE a path; hence it is not really a URL; all it supports is protocol (which must be ws or wss), hostname, and port. anything after that gives a mysterious # File "/usr/lib/python2.7/site-packages/autobahn/websocket/protocol.py", line 3383, in setSessionParameters # raise Exception("path specified for server WebSocket URL") transport_factory = WampWebSocketServerFactory(session_factory, args.wsurl, debug=True) transport_factory.setProtocolOptions(failByDrop=False) ## start the WebSocket server from an endpoint
from autobahn.twisted.choosereactor import install_reactor reactor = install_reactor() if args.debug: print("Running on reactor {}".format(reactor)) ## create a WAMP router factory ## from autobahn.wamp.router import RouterFactory router_factory = RouterFactory() ## create a WAMP router session factory ## from autobahn.twisted.wamp import RouterSessionFactory session_factory = RouterSessionFactory(router_factory) ## if asked to start an embedded application component .. ## if args.component: ## dynamically load the application component .. ## import importlib c = args.component.split('.') mod, klass = '.'.join(c[:-1]), c[-1] app = importlib.import_module(mod) SessionKlass = getattr(app, klass) ## .. and create and add an WAMP application session to ## run next to the router
# we use an Autobahn utility to install the "best" available Twisted reactor ## from autobahn.twisted.choosereactor import install_reactor reactor = install_reactor() if args.debug: print("Running on reactor {}".format(reactor)) # create a WAMP router factory ## from autobahn.twisted.wamp import RouterFactory router_factory = RouterFactory() # create a WAMP router session factory ## from autobahn.twisted.wamp import RouterSessionFactory session_factory = RouterSessionFactory(router_factory) session_factory.session = MyRouterSession # start an embedded application component .. ## component_config = types.ComponentConfig(realm="realm1") component_session = TimeService(component_config) session_factory.add(component_session) # create a WAMP-over-WebSocket transport server factory ## from autobahn.twisted.websocket import WampWebSocketServerFactory transport_factory = WampWebSocketServerFactory(session_factory, args.wsurl, debug=False, debug_wamp=args.debug) transport_factory.protocol = ServerProtocol transport_factory._cookies = {}
def test_minimal(self): embedded_components, client_components = [], [Case2_Backend, Case2_Frontend] ## create a WAMP router factory ## router_factory = RouterFactory() ## create a WAMP router session factory ## session_factory = RouterSessionFactory(router_factory) ## .. and create and add an WAMP application session to ## run next to the router ## config = types.ComponentConfig(realm = self.realm, extra = { 'caselog': 'case1.log' } ) try: log = io.open('caselog.log', 'w') except Exception as e: print(e) return # log = io.open(config.extra['caselog'], 'w') config.log = log config.dlog = [] config.components = [] config.all_done = [] for C in embedded_components: one_done = Deferred() config.all_done.append(one_done) c = C(config, one_done) config.components.append(c) session_factory.add(c) if self.transport == "websocket": ## create a WAMP-over-WebSocket transport server factory ## transport_factory = WampWebSocketServerFactory(session_factory, debug_wamp = self.debug) transport_factory.setProtocolOptions(failByDrop = False, openHandshakeTimeout = 0, closeHandshakeTimeout = 0) elif self.transport in ['rawsocket-json', 'rawsocket-msgpack']: ## create a WAMP-over-RawSocket transport server factory ## if self.transport == 'rawsocket-msgpack': serializer = MsgPackSerializer() elif self.transport == 'rawsocket-json': serializer = JsonSerializer() else: raise Exception("should not arrive here") transport_factory = WampRawSocketServerFactory(session_factory, serializer, debug = self.debug) else: raise Exception("should not arrive here") ## start the server from an endpoint ## from twisted.internet import reactor server = serverFromString(reactor, self.server) d = server.listen(transport_factory) def onlisten(port): config.port = port d.addCallback(onlisten) clients = [] clients_d = [] for C in client_components: ## create a WAMP application session factory ## session_factory = ApplicationSessionFactory(config) one_done = Deferred() config.all_done.append(one_done) def make_make(Klass, done): def make(config): c = Klass(config, done) config.components.append(c) return c return make ## .. and set the session class on the factory ## session_factory.session = make_make(C, one_done) if self.transport == "websocket": serializers = [JsonSerializer()] ## create a WAMP-over-WebSocket transport client factory ## transport_factory = WampWebSocketClientFactory(session_factory, serializers = serializers, url = self.url, debug_wamp = self.debug) if True: def maker(Klass): class TestClientProtocol(WampWebSocketClientProtocol): def onOpen(self): self.txcnt = 0 self.rxcnt = 0 WampWebSocketClientProtocol.onOpen(self) def sendMessage(self, payload, isBinary): self.txcnt += 1 print("> : {0:>3} : {1:<20} : {3}".format(self.txcnt, Klass.__name__, payload)) WampWebSocketClientProtocol.sendMessage(self, payload, isBinary) def onMessage(self, payload, isBinary): self.rxcnt += 1 print("< : {0:>3} : {1:<20} : {2}".format(self.rxcnt, Klass.__name__, payload)) WampWebSocketClientProtocol.onMessage(self, payload, isBinary) return TestClientProtocol transport_factory.protocol = maker(C) else: transport_factory.protocol = WampWebSocketClientProtocol transport_factory.setProtocolOptions(failByDrop = False, openHandshakeTimeout = 0, closeHandshakeTimeout = 0) elif self.transport in ['rawsocket-json', 'rawsocket-msgpack']: ## create a WAMP-over-RawSocket transport client factory ## if self.transport == 'rawsocket-msgpack': serializer = MsgPackSerializer() elif self.transport == 'rawsocket-json': serializer = JsonSerializer() else: raise Exception("should not arrive here") transport_factory = WampRawSocketClientFactory(session_factory, serializer, debug = self.debug) ## start the client from an endpoint ## cl = clientFromString(reactor, self.client) clients_d.append(cl.connect(transport_factory)) clients.append(cl) config.connected_clients = None def client_connected(res): config.connected_clients = [proto for success, proto in res if success] DeferredList(clients_d).addCallback(client_connected) d = DeferredList(config.all_done, consumeErrors = True) #d = config.components[1]._done def done(_): log.flush() log.close() if config.port: config.port.stopListening() if config.connected_clients: for proto in config.connected_clients: proto.transport.abortConnection() print("Log length: {0}".format(len(config.dlog))) print(config.dlog) #from twisted.internet import reactor #reactor.callLater(1, reactor.stop) def error(err): print(err) d.addCallbacks(done, error) # d2 = Deferred() return d
#data_endpoint.setProtocolOptions(allowHixie76 = True) # needed if Hixie76 is to be supported ctl_endpoint = WebSocketServerFactory("ws://localhost:8080", debug = debug, debugCodePaths = True) ctl_endpoint.protocol = CtlProtocol from autobahn.wamp.router import RouterFactory router_factory = RouterFactory() ## create a WAMP router session factory ## from autobahn.twisted.wamp import RouterSessionFactory session_factory = RouterSessionFactory(router_factory) ## [ ... ... ] session_factory.add(ModelServer()) ## create a WAMP-over-WebSocket transport server factory ## from autobahn.twisted.websocket import WampWebSocketServerFactory wamp_factory = WampWebSocketServerFactory(session_factory, "ws://localhost:8080", debug = True) wamp_factory.setProtocolOptions(failByDrop = False) webroot = pathjoin(PROJECT_ROOT,"src","frontend") assets = pathjoin(PROJECT_ROOT,"assets") if debug: print "putting", webroot,"at root"
self.publish('com.myapp.topic1', counter) print("Published event: {}".format(counter)) counter += 1 yield sleep(1) if __name__ == '__main__': ## 0) start logging to console log.startLogging(sys.stdout) ## 1) create a WAMP router factory router_factory = RouterFactory() ## 2) create a WAMP router session factory session_factory = RouterSessionFactory(router_factory) ## 3) Optionally, add embedded WAMP application sessions to the router session_factory.add(MyBackendComponent()) ## 4) create a WAMP-over-WebSocket transport server factory transport_factory1 = WampWebSocketServerFactory(session_factory, debug=False) ## 5) start the server from a Twisted endpoint server1 = serverFromString(reactor, "tcp:8080") server1.listen(transport_factory1) ## 6) create a WAMP-over-RawSocket-MsgPack transport server factory serializer = MsgPackSerializer() serializer._serializer.ENABLE_V5 = False
def start_webserver(options, protocol=vtk_wamp.ServerProtocol, disableLogging=False): """ Starts the web-server with the given protocol. Options must be an object with the following members: options.host : the interface for the web-server to listen on options.port : port number for the web-server to listen on options.timeout : timeout for reaping process on idle in seconds options.content : root for web-pages to serve. """ from twisted.internet import reactor from twisted.web.server import Site from twisted.web.static import File import sys if not disableLogging: log.startLogging(sys.stdout) contextFactory = None use_SSL = False if options.sslKey and options.sslCert: use_SSL = True wsProtocol = "wss" from twisted.internet import ssl contextFactory = ssl.DefaultOpenSSLContextFactory(options.sslKey, options.sslCert) else: wsProtocol = "ws" # Create WAMP router factory from autobahn.twisted.wamp import RouterFactory router_factory = RouterFactory() # create a user DB authdb = vtk_wamp.AuthDb() # create a WAMP router session factory from autobahn.twisted.wamp import RouterSessionFactory session_factory = RouterSessionFactory(router_factory) session_factory.session = vtk_wamp.CustomWampCraRouterSession session_factory.authdb = authdb # Create ApplicationSession and register protocols appSession = protocol(types.ComponentConfig(realm = "vtkweb")) appSession.setAuthDB(authdb) session_factory.add(appSession) # create a WAMP-over-WebSocket transport server factory transport_factory = vtk_wamp.TimeoutWampWebSocketServerFactory(session_factory, \ url = "%s://%s:%d" % (wsProtocol, options.host, options.port), \ debug = options.debug, \ debug_wamp = options.debug, \ timeout = options.timeout ) root = Resource() # Do we serve static content or just websocket ? if len(options.content) > 0: # Static HTTP + WebSocket root = File(options.content) # Handle possibly complex ws endpoint if not options.nows: wsResource = WebSocketResource(transport_factory) handle_complex_resource_path(options.ws, root, wsResource) # Handle binary push WebSocket for images if not options.nobws: wsbFactory = WebSocketServerFactory( \ url = "%s://%s:%d" % (wsProtocol, options.host, options.port), \ debug = options.debug) wsbFactory.protocol = vtk_wamp.ImagePushBinaryWebSocketServerProtocol wsbResource = WebSocketResource(wsbFactory) handle_complex_resource_path('wsb', root, wsbResource) # Handle possibly complex lp endpoint if not options.nolp: lpResource = WampLongPollResource(session_factory, timeout=options.timeout, debug=options.debug) #killAfter = 30000, #queueLimitBytes = 1024 * 1024, #queueLimitMessages = 1000, #debug=True, #reactor=reactor) handle_complex_resource_path(options.lp, root, lpResource) if options.uploadPath != None : from vtk.web.upload import UploadPage uploadResource = UploadPage(options.uploadPath) root.putChild("upload", uploadResource) if len(options.fsEndpoints) > 3: for fsResourceInfo in options.fsEndpoints.split('|'): infoSplit = fsResourceInfo.split('=') handle_complex_resource_path(infoSplit[0], root, File(infoSplit[1])) site = Site(root) if use_SSL: reactor.listenSSL(options.port, site, contextFactory) else: reactor.listenTCP(options.port, site) # flush ready line sys.stdout.flush() # Work around to force the output buffer to be flushed # This allow the process launcher to parse the output and # wait for "Start factory" to know that the WebServer # is running. if options.forceFlush : for i in range(200): log.msg("+"*80, logLevel=logging.CRITICAL) # Initialize testing: checks if we're doing a test and sets it up testing.initialize(options, reactor, stop_webserver) # Start the reactor if options.nosignalhandlers: reactor.run(installSignalHandlers=0) else: reactor.run() # Give the testing module a chance to finalize, if necessary testing.finalize()
def start_webserver(options, protocol=vtk_wamp.ServerProtocol, disableLogging=False): """ Starts the web-server with the given protocol. Options must be an object with the following members: options.host : the interface for the web-server to listen on options.port : port number for the web-server to listen on options.timeout : timeout for reaping process on idle in seconds options.content : root for web-pages to serve. """ from twisted.internet import reactor from twisted.web.server import Site from twisted.web.static import File import sys if not disableLogging: log.startLogging(sys.stdout) contextFactory = None use_SSL = False if options.sslKey and options.sslCert: use_SSL = True wsProtocol = "wss" from twisted.internet import ssl contextFactory = ssl.DefaultOpenSSLContextFactory(options.sslKey, options.sslCert) else: wsProtocol = "ws" # Create WAMP router factory from autobahn.wamp.router import RouterFactory router_factory = RouterFactory() # create a WAMP router session factory from autobahn.twisted.wamp import RouterSessionFactory session_factory = RouterSessionFactory(router_factory) # Register protocol session_factory.add(protocol()) # create a WAMP-over-WebSocket transport server factory transport_factory = vtk_wamp.TimeoutWampWebSocketServerFactory(session_factory, \ url = "%s://%s:%d" % (wsProtocol, options.host, options.port), \ debug = options.debug, \ debug_wamp = options.debug, \ timeout = options.timeout ) # Do we serve static content or just websocket ? if len(options.content) == 0: # Only WebSocket listenWS(transport_factory, contextFactory, options.timeout) else: # Static HTTP + WebSocket wsResource = WebSocketResource(transport_factory) root = File(options.content) root.putChild("ws", wsResource) if options.uploadPath != None : from upload import UploadPage uploadResource = UploadPage(options.uploadPath) root.putChild("upload", uploadResource) site = Site(root) if use_SSL: reactor.listenSSL(options.port, site, contextFactory) else: reactor.listenTCP(options.port, site) # Work around to force the output buffer to be flushed # This allow the process launcher to parse the output and # wait for "Start factory" to know that the WebServer # is running. if options.forceFlush : for i in range(200): log.msg("+"*80, logLevel=logging.CRITICAL) # Give test client a chance to initialize a thread for itself # testing.initialize(opts=options) # Initialize testing: checks if we're doing a test and sets it up testing.initialize(options, reactor) # Start the reactor if options.nosignalhandlers: reactor.run(installSignalHandlers=0) else: reactor.run() # Give the testing module a chance to finalize, if necessary testing.finalize()
def test_minimal(self): embedded_components, client_components = [], [ Case2_Backend, Case2_Frontend ] ## create a WAMP router factory ## router_factory = RouterFactory() ## create a WAMP router session factory ## session_factory = RouterSessionFactory(router_factory) ## .. and create and add an WAMP application session to ## run next to the router ## config = types.ComponentConfig(realm=self.realm, extra={'caselog': 'case1.log'}) try: log = io.open('caselog.log', 'w') except Exception as e: print(e) return # log = io.open(config.extra['caselog'], 'w') config.log = log config.dlog = [] config.components = [] config.all_done = [] for C in embedded_components: one_done = Deferred() config.all_done.append(one_done) c = C(config, one_done) config.components.append(c) session_factory.add(c) if self.transport == "websocket": ## create a WAMP-over-WebSocket transport server factory ## transport_factory = WampWebSocketServerFactory( session_factory, debug_wamp=self.debug) transport_factory.setProtocolOptions(failByDrop=False, openHandshakeTimeout=0, closeHandshakeTimeout=0) elif self.transport in ['rawsocket-json', 'rawsocket-msgpack']: ## create a WAMP-over-RawSocket transport server factory ## if self.transport == 'rawsocket-msgpack': serializer = MsgPackSerializer() elif self.transport == 'rawsocket-json': serializer = JsonSerializer() else: raise Exception("should not arrive here") transport_factory = WampRawSocketServerFactory( session_factory, serializer, debug=self.debug) else: raise Exception("should not arrive here") ## start the server from an endpoint ## from twisted.internet import reactor server = serverFromString(reactor, self.server) d = server.listen(transport_factory) def onlisten(port): config.port = port d.addCallback(onlisten) clients = [] clients_d = [] for C in client_components: ## create a WAMP application session factory ## session_factory = ApplicationSessionFactory(config) one_done = Deferred() config.all_done.append(one_done) def make_make(Klass, done): def make(config): c = Klass(config, done) config.components.append(c) return c return make ## .. and set the session class on the factory ## session_factory.session = make_make(C, one_done) if self.transport == "websocket": serializers = [JsonSerializer()] ## create a WAMP-over-WebSocket transport client factory ## transport_factory = WampWebSocketClientFactory( session_factory, serializers=serializers, url=self.url, debug_wamp=self.debug) if True: def maker(Klass): class TestClientProtocol( WampWebSocketClientProtocol): def onOpen(self): self.txcnt = 0 self.rxcnt = 0 WampWebSocketClientProtocol.onOpen(self) def sendMessage(self, bytes, isBinary): self.txcnt += 1 print("> : {:>3} : {:<20} : {}".format( self.txcnt, Klass.__name__, bytes)) WampWebSocketClientProtocol.sendMessage( self, bytes, isBinary) def onMessage(self, bytes, isBinary): self.rxcnt += 1 print("< : {:>3} : {:<20} : {}".format( self.rxcnt, Klass.__name__, bytes)) WampWebSocketClientProtocol.onMessage( self, bytes, isBinary) return TestClientProtocol transport_factory.protocol = maker(C) else: transport_factory.protocol = WampWebSocketClientProtocol transport_factory.setProtocolOptions( failByDrop=False, openHandshakeTimeout=0, closeHandshakeTimeout=0) elif self.transport in ['rawsocket-json', 'rawsocket-msgpack']: ## create a WAMP-over-RawSocket transport client factory ## if self.transport == 'rawsocket-msgpack': serializer = MsgPackSerializer() elif self.transport == 'rawsocket-json': serializer = JsonSerializer() else: raise Exception("should not arrive here") transport_factory = WampRawSocketClientFactory( session_factory, serializer, debug=self.debug) ## start the client from an endpoint ## cl = clientFromString(reactor, self.client) clients_d.append(cl.connect(transport_factory)) clients.append(cl) config.connected_clients = None def client_connected(res): config.connected_clients = [ proto for success, proto in res if success ] DeferredList(clients_d).addCallback(client_connected) d = DeferredList(config.all_done, consumeErrors=True) #d = config.components[1]._done def done(res): log.flush() log.close() if config.port: config.port.stopListening() if config.connected_clients: for proto in config.connected_clients: proto.transport.abortConnection() print("Log length: {}".format(len(config.dlog))) print(config.dlog) #from twisted.internet import reactor #reactor.callLater(1, reactor.stop) def error(err): print(err) d.addCallbacks(done, error) # d2 = Deferred() return d
def run(): import sys, argparse from twisted.python import log from twisted.internet.endpoints import serverFromString ## parse command line arguments ## def_wsocket = 'ws://127.0.0.1:8080/ws' def_realm = 'realm1' def_topic_base = 'sys' def_dsn = 'dbname=autobahn host=localhost user=autouser' def_endpoint='tcp:8080' def_engine = 'PG9_4' p = argparse.ArgumentParser(description="basicrouter example with database") p.add_argument('-w', '--websocket', action='store', dest='wsocket', default=def_wsocket, help='web socket '+def_wsocket) p.add_argument('-r', '--realm', action='store', dest='realm', default=def_realm, help='connect to websocket using "realm", default '+def_realm) p.add_argument('-v', '--verbose', action='store_true', dest='verbose', default=False, help='Verbose logging for debugging') p.add_argument('--debug', action='store_true', dest='debug', default=False, help='Autobahn layer debugging') p.add_argument('-e', '--engine', action='store', dest='engine', default=def_engine, help='if specified, a database engine will be attached. Note engine is rooted on --topic') p.add_argument("--endpoint", type = str, default = "tcp:8080", help = 'Twisted server endpoint descriptor, e.g. "tcp:8080" or "unix:/tmp/mywebsocket", default is "' + def_endpoint + '"') p.add_argument('-d', '--dsn', action='store', dest='dsn', default=def_dsn, help='if specified the database in dsn will be connected and ready') p.add_argument('-t', '--topic', action='store', dest='topic_base', default=def_topic_base, help='if you specify --dsn then you will need a topic to root it on, the default ' + def_topic_base + ' is fine.') args = p.parse_args() if args.verbose: log.startLogging(sys.stdout) ## we use an Autobahn utility to install the "best" available Twisted reactor ## from autobahn.twisted.choosereactor import install_reactor reactor = install_reactor() log.msg("Running on reactor {}".format(reactor)) # database workers... userdb = UserDb(topic_base=args.topic_base+'.db',debug=args.verbose) sessiondb = SessionDb(topic_base=args.topic_base,debug=args.verbose) ## create a WAMP router factory ## component_config = types.ComponentConfig(realm = args.realm) from autobahn.twisted.wamp import RouterFactory router_factory = RouterFactory() authorization_session = AuthorizeSession(component_config, topic_base=args.topic_base+'.db',debug=args.verbose,db=sessiondb,router=AuthorizeRouter) router_factory.router = authorization_session.ret_func ## create a WAMP router session factory ## from autobahn.twisted.wamp import RouterSessionFactory session_factory = RouterSessionFactory(router_factory) session_factory.session = MyRouterSession log.msg("session_factory.session") session_factory.userdb = userdb session_factory.sessiondb = sessiondb log.msg("userdb, sessiondb") sessiondb_component = SessionData(component_config,session_factory.sessiondb, topic_base=args.topic_base) session_factory.add(sessiondb_component) session_factory.add(authorization_session) log.msg("session_factory") db_session = DB(component_config, engine=args.engine, topic_base=args.topic_base+'.db', dsn=args.dsn, debug=args.verbose) session_factory.add(db_session) session_factory.userdb.set_session(db_session) session_factory.sessiondb.set_session(db_session) ## create a WAMP-over-WebSocket transport server factory ## from autobahn.twisted.websocket import WampWebSocketServerFactory transport_factory = WampWebSocketServerFactory(session_factory, debug = args.debug) transport_factory.setProtocolOptions(failByDrop = False) ## start the server from an endpoint ## ## this address clash detection was a goody I got from stackoverflow: ## http://stackoverflow.com/questions/12007316/exiting-twisted-application-after-listenfailure server = serverFromString(reactor, args.endpoint) def listen(): srv = server.listen(transport_factory) def ListenFailed(reason): log.msg("On Startup Listen Failed with {}".format(reason)) reactor.stop() srv.addErrback(ListenFailed) def addsession(): log.msg("here are three sessions {} {} {}".format(authorization_session, sessiondb_component, db_session)) qv = { "sessiondb_component":sessiondb_component._session_id, "db_session":db_session._session_id, "authorization_session":authorization_session._session_id } session_factory.sessiondb.set_system_sessions(qv) session_factory.sessiondb.add(0, sessiondb_component._session_id, sessiondb_component) session_factory.sessiondb.add(0, db_session._session_id, db_session) session_factory.sessiondb.add(0, authorization_session._session_id, authorization_session) reactor.callWhenRunning(listen) reactor.callWhenRunning(addsession) reactor.run()
## we use an Autobahn utility to install the "best" available Twisted reactor ## from autobahn.twisted.choosereactor import install_reactor reactor = install_reactor() if args.debug: print("Running on reactor {}".format(reactor)) ## create a WAMP router factory ## from autobahn.wamp.router import RouterFactory router_factory = RouterFactory() ## create a WAMP router session factory ## from autobahn.twisted.wamp import RouterSessionFactory session_factory = RouterSessionFactory(router_factory) session_factory.session = MyRouterSession ## start an embedded application component .. ## session_factory.add(TimeService()) ## create a WAMP-over-WebSocket transport server factory ## from autobahn.twisted.websocket import WampWebSocketServerFactory transport_factory = WampWebSocketServerFactory(session_factory, args.wsurl, debug_wamp=args.debug) transport_factory.protocol = ServerProtocol transport_factory._cookies = {}
from autobahn.twisted.choosereactor import install_reactor reactor = install_reactor() if args.debug: print("Running on reactor {}".format(reactor)) ## create a WAMP router factory ## from autobahn.twisted.wamp import RouterFactory router_factory = RouterFactory() ## create a WAMP router session factory ## from autobahn.twisted.wamp import RouterSessionFactory session_factory = RouterSessionFactory(router_factory) ## .. and create and add an WAMP application session to ## run next to the router ## from autobahn.wamp import types config = types.ComponentConfig(realm = args.realm, extra = { 'caselog': 'case1.log' } ) if False:
## we use an Autobahn utility to install the "best" available Twisted reactor ## from autobahn.twisted.choosereactor import install_reactor reactor = install_reactor() print("Running on reactor {}".format(reactor)) ## create a WAMP router factory ## from autobahn.twisted.wamp import RouterFactory router_factory = RouterFactory() ## create a WAMP router session factory ## from autobahn.twisted.wamp import RouterSessionFactory session_factory = RouterSessionFactory(router_factory) ## create a WAMP-over-WebSocket transport server factory ## from autobahn.twisted.websocket import WampWebSocketServerFactory transport_factory = WampWebSocketServerFactory(session_factory, debug=args.debug) transport_factory.setProtocolOptions(failByDrop=False) ## start the server from an endpoint ## server = serverFromString(reactor, args.endpoint) server.listen(transport_factory) ## now enter the Twisted reactor loop ##
class Node: """ A Crossbar.io node is the running a controller process and one or multiple worker processes. A single Crossbar.io node runs exactly one instance of this class, hence this class can be considered a system singleton. """ def __init__(self, reactor, options): """ Ctor. :param reactor: Reactor to run on. :type reactor: obj :param cbdir: Crossbar.io node directory to run from. :type cbdir: str """ self.debug = options.debug self._cbdir = options.cbdir self._reactor = reactor self._worker_processes = {} ## node name: FIXME self._node_name = "{}-{}".format(socket.getfqdn(), os.getpid()) self._node_name.replace('-', '_') self._node_name = '918234' self._node_realm = 'crossbar' self._node_controller_session = None ## node management self._management_url = "ws://127.0.0.1:7000" #self._management_url = "wss://cloud.crossbar.io" self._management_realm = "crossbar.cloud.aliceblue" @inlineCallbacks def start(self): """ Starts this node. This will start a node controller and then spawn new worker processes as needed. The node controller will watch spawned processes, communicate via stdio with the worker, and start and restart the worker processes as needed. """ try: import setproctitle except ImportError: log.msg("Warning, could not set process title (setproctitle not installed)") else: setproctitle.setproctitle("Crossbar.io Node Controller") ## the node controller singleton WAMP application session ## self._node_controller_session = NodeControllerSession(self) ## router and factory that creates router sessions ## self._router_factory = RouterFactory( options = types.RouterOptions(uri_check = types.RouterOptions.URI_CHECK_LOOSE), debug = False) self._router_session_factory = RouterSessionFactory(self._router_factory) ## add the node controller singleton session to the router ## self._router_session_factory.add(self._node_controller_session) ## Detect WAMPlets ## for wpl in self._node_controller_session.list_wamplets(): log.msg("WAMPlet detected: {}.{}".format(wpl['dist'], wpl['name'])) yield self.start_from_local_config(configfile = os.path.join(self._cbdir, 'config.json')) self.start_local_management_transport(endpoint_descriptor = "tcp:9000") def start_remote_management_client(self): from crossbar.management import NodeManagementSession management_session_factory = ApplicationSessionFactory() management_session_factory.session = NodeManagementSession management_session_factory.node_controller_session = node_controller_session management_transport_factory = WampWebSocketClientFactory(management_session_factory, "ws://127.0.0.1:7000") management_transport_factory.setProtocolOptions(failByDrop = False) management_client = clientFromString(self._reactor, "tcp:127.0.0.1:7000") management_client.connect(management_transport_factory) def start_local_management_transport(self, endpoint_descriptor): ## create a WAMP-over-WebSocket transport server factory ## from autobahn.twisted.websocket import WampWebSocketServerFactory from twisted.internet.endpoints import serverFromString self._router_server_transport_factory = WampWebSocketServerFactory(self._router_session_factory, debug = self.debug) self._router_server_transport_factory.setProtocolOptions(failByDrop = False) ## start the WebSocket server from an endpoint ## self._router_server = serverFromString(self._reactor, endpoint_descriptor) self._router_server.listen(self._router_server_transport_factory) @inlineCallbacks def start_from_local_config(self, configfile): ## load Crossbar.io node configuration ## configfile = os.path.abspath(configfile) log.msg("Loading from local config '{}' ..".format(configfile)) config = check_config_file(configfile, silence = True) ## startup the node from configuration file ## yield self._node_controller_session.run_node_config(config) log.msg("Local configuration loaded.")