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
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
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, debug_wamp=args.debug)
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()
# 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.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 = {} transport_factory.setProtocolOptions(failByDrop=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()
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 args.transport == "websocket": from autobahn.wamp.serializer import JsonSerializer serializers = [JsonSerializer()] ## create a WAMP-over-WebSocket transport client factory ## transport_factory = WampWebSocketClientFactory( session_factory, serializers=serializers, url=args.url, debug_wamp=args.debug)
from autobahn.twisted.wamp import ApplicationSessionFactory 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 args.transport == "websocket": from autobahn.wamp.serializer import JsonSerializer serializers = [JsonSerializer()] ## create a WAMP-over-WebSocket transport client factory ## transport_factory = WampWebSocketClientFactory(session_factory, serializers = serializers, url = args.url, debug_wamp = args.debug) if False: def maker(Klass): class TestClientProtocol(WampWebSocketClientProtocol):
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()
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 from twisted.web.resource import Resource 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 # Register protocol session_factory.add(protocol(authdb=authdb)) # 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) # 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 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()
# 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 serve static files under "/" ..