def setUp(): if len(sys.argv) > 1 and sys.argv[1] == 'debug': log.startLogging(sys.stdout) debug = True else: debug = False try: import autobahn import twisted except ImportError: sys.exit("Install all dependencies") root = Resource() # root.putChild(constants.WEB_DYNAMIC_BRANCH, resource) from autobahn.twisted.resource import WebSocketResource, HTTPChannelHixie76Aware from twisted.web.server import Site factory = BroadcastServerFactory("ws://127.0.0.1:8888", debug=debug, debugCodePaths=debug) #если используется proxy #factory.proxy={'host': '192.168.200.105', 'port': '8088'} factory.protocol = BroadcastServerProtocol factory.setProtocolOptions(allowHixie76=True) ws_resource = WebSocketResource(factory) root.putChild("ws", ws_resource) site = Site(root) site.protocol = HTTPChannelHixie76Aware listenWS(factory) reactor.run()
def test_no_self_connect(): """ Test that when a producer connects, the consumer sends all existing subscription to it. """ class WampConsumerServerFactory(ConsumerMixin, wamp.WampServerFactory): protocol = wamp.WampServerProtocol id = generate_id() consumer = ConsumerServer('localhost', 19200, id=id) consumer.processor = WampConsumerServerFactory('ws://localhost:19202') listenWS(consumer.processor) producer = ProducerClient(id=id) deferLater(reactor, 0.5, producer.connect, 'localhost', 19200) def check_connection(): """ Make sure producer has no connections, because it's been controlled. """ print(set(producer.nodes)) assert set(producer.nodes) == set() return deferLater(reactor, 1.0, check_connection)
def setUp(): if len(sys.argv) > 1 and sys.argv[1] == 'debug': log.startLogging(sys.stdout) debug = True else: debug = False try: import autobahn import twisted except ImportError: sys.exit("Install all dependencies") from orm.database_init import init_db, db_session from apps.web import constants init_db() from pdb import set_trace set_trace() from apps.web import main_resource root = main_resource.Root() reactor.listenTCP(8000, server.Site(main_resource.Root())) factory = BroadcastServerFactory("ws://127.0.0.1:8011", debug=debug, debugCodePaths=debug) factory.protocol = BroadcastServerProtocol factory.setProtocolOptions(allowHixie76=True) ws_resource = WebSocketResource(factory) root.putChild("ws", ws_resource) site = Site(root) site.protocol = HTTPChannelHixie76Aware listenWS(factory) reactor.run()
def startServer(self, webport, debug = False): ## WAMP Server for wsperf slaves ## wsperf = WsPerfMasterFactory("ws://localhost:9090") wsperf.debugWsPerf = debug listenWS(wsperf) ## Web Server for UI static files ## if webport: webdir = File(pkg_resources.resource_filename("autobahntestsuite", "web/wsperfmaster")) web = Site(webdir) reactor.listenTCP(webport, web) ## WAMP Server for UI ## wsperfUi = WsPerfMasterUiFactory("ws://localhost:9091") wsperfUi.debug = debug wsperfUi.debugWamp = debug listenWS(wsperfUi) ## Connect servers ## wsperf.uiFactory = wsperfUi wsperfUi.slaveFactory = wsperf
def __init__(self, interface, port, id=None): self.nodes = WeakSet() url = 'ws://{0}:{1}/'.format(interface, port) log.msg('pubsubclub: Listening on %s' % url) websocket.WebSocketServerFactory.__init__(self, url) websocket.listenWS(self) self.id = id
def __init__(self, url): WebSocketServerFactory.__init__(self, url) self.clients = [] self.tickGap = 5 self.tickSetup() listenWS(self)
def run(self): if len(sys.argv) > 1 and sys.argv[1] == 'debug': log.startLogging(sys.stdout) debug = True else: debug = False global cam ServerFactory = BroadcastServerFactory # ServerFactory = BroadcastPreparedServerFactory factory = ServerFactory("ws://localhost:9000", debug=debug, debugCodePaths=debug) factory.protocol = BroadcastServerProtocol factory.setProtocolOptions(allowHixie76=True) listenWS(factory) path = os.path.join(os.path.curdir,"www") print path webdir = File(path) web = Site(webdir) reactor.listenTCP(8000, web) reactor.run() cam.stop_recording() cam.close()
def execute(self): factory = WampServerFactory("ws://localhost:17998", debug = False, debugWamp = False) factory.protocol = PlywoodWebSocketServerProtocol factory.setProtocolOptions(allowHixie76 = True) listenWS(factory) reactor.run(installSignalHandlers=0)
def startServer(wsuri, sslKey = None, sslCert = None, debug = False): factory = TesteeServerFactory(wsuri, debug) if sslKey and sslCert: sslContext = ssl.DefaultOpenSSLContextFactory(sslKey, sslCert) else: sslContext = None listenWS(factory, sslContext) return True
def serve_web(): listenWS(factory) webdir = File(".") web = Site(webdir) reactor.listenTCP(8080, web) reactor.run()
def init_networking(self): factory = BroadcastServerFactory("ws://{}:{}".format(self.config['host'], self.config['port'])) factory.world = self.world factory.game = self self.world.networking_factory = factory factory.cache = MessageCache(self.world) factory.protocol = UserCommunication listenWS(factory) logging.info("Server is listening on %s:%i" % (factory.host, factory.port))
def __init__(self): print '\nRunning notification server in port 8182' factory = WebSocketServerFactory('ws://localhost:8182') factory.protocol = ServiceServerProtocol listenWS(factory) try: reactor.run(installSignalHandlers=0) except KeyboardInterrupt: reactor.stop()
def listen(cls, uri, apps, allowHixie76=False, debug=False): with log.enter(obj=cls) as tm: global server_factory url = urlparse.urlparse(uri) server_factory = ServerFactory(uri, apps, debug=debug) server_factory.protocol = cls server_factory.setProtocolOptions(allowHixie76=allowHixie76) listenWS(server_factory) server_factory.internal_client = InternalClientProtocol.connect(uri, debug) return server_factory
def start_echo_server(): factory = WebSocketServerFactory('ws://0.0.0.0:9000', debug = False) factory.protocol = EchoServerProtocol thread = EchoThread() # thread.start() listenWS(factory) print 'listening'
def setupWebSocket( address, engine, protocol ): ''' Listen for WebSocket connections at the given address. ''' factory = WebSocketServerFactory( address ) factory.engine = engine factory.protocol = protocol listenWS( factory ) print "Listening for WebSocket connections at:", address
def spawnWebsocketServer(uri, logLevel, protocol, externalPort=None): if logLevel == "DEBUG": isDebug = True else: isDebug = False factory = WebSocketServerFactory(uri, debug=isDebug, externalPort=externalPort) factory.protocol = protocol factory.setProtocolOptions(perMessageCompressionAccept=acceptedCompression) listenWS(factory) reactor.run()
def startServer(wsuri, sslKey = None, sslCert = None, debug = False): factory = BroadcastServerFactory(wsuri, debug) if sslKey and sslCert: sslContext = ssl.DefaultOpenSSLContextFactory(sslKey, sslCert) else: sslContext = None listenWS(factory, sslContext) webdir = File(pkg_resources.resource_filename("autobahntestsuite", "web/broadcastserver")) web = Site(webdir) reactor.listenTCP(8080, web) return True
def startService(self): # here the channel requested from the websocket is passed to the redis conn # basically, the listeners of websockets and redis messages are coupled here def onMessageReceived(message): msg = dict(channel=self.channel, message=message) self.wsfactory.broadcast(msg) self.redisFactory.onMessageReceived = onMessageReceived # start listening for websocket connections listenWS(self.wsfactory) # connect to redis self.redisFactory.connectTCP(self.channel, reactor)
def _start_server(self): """ Start shotgun web server, listening to websocket connections. :param debug: Boolean Show debug output. Will also Start local web server to test client pages. """ cert_crt_path, cert_key_path = certificates.get_certificate_file_names(self._keys_path) self._raise_if_missing_certificate(cert_key_path) self._raise_if_missing_certificate(cert_crt_path) # SSL server context: load server key and certificate self.context_factory = ssl.DefaultOpenSSLContextFactory(cert_key_path, cert_crt_path) # FIXME: Seems like the debugging flags are gone from the initializer at the moment. # We should try to restore these. self.factory = WebSocketServerFactory( "wss://localhost:%d" % self._port ) self.factory.protocol = ServerProtocol self.factory.host = self._host self.factory.host_aliases = self._host_aliases self.factory.user_id = self._user_id self.factory.notifier = self.notifier self.factory.ws_server_id = self._ws_server_id self.factory.setProtocolOptions(echoCloseCodeReason=True) try: self.listener = listenWS(self.factory, self.context_factory) except error.CannotListenError, e: raise PortBusyError(str(e))
def run(self): #import gc #gc.enable() #gc.set_debug(gc.DEBUG_LEAK) # Registers the memory statistics function super(WebSocketServer, self).run() factory = self.factory(self.uri, self.extPort) factory.protocol = self.protocol factory.setProtocolOptions(perMessageCompressionAccept=acceptedCompression) # This has to be in the child process listener = listenWS(factory) def tearDown(): # callback to stopListening def stopReactor(): if reactor.running: reactor.stop d = listener.stopListening() d.addCallback(stopReactor) reactor.addSystemEventTrigger('before', 'shutdown', tearDown) reactor.run()
def _start_server(self): """ Start shotgun web server, listening to websocket connections. :param debug: Boolean Show debug output. Will also Start local web server to test client pages. """ cert_crt_path, cert_key_path = certificates.get_certificate_file_names(self._keys_path) self._raise_if_missing_certificate(cert_key_path) self._raise_if_missing_certificate(cert_crt_path) # SSL server context: load server key and certificate self.context_factory = ssl.DefaultOpenSSLContextFactory(cert_key_path, cert_crt_path) self.factory = WebSocketServerFactory( "wss://localhost:%d" % self._port, debug=self._debug, debugCodePaths=self._debug ) self.factory.protocol = ServerProtocol self.factory.websocket_server_whitelist = self._whitelist self.factory.setProtocolOptions(allowHixie76=True, echoCloseCodeReason=True) try: self.listener = listenWS(self.factory, self.context_factory) except error.CannotListenError, e: raise PortBusyError(str(e))
def main(): parser = argparse.ArgumentParser() parser.add_argument('-u', '--url', default='ws://localhost:9001', help='Listen URL [default: %(default)s]') parser.add_argument('-O', '--options', default=jsondict({'failByDrop':False}), type=jsondict, action='append', help='extra options (overwrites existing) [default: %(default)s]') parser.add_argument('-p', '--webport', default=9090, type=int) parser.add_argument('-i', '--listen-interface', default='localhost', help='interface to listen on') parser.add_argument('-w', '--webdir', default='.') parser.add_argument('-d', '--debug', default=False, action='store_true', help='Debug Mode [default: %(default)s]') parser.add_argument('-o', '--outdir', default='./pages/results', metavar='DIR', help='Output Directory [default: %(default)s]') parser.add_argument('-c', '--cases', default=['*'], nargs='+', help='test cases [default: %(default)s]') parser.add_argument('-x', '--exclude-cases', default=[], nargs='+', help='test cases to exclude [default: %(default)s]') parser.add_argument('-l', '--logfile', type=argparse.FileType('w'), default=sys.stdout, help='logging file [default: stdout]') parser.add_argument('-t', '--exit-timeout', metavar='SECONDS', default=None, type=float, help='Will automatically exit after %(metavar)s seconds [default: %(default)s]') args = parser.parse_args() spec = args.__dict__ log.startLogging(args.logfile) ## fuzzing server fuzzer = FuzzingServerFactory(spec) listenWS(fuzzer, interface=args.listen_interface) ## web server webdir = File(args.webdir) web = Site(webdir) reactor.listenTCP(args.webport, web, interface=args.listen_interface) log.msg("Using Twisted reactor class %s" % str(reactor.__class__)) if args.exit_timeout: def exit_callback(): log.msg("Exiting due to timeout (--exit-timeout/-t)") reactor.fireSystemEvent('shutdown') #reactor.stop() sys.exit(12) reactor.callLater(args.exit_timeout, exit_callback) reactor.run()
def run(self, start_reactor=True): # Look for event classes in the source tree self.autodiscover() # Create factory self.factory = GatewayWampServerFactory(self.url, debugWamp=self.debug, gateway=self ) self.factory.protocol = TelegraphyConnection self.factory.setProtocolOptions(allowHixie76=True) listenWS(self.factory) r = WebAppXMLRPCInterface(gateway=self) reactor.listenTCP(self.xmlrpc_port, server.Site(r)) if start_reactor: reactor.run()
def run(self): def signal_handler(*args): logger.info("Stopping threads, please wait...") # teardown() self.raw_report_processor.stop() reactor.stop() site = twisted.web.server.Site(self.__root_resource) if self.__ssl_enabled: ssl_context = self.__load_ssl_certs() self.__listen_func = functools.partial( reactor.listenSSL, contextFactory=ssl_context) else: self.__listen_func = reactor.listenTCP try: self.install_signal() # start threads and processes self.raw_report_processor = RawReportProcessor() self.raw_report_processor.start() # web and static content self.__listen_func( self.__listen_port, site, interface=self.__bind_address) # websockets try: listenWS(self.__build_websockets_resource(), interface=self.__bind_address) except : logger.warn('Could not start websockets, address already open. This is ok is you wan to run multiple instances.') logger.info('Faraday Server is ready') reactor.addSystemEventTrigger('before', 'shutdown', signal_handler) reactor.run() except error.CannotListenError as e: logger.error(str(e)) sys.exit(1) except Exception as e: logger.error('Something went wrong when trying to setup the Web UI') logger.exception(e) sys.exit(1)
def main(): # Explicitly set dbus main loop. DBusGMainLoop(set_as_default=True) # Wake up the settings manager dbus service. try: settings_bus = SessionBus().get_object( 'org.gnome.SettingsDaemon', '/org/gnome/SettingsDaemon') except DBusException as e: dialog = gtk.MessageDialog( None, gtk.DIALOG_DESTROY_WITH_PARENT, gtk.MESSAGE_ERROR, gtk.BUTTONS_CLOSE, GSM_NOT_FOUND_MESSAGE) dialog.run() dialog.destroy() return try: settings_bus.Awake(dbus_interface='org.gnome.SettingsDaemon') except DBusException as e: # May not always be wakeable. That's Ok. pass # Create server. factory = BroadcastServerFactory('ws://localhost:1337') listenWS(factory) # Start twisted. reactor.startRunning() # Create the tray icon. Must keep reference to prevent GC. icon = createTrayIcon() #Run GTK loop. gtk.main() # Kill twisted if it's still alive. if reactor.running: reactor.stop()
def main(): writelog('starting server') if len(sys.argv) > 1 and sys.argv[1] == 'debug': log.startLogging(sys.stdout) debug = True #print 'debuggin' else: debug = False log.startLogging(DailyLogFile.fromFullPath("/var/log/sprinkler.log")) debug = True contextFactory = ssl.DefaultOpenSSLContextFactory('/home/pi/cron/keys/server.key', '/home/pi/cron/keys/server.crt') ServerFactory = BroadcastServerFactory #ServerFactory = BroadcastPreparedServerFactory factory = ServerFactory("wss://localhost:5000", debug = debug, debugCodePaths = debug) factory2 = ServerFactory("ws://localhost:5001", debug = debug, debugCodePaths = debug) factory.protocol = BroadcastServerProtocol factory.setProtocolOptions(allowHixie76 = True) factory2.protocol = BroadcastServerProtocol factory2.setProtocolOptions(allowHixie76 = True) listenWS(factory2) listenWS(factory,contextFactory) webdir = File("/home/pi/cron/sprinklerwww/") web = Site(webdir) web.protocol = HTTPChannelHixie76Aware webdir.contentTypes['.crt'] = 'application/x-x509-ca-cert' print 'starting server' webdir.putChild("sChange",sChange()) webdir.putChild("schedule",schedule()) webdir.putChild("manual",manual()) #reactor.listenTCP(8080, web) reactor.listenSSL(8081,web,contextFactory) reactor.run()
def __init__(self, queue): self.queue = queue # set up handler to drop emails from the 'queue' into the main queue lc = task.LoopingCall(self.processSockets) lc.start(2) # fire up static server while we're here staticResource = File('./static/dist') staticFactory = Site(staticResource, logPath=os.devnull) staticFactory.noisy = False if Config.useSSL: contextFactory = ssl.DefaultOpenSSLContextFactory( Config.keyFile, Config.certFile ) # static HTTPS serving reactor.listenSSL(Config.httpsPort, staticFactory, contextFactory) # WSS WSfactory = WebSocketServerFactory(u"wss://localhost:9000", debug=False) WSfactory.protocol = self.MyServerProtocol WSfactory.noisy = False listenWS(WSfactory, contextFactory) else: # static HTTP serving reactor.listenTCP(Config.httpPort, staticFactory) # WS WSfactory = WebSocketServerFactory(u"ws://localhost:9000", debug=False) WSfactory.protocol = self.MyServerProtocol WSfactory.noisy = False listenWS(WSfactory) # no handlers because threads reactor.run(installSignalHandlers=0)
def __init__(self): logging.Handler.__init__(self) factory = BroadcastLogFactory("ws://0.0.0.0:0") factory.protocol = BroadcastLogProtocol self.port = listenWS(factory).getHost() self.factory = factory # Start the reactor thread, setting daemon to True # (daemon = True) allows the program to normally end, which allows the # close function to be called, where we explicitly join the reactor # thread self._th = Thread(target=reactor.run, args=(False,)) self._th.daemon = True self._th.start()
def setupWebSocketFactory(hostname, port, extPort, cLogger): """ Registers factory along with the protocol Args: hostname : resolvable fqdn of the system port : port to listen on extPort : external port if running behind a proxy. logger : global logger Return: websocket factory websocket listener object """ factory = MetrilyxWebSocketServerFactory(cLogger, "ws://%s:%d" % (hostname, port), externalPort=extPort) factory.protocol = getConfiguredProtocol(cLogger) factory.setProtocolOptions(perMessageCompressionAccept=acceptedCompression) cLogger.warning("Starting websocket server: ws://%s:%d [permessage-deflate]" % (hostname, port)) return factory, listenWS(factory)
def startService(self): """ Starting a TCP server and put to the right service collection :return: """ if self.factory.ws_protocol == 'ws': factory = self.factory.ws_server_factory(self.factory.url) factory.protocol = self.factory.ws_msg_protocol factory.name = self.factory.name self.factory.ws_server_factory = factory internet.TCPServer( self.factory.port, factory, 50 ).setServiceParent(self.service_collection) else: factory = self.factory.ws_server_factory(self.factory.url) factory.protocol = self.factory.ws_msg_protocol factory.startFactory() self.factory.ws_server_factory = factory self.listener = listenWS(self.factory.ws_server_factory, self.__ssl_context) if self.factory.belong_to is False: return self.__application
def run(self, mode=Modes.DEVELOPMENT, ssl_only=False, use_ssl=False, open_browser=True, ui_path=None): """ Start up and run the broker. This method call with not return """ from parlay.protocols.websocket import WebSocketServerAdapter import webbrowser # cleanup on sigint signal.signal(signal.SIGINT, lambda sig, frame: self.cleanup()) if mode == Broker.Modes.DEVELOPMENT: print("INFO: Broker running in DEVELOPER mode. This is fine for a development environment") print("INFO: For production systems run the Broker in PRODUCTION mode. e.g.: " + \ "broker.run(mode=Broker.Modes.PRODUCTION)") # print out the local ip to access this broker from print("This device is remotely accessible at http://" + self.get_local_ip() + ":" + str(self.http_port)) self._run_mode = mode # interface to listen on. In Development mode listen on everything # in production mode, only listen on localhost interface = '127.0.0.1' if mode == Broker.Modes.PRODUCTION else "" # UI path if ui_path is not None: root = static.File(ui_path) root.putChild("parlay", static.File(PARLAY_PATH + "/ui")) else: root = static.File(PARLAY_PATH + "/ui/dist") root.putChild("docs", static.File(PARLAY_PATH + "/docs/_build/html")) # ssl websocket if use_ssl: try: from OpenSSL.SSL import Context ssl_context_factory = BrokerSSlContextFactory() factory = WebSocketServerFactory("wss://localhost:" + str(self.secure_websocket_port)) factory.protocol = WebSocketServerAdapter factory.setProtocolOptions() listenWS(factory, ssl_context_factory, interface=interface) root.contentTypes['.crt'] = 'application/x-x509-ca-cert' self.reactor.listenSSL(self.https_port, server.Site(root), ssl_context_factory, interface=interface) except ImportError: print("WARNING: PyOpenSSL is *not* installed. Parlay cannot host HTTPS or WSS without PyOpenSSL") except Exception as e: print("WARNING: PyOpenSSL has had an error: " + str(e)) if ssl_only: raise if not ssl_only: # listen for websocket connections on port 8085 factory = WebSocketServerFactory("ws://localhost:" + str(self.websocket_port)) factory.protocol = WebSocketServerAdapter self.reactor.listenTCP(self.websocket_port, factory, interface=interface) # http server site = server.Site(root) self.reactor.listenTCP(self.http_port, site, interface=interface) if open_browser: # give the reactor some time to init before opening the browser self.reactor.callLater(.5, lambda: webbrowser.open_new_tab("http://localhost:"+str(self.http_port))) # add advertising reactor.listenMulticast(self.websocket_port, advertiser.ParlayAdvertiser(), listenMultiple=True) self.reactor.callWhenRunning(self._started.callback, None) self.reactor.run()
def _listenServer(self, d): factory = WampServerFactory('ws://localhost:9000', debugWamp=True) factory.protocol = ServerProtocol factory.onConnectionLost = d return listenWS(factory)
"""Return some JavaScript.""" return js_code @app.route('/') def index(request): return html c = SimpleRPCContainer() @c.register def alert(con, text): """Handle text.""" if text: return f'I received: {text}' raise Exception('You must enter something.') @c.register def problem(con): raise Exception('That was an error.') if __name__ == '__main__': f = WebSocketServerFactory('ws://0.0.0.0:9000') f.protocol = c.protocol listenWS(f) app.run(host='0.0.0.0', port=8080)
default="ws://localhost:9000", help="Listening URI of WAMP server, e.g. ws://localhost:9000.") parser.add_argument( "-t", "--topic", type=str, default="http://example.com/simple", help="Topic URI to use, e.g. http://example.com/simple") parser.add_argument( "-s", "--secure", help= "Enable WAMP-CRA authentication (as anonymous) - This is for testing with Crossbar.io", action="store_true") config = parser.parse_args() if config.debug: log.startLogging(sys.stdout) factory = LoadLatencyBrokerFactory(config) listenWS(factory, backlog=4096) print reactor.__class__ print autobahn.utf8validator.Utf8Validator print autobahn.xormasker.XorMaskerNull print autobahn.wamp1.protocol.json_lib reactor.run()
def main(): parser = argparse.ArgumentParser() parser.add_argument('-u', '--url', default='ws://localhost:9001', help='Listen URL [default: %(default)s]') parser.add_argument( '-O', '--options', default=jsondict({'failByDrop': False}), type=jsondict, action='append', help='extra options (overwrites existing) [default: %(default)s]') parser.add_argument('-p', '--webport', default=9090, type=int) parser.add_argument('-i', '--listen-interface', default='localhost', help='interface to listen on') parser.add_argument('-w', '--webdir', default='.') parser.add_argument('-d', '--debug', default=False, action='store_true', help='Debug Mode [default: %(default)s]') parser.add_argument('-o', '--outdir', default='./pages/results', metavar='DIR', help='Output Directory [default: %(default)s]') parser.add_argument('-c', '--cases', default=['*'], nargs='+', help='test cases [default: %(default)s]') parser.add_argument('-x', '--exclude-cases', default=[], nargs='+', help='test cases to exclude [default: %(default)s]') parser.add_argument('-l', '--logfile', type=argparse.FileType('w'), default=sys.stdout, help='logging file [default: stdout]') parser.add_argument( '-t', '--exit-timeout', metavar='SECONDS', default=None, type=float, help= 'Will automatically exit after %(metavar)s seconds [default: %(default)s]' ) args = parser.parse_args() spec = args.__dict__ log.startLogging(args.logfile) ## fuzzing server fuzzer = FuzzingServerFactory(spec) listenWS(fuzzer, interface=args.listen_interface) ## web server webdir = File(args.webdir) web = Site(webdir) reactor.listenTCP(args.webport, web, interface=args.listen_interface) log.msg("Using Twisted reactor class %s" % str(reactor.__class__)) if args.exit_timeout: def exit_callback(): log.msg("Exiting due to timeout (--exit-timeout/-t)") reactor.fireSystemEvent('shutdown') #reactor.stop() sys.exit(12) reactor.callLater(args.exit_timeout, exit_callback) reactor.run()
def run(*args): TESTNET = args[0] # database db = Database(TESTNET) # key generation keys = KeyChain(db) # logging # TODO: prune this log file and prevent it from getting too large? logFile = logfile.LogFile.fromFullPath(DATA_FOLDER + "debug.log") log.addObserver(FileLogObserver(logFile, level=args[1]).emit) log.addObserver(FileLogObserver(level=args[1]).emit) logger = Logger(system="OpenBazaard") # NAT traversal port = args[2] PortMapper().add_port_mapping(port, port, 'UDP') logger.info("Finding NAT Type...") try: response = stun.get_ip_info(source_port=port) except Exception: response = stun.get_ip_info() logger.info("%s on %s:%s" % (response[0], response[1], response[2])) ip_address = response[1] port = response[2] # TODO: use TURN if symmetric NAT def on_bootstrap_complete(resp): logger.info("bootstrap complete, downloading outstanding messages...") mlistener = MessageListenerImpl(ws_factory, db) mserver.get_messages(mlistener) mserver.protocol.add_listener(mlistener) nlistener = NotificationListenerImpl(ws_factory, db) mserver.protocol.add_listener(nlistener) # TODO: ping seed node to establish connection if not full cone NAT # TODO: after bootstrap run through any pending contracts and see if the bitcoin address # has been funded, if not listen on the address and start the 10 minute delete timer. protocol = OpenBazaarProtocol((ip_address, port), testnet=TESTNET) # kademlia node = Node(keys.guid, ip_address, port, signed_pubkey=keys.guid_signed_pubkey, vendor=Profile(db).get().vendor) storage = ForgetfulStorage() if TESTNET else PersistentStorage(db.DATABASE) try: kserver = Server.loadState(DATA_FOLDER + 'cache.pickle', ip_address, port, protocol, db, on_bootstrap_complete, storage=storage) except Exception: kserver = Server(node, db, KSIZE, ALPHA, storage=storage) kserver.protocol.connect_multiplexer(protocol) kserver.bootstrap( kserver.querySeed("seed.openbazaar.org:8080", "5b44be5c18ced1bc9400fe5e79c8ab90204f06bebacc04dd9c70a95eaca6e117"))\ .addCallback(on_bootstrap_complete) # TODO: load seeds from config file kserver.saveStateRegularly(DATA_FOLDER + 'cache.pickle', 10) protocol.register_processor(kserver.protocol) # market mserver = network.Server(kserver, keys.signing_key, db) mserver.protocol.connect_multiplexer(protocol) protocol.register_processor(mserver.protocol) reactor.listenUDP(port, protocol) # websockets api ws_factory = WSFactory("ws://127.0.0.1:18466", mserver, kserver) ws_factory.protocol = WSProtocol ws_factory.setProtocolOptions(allowHixie76=True) listenWS(ws_factory) webdir = File(".") web = Site(webdir) reactor.listenTCP(9000, web, interface=args[4]) # rest api api = OpenBazaarAPI(mserver, kserver, protocol) site = Site(api, timeout=None) reactor.listenTCP(18469, site, interface=args[3]) # TODO: add optional SSL on rest and websocket servers # blockchain # TODO: listen on the libbitcoin heartbeat port instead fetching height def height_fetched(ec, height): # TODO: re-broadcast any unconfirmed txs in the db using height to find confirmation status logger.info("Libbitcoin server online") try: timeout.cancel() except Exception: pass def timeout(client): logger.critical("Libbitcoin server offline") client = None if TESTNET: libbitcoin_client = LibbitcoinClient( "tcp://libbitcoin2.openbazaar.org:9091") else: libbitcoin_client = LibbitcoinClient( "tcp://libbitcoin1.openbazaar.org:9091") # TODO: load libbitcoin server url from config file libbitcoin_client.fetch_last_height(height_fetched) timeout = reactor.callLater(7, timeout, libbitcoin_client) protocol.set_servers(ws_factory, libbitcoin_client) reactor.run()
def test_basic(): """ Test a simple one-to-one connection with WAMP pubsub. """ print('Running test_basic') # Awful (but simple) way of making sure handshake is complete handshake = deferLater(reactor, 0.5, lambda: None) # Ordering the things to do consumer_client_subscribe = handshake publisher_dispatch = Deferred() # All the events that should be triggered producer_pubsub_received = Deferred() consumer_pubsub_received = Deferred() class WampProducerServerProtocol(wamp.WampServerProtocol): def onSessionOpen(self): self.registerForPubSub('http://example.com/mytopic') publisher_dispatch.addCallback(lambda _: self.dispatch( 'http://example.com/mytopic', {'a': 'b'}, )) # This one shouldn't go through publisher_dispatch.addCallback(lambda _: self.dispatch( 'http://example.com/NOTmytopic', {'a': 'b'}, )) class WampProducerServerFactory(ProducerMixin, wamp.WampServerFactory): protocol = WampProducerServerProtocol class WampProducerClientProtocol(wamp.WampClientProtocol): def onSessionOpen(self): self.subscribe('http://example.com/mytopic', self.onEvent) def onEvent(self, topic, event): try: assert topic == 'http://example.com/mytopic' assert event == {'a': 'b'} producer_pubsub_received.callback(None) except: producer_pubsub_received.errback() class WampProducerClientFactory(wamp.WampClientFactory): protocol = WampProducerClientProtocol class WampConsumerServerProtocol(wamp.WampServerProtocol): def onSessionOpen(self): self.registerForPubSub('http://example.com/mytopic') class WampConsumerServerFactory(ConsumerMixin, wamp.WampServerFactory): protocol = WampConsumerServerProtocol class WampConsumerClientProtocol(wamp.WampClientProtocol): def onSessionOpen(self): consumer_client_subscribe.addCallback(lambda _: self.subscribe( 'http://example.com/mytopic', self.onEvent, )) consumer_client_subscribe.addCallback(lambda _: deferLater( reactor, 0.5, lambda: None)).chainDeferred(publisher_dispatch) def onEvent(self, topic, event): try: assert topic == 'http://example.com/mytopic' assert event == {'a': 'b'} consumer_pubsub_received.callback(None) except: consumer_pubsub_received.errback() class WampConsumerClientFactory(wamp.WampClientFactory): protocol = WampConsumerClientProtocol consumer = ConsumerServer('localhost', 19000) WampConsumerServerFactory.consumer = consumer producer = ProducerClient([ ('localhost', 19000), ]) WampProducerServerFactory.producer = producer listenWS(WampProducerServerFactory('ws://localhost:19001')) connectWS(WampProducerClientFactory('ws://localhost:19001')) consumer_server = WampConsumerServerFactory('ws://localhost:19002') listenWS(consumer_server) consumer.processor = consumer_server connectWS(WampConsumerClientFactory('ws://localhost:19002')) return DeferredList([ consumer_client_subscribe, publisher_dispatch, producer_pubsub_received, consumer_pubsub_received, ])
def listen(self): listenWS(self)
if __name__ == "__main__": from twisted.internet import reactor, ssl # if not os.path.exists('../db.sqlite'): # db.create_all() log.startLogging(sys.stdout) contextFactory = ssl.DefaultOpenSSLContextFactory('keys/server.key', 'keys/server.crt') # create a Twisted Web resource for our WebSocket server wsFactory = GxgServerFactory(u"wss://127.0.0.1:9000") wsResource = WebSocketResource(wsFactory) # create a Twisted Web WSGI resource for our Flask server wsgiResource = WSGIResource(reactor, reactor.getThreadPool(), app) # create a root resource serving everything via WSGI/Flask, but # the path "/ws" served by our WebSocket stuff rootResource = WSGIRootResource(wsgiResource, {b'ws': wsResource}) listenWS(wsFactory, contextFactory) # create a Twisted Web Site and run everything site = Site(rootResource) # reactor.listenSSL(9090, site, contextFactory) reactor.listenTCP(9090, site) reactor.run() #curl -i -X POST -H "Content-Type: application/json" -d '{"username":"******","password":"******"}' http://127.0.0.1:9090/api/users
class WampServerFactory(ConsumerMixin, ProducerMixin, wamp.WampServerFactory): protocol = WampServerProtocol if __name__ == '__main__': # import logging # logging.basicConfig(level=logging.INFO) from twisted.python import log import sys log.startLogging(sys.stderr) consumer = ConsumerServer('0.0.0.0', 19000) WampServerFactory.consumer = consumer producer = ProducerClient([]) WampServerFactory.producer = producer server = WampServerFactory('ws://localhost:9900') listenWS(server) consumer.processor = server discovery = consul.ConsulDiscovery( 'http://localhost:8500/', 'pubsubclub', producer, ) discovery.start() print('Starting...') reactor.run()
ws_host = "[::1]" ws_initial_url = "wss://{}:0".format(ws_host) print('Initial URL = "{}"'.format(ws_initial_url)) # factory = WebSocketServerFactory(u"wss://127.0.0.1:0") factory = WebSocketServerFactory(ws_initial_url) # by default, allowedOrigins is "*" and will work fine out of the # box, but we can do better and be more-explicit about what we # allow. We are serving the Web content on 8080, but our WebSocket # listener is on 9000 so the Origin sent by the browser will be # from port 8080... factory.setProtocolOptions(allowedOrigins=[ "https://127.0.0.1:8080", "https://localhost:8080", ]) factory.protocol = EchoServerProtocol listener = listenWS(factory, contextFactory, interface='::') # print('"wss://127.0.0.1:{}"'.format(listener.getHost().port)) ws_actual_url = "wss://{}:{}".format(ws_host, listener.getHost().port) print('Actual URL = "{}"'.format(ws_actual_url)) webdir = File(".") webdir.contentTypes['.crt'] = 'application/x-x509-ca-cert' web = Site(webdir) reactor.listenSSL(0, web, contextFactory) #reactor.listenTCP(8080, web) reactor.run()
##################################################################### if __name__ == '__main__': sensorlist, portdict, baudratedict = GetSensors() ## Start Twisted logging system ## #log.startLogging(sys.stdout) logfile = os.path.join(homedir, 'MARTAS', 'Logs', 'martas.log') log.startLogging(open(logfile, 'a')) ## create Serial2Ws gateway factory ## wsMcuFactory = WsMcuFactory(wsurl) listenWS(wsMcuFactory) ## create serial port and serial port protocol; modify this according to attached sensors ## for sensor in sensorlist: port = serialport + portdict[sensor] baudrate = baudratedict[sensor] if sensor[:3].upper() == 'LEM': protocol = wsMcuFactory.lemiProtocol if sensor[:3].upper() == 'POS': protocol = wsMcuFactory.pos1Protocol if sensor[:3].upper() == 'G82': protocol = wsMcuFactory.csProtocol if sensor[:3].upper() == 'GSM': protocol = wsMcuFactory.gsm90Protocol
def run(*args): TESTNET = args[0] LOGLEVEL = args[1] PORT = args[2] ALLOWIP = args[3] SSL = args[4] RESTPORT = args[5] WSPORT = args[6] # database db = Database(TESTNET) # key generation keys = KeyChain(db) # logging logFile = logfile.LogFile.fromFullPath(DATA_FOLDER + "debug.log", rotateLength=15000000, maxRotatedFiles=1) log.addObserver(FileLogObserver(logFile, level=LOGLEVEL).emit) log.addObserver(FileLogObserver(level=LOGLEVEL).emit) logger = Logger(system="OpenBazaard") # NAT traversal p = PortMapper() threading.Thread(target=p.add_port_mapping, args=(PORT, PORT, "UDP")).start() logger.info("Finding NAT Type...") while True: # sometimes the stun server returns a code the client # doesn't understand so we have to try again try: response = stun.get_ip_info(source_port=PORT) break except Exception: pass logger.info("%s on %s:%s" % (response[0], response[1], response[2])) nat_type = response[0] ip_address = response[1] port = response[2] # TODO: use TURN if symmetric NAT def on_bootstrap_complete(resp): logger.info("bootstrap complete") mserver.get_messages(mlistener) task.LoopingCall(check_unfunded_for_payment, db, libbitcoin_client, nlistener, TESTNET).start(600) protocol = OpenBazaarProtocol((ip_address, port), response[0], testnet=TESTNET) # kademlia node = Node(keys.guid, ip_address, port, signed_pubkey=keys.guid_signed_pubkey, vendor=Profile(db).get().vendor) storage = ForgetfulStorage() if TESTNET else PersistentStorage(db.DATABASE) try: kserver = Server.loadState(DATA_FOLDER + 'cache.pickle', ip_address, port, protocol, db, on_bootstrap_complete, storage=storage) except Exception: kserver = Server(node, db, KSIZE, ALPHA, storage=storage) kserver.protocol.connect_multiplexer(protocol) kserver.bootstrap(kserver.querySeed(SEED)).addCallback(on_bootstrap_complete) kserver.saveStateRegularly(DATA_FOLDER + 'cache.pickle', 10) protocol.register_processor(kserver.protocol) if nat_type != "Full Cone": kserver.protocol.ping(SEED_NODE_TESTNET if TESTNET else SEED_NODE) # market mserver = network.Server(kserver, keys.signing_key, db) mserver.protocol.connect_multiplexer(protocol) protocol.register_processor(mserver.protocol) reactor.listenUDP(port, protocol) class OnlyIP(Site): def __init__(self, resource, ip, timeout=60 * 60 * 1): self.ip = ip Site.__init__(self, resource, timeout=timeout) def buildProtocol(self, addr): if addr.host == self.ip: return Site.buildProtocol(self, addr) return None # websockets api if SSL: ws_factory = WSFactory("wss://127.0.0.1:" + str(WSPORT), mserver, kserver, only_ip=ALLOWIP) contextFactory = ChainedOpenSSLContextFactory(SSL_KEY, SSL_CERT) ws_factory.protocol = WSProtocol listenWS(ws_factory, contextFactory) else: ws_factory = WSFactory("ws://127.0.0.1:" + str(WSPORT), mserver, kserver, only_ip=ALLOWIP) ws_factory.protocol = WSProtocol listenWS(ws_factory) if ALLOWIP != "127.0.0.1" and ALLOWIP != "0.0.0.0": ws_interface = "0.0.0.0" else: ws_interface = ALLOWIP webdir = File(".") web = Site(webdir) reactor.listenTCP(WSPORT - 1, web, interface=ws_interface) # rest api api = OpenBazaarAPI(mserver, kserver, protocol) if ALLOWIP != "127.0.0.1" and ALLOWIP != "0.0.0.0": rest_interface = "0.0.0.0" site = OnlyIP(api, ALLOWIP, timeout=None) else: rest_interface = ALLOWIP site = Site(api, timeout=None) if SSL: reactor.listenSSL(RESTPORT, site, ChainedOpenSSLContextFactory(SSL_KEY, SSL_CERT), interface=rest_interface) else: reactor.listenTCP(RESTPORT, site, interface=rest_interface) # blockchain if TESTNET: libbitcoin_client = LibbitcoinClient(LIBBITCOIN_SERVER_TESTNET, log=Logger(service="LibbitcoinClient")) else: libbitcoin_client = LibbitcoinClient(LIBBITCOIN_SERVER, log=Logger(service="LibbitcoinClient")) # listeners nlistener = NotificationListenerImpl(ws_factory, db) mserver.protocol.add_listener(nlistener) mlistener = MessageListenerImpl(ws_factory, db) mserver.protocol.add_listener(mlistener) blistener = BroadcastListenerImpl(ws_factory, db) mserver.protocol.add_listener(blistener) protocol.set_servers(ws_factory, libbitcoin_client) logger.info("Startup took %s seconds" % str(round(time.time() - args[7], 2))) reactor.run()
kserver.saveStateRegularly(DATA_FOLDER + 'cache.pickle', 10) protocol.register_processor(kserver.protocol) # market mserver = network.Server(kserver, keys.signing_key) mserver.protocol.connect_multiplexer(protocol) protocol.register_processor(mserver.protocol) reactor.listenUDP(port, protocol) # json-rpc server factory = jsonrpc.RPCFactory(RPCCalls(kserver, mserver, keys)) reactor.listenTCP(18465, factory, interface="127.0.0.1") # web sockets ws_factory = WSFactory("ws://127.0.0.1:18466", mserver, kserver) ws_factory.protocol = WSProtocol ws_factory.setProtocolOptions(allowHixie76=True) listenWS(ws_factory) webdir = File(".") web = Site(webdir) reactor.listenTCP(9000, web, interface="127.0.0.1") # rest api api = OpenBazaarAPI(mserver, kserver) site = Site(api, timeout=None) reactor.listenTCP(18469, site, interface="127.0.0.1") reactor.run()
def start_server(self, url): server_factory = ServerFactory(url, self.engine, self.broadcaster) server_factory.protocol = ServerProtocol listenWS(server_factory)
settings_text = settings_text + "PASSWORD " addr = ws_type + "0.0.0.0" + ":" + str(port) # We start the websocket here factory = WebSocketServerFactory(addr) failed_start = False if secure: if os.path.isfile(ssl_dir + "/privkey.pem") and os.path.isfile(ssl_dir + "/cert.pem"): contextFactory = ssl.DefaultOpenSSLContextFactory( ssl_dir + '/privkey.pem', ssl_dir + '/cert.pem') listenWS(factory, contextFactory, interface=interface) else: print("[ERROR]: I can't find " + ssl_dir + "cert.pem" + " and/or " + ssl_dir + 'privkey.pem') failed_start = True else: listenWS(factory, interface=interface) if not failed_start: print("[" + name + "] " + "[INFO]: " + ws_type + server_ip + ":" + str(port) + " " + settings_text) factory.protocol = ArduinoServerProtocol # We listen to arduino message in a thread listener_thread = threading.Thread(target=start_listen)
def start(): websocket_factory = WebSocketServerFactory() websocket_factory.protocol = MyServerProtocol websocket_factory.port = 9000 listenWS(websocket_factory)
def run(self): def signal_handler(*args): logger.info('Received SIGTERM, shutting down.') logger.info("Stopping threads, please wait...") # teardown() self.raw_report_processor.stop() self.timer.stop() log_path = os.path.join(CONST_FARADAY_HOME_PATH, 'logs', 'access-logging.log') site = twisted.web.server.Site(self.__root_resource, logPath=log_path, logFormatter=proxiedLogFormatter) site.displayTracebacks = False if self.__ssl_enabled: ssl_context = self.__load_ssl_certs() self.__listen_func = functools.partial(reactor.listenSSL, contextFactory=ssl_context) else: self.__listen_func = reactor.listenTCP try: self.install_signal() # start threads and processes self.raw_report_processor = RawReportProcessor() self.raw_report_processor.start() self.timer = TimerClass() self.timer.start() # web and static content self.__listen_func(self.__listen_port, site, interface=self.__bind_address) # websockets if faraday.server.config.websocket_ssl.enabled: contextFactory = ssl.DefaultOpenSSLContextFactory( faraday.server.config.websocket_ssl.keyfile.strip('\''), faraday.server.config.websocket_ssl.certificate.strip( '\'')) try: listenWS(self.__build_websockets_resource(), interface=self.__bind_address, contextFactory=contextFactory) except error.CannotListenError: logger.warn( 'Could not start websockets, address already open. This is ok is you wan to run multiple instances.' ) except Exception as ex: logger.warn( 'Could not start websocket, error: {}'.format(ex)) else: try: listenWS(self.__build_websockets_resource(), interface=self.__bind_address) except error.CannotListenError: logger.warn( 'Could not start websockets, address already open. This is ok is you wan to run multiple instances.' ) except Exception as ex: logger.warn( 'Could not start websocket, error: {}'.format(ex)) logger.info('Faraday Server is ready') reactor.addSystemEventTrigger('before', 'shutdown', signal_handler) reactor.run() except error.CannotListenError as e: logger.error(str(e)) sys.exit(1) except Exception as e: logger.error( 'Something went wrong when trying to setup the Web UI') logger.exception(e) sys.exit(1)
def setup_finalize(event, application): import OpenSSL.SSL from twisted.application import internet from twisted.internet import reactor, ssl from twisted.python import log from twisted.web.server import Site from . import socket_transport from . import http_transport from . import websocket_transport from . import irc from .services import ServiceEventHandler from stratum import settings try: from . import signature signing_key = signature.load_privkey_pem(settings.SIGNING_KEY) except Exception: print( "Loading of signing key '%s' failed, protocol messages cannot be signed." % settings.SIGNING_KEY) signing_key = None # Attach HTTPS Poll Transport service to application try: sslContext = ssl.DefaultOpenSSLContextFactory(settings.SSL_PRIVKEY, settings.SSL_CACERT) except OpenSSL.SSL.Error: sslContext = None print( 'Cannot initiate SSL context, are SSL_PRIVKEY or SSL_CACERT missing?' ) print('This will skip all SSL-based transports.') # Set up thread pool size for service threads reactor.suggestThreadPoolSize(settings.THREAD_POOL_SIZE) if settings.LISTEN_SOCKET_TRANSPORT: # Attach Socket Transport service to application socket = internet.TCPServer( settings.LISTEN_SOCKET_TRANSPORT, socket_transport.SocketTransportFactory( debug=settings.DEBUG, signing_key=signing_key, signing_id=settings.SIGNING_ID, event_handler=ServiceEventHandler, tcp_proxy_protocol_enable=settings.TCP_PROXY_PROTOCOL, ), ) socket.setServiceParent(application) # Build the HTTP interface httpsite = Site( http_transport.Root( debug=settings.DEBUG, signing_key=signing_key, signing_id=settings.SIGNING_ID, event_handler=ServiceEventHandler, ), ) httpsite.sessionFactory = http_transport.HttpSession if settings.LISTEN_HTTP_TRANSPORT: # Attach HTTP Poll Transport service to application http = internet.TCPServer(settings.LISTEN_HTTP_TRANSPORT, httpsite) http.setServiceParent(application) if settings.LISTEN_HTTPS_TRANSPORT and sslContext: https = internet.SSLServer(settings.LISTEN_HTTPS_TRANSPORT, httpsite, contextFactory=sslContext) https.setServiceParent(application) if settings.LISTEN_WS_TRANSPORT: from autobahn.twisted.websocket import listenWS log.msg("Starting WS transport on %d" % settings.LISTEN_WS_TRANSPORT) ws = websocket_transport.WebsocketTransportFactory( settings.LISTEN_WS_TRANSPORT, debug=settings.DEBUG, signing_key=signing_key, signing_id=settings.SIGNING_ID, event_handler=ServiceEventHandler, ) listenWS(ws) if settings.LISTEN_WSS_TRANSPORT and sslContext: from autobahn.twisted.websocket import listenWS log.msg("Starting WSS transport on %d" % settings.LISTEN_WSS_TRANSPORT) wss = websocket_transport.WebsocketTransportFactory( settings.LISTEN_WSS_TRANSPORT, is_secure=True, debug=settings.DEBUG, signing_key=signing_key, signing_id=settings.SIGNING_ID, event_handler=ServiceEventHandler, ) listenWS(wss, contextFactory=sslContext) if settings.IRC_NICK: reactor.connectTCP( settings.IRC_SERVER, settings.IRC_PORT, irc.IrcLurkerFactory( settings.IRC_ROOM, settings.IRC_NICK, settings.IRC_HOSTNAME, )) return event
self.factory.unregister(self) print("Connection to client closed!") class BroadcastServerFactory(WebSocketServerFactory): """ Simple broadcast server broadcasting any message it receives to all currently connected clients. """ protocol = BroadcastServerProtocol def __init__(self, url): WebSocketServerFactory.__init__(self, url) self.client = None def register(self, client): self.client = client def unregister(self, client): self.client = None def post(self, msg): self.client.sendMessage(msg.encode("UTF8")) if __name__ == '__main__': log.startLogging(sys.stdout) ServerFactory = BroadcastServerFactory(address) listenWS(ServerFactory) reactor.run()
def run(self): def signal_handler(*args): logger.info('Received SIGTERM, shutting down.') logger.info("Stopping threads, please wait...") # teardown() if self.raw_report_processor.isAlive(): self.raw_report_processor.stop() self.ping_home_thread.stop() log_path = CONST_FARADAY_HOME_PATH / 'logs' / 'access-logging.log' site = twisted.web.server.Site(self.__root_resource, logPath=log_path, logFormatter=proxiedLogFormatter) site.displayTracebacks = False if self.__ssl_enabled: ssl_context = self.__load_ssl_certs() self.__listen_func = functools.partial(reactor.listenSSL, contextFactory=ssl_context) else: self.__listen_func = reactor.listenTCP try: self.install_signal() # start threads and processes self.raw_report_processor = ReportsManager( REPORTS_QUEUE, name="ReportsManager-Thread", daemon=True) self.raw_report_processor.start() self.ping_home_thread = PingHomeThread() self.ping_home_thread.start() # web and static content self.__listen_func(self.__listen_port, site, interface=self.__bind_address) # websockets if faraday.server.config.websocket_ssl.enabled: try: contextFactory = ssl.DefaultOpenSSLContextFactory( faraday.server.config.websocket_ssl.keyfile.strip( '\''), faraday.server.config.websocket_ssl.certificate.strip( '\'')) listenWS(self.__build_websockets_resource(), interface=self.__bind_address, contextFactory=contextFactory) except SSLError as e: logger.error( 'Could not start websockets due to a SSL Config error. Some web functionality will not be available' ) except error.CannotListenError: logger.warn( 'Could not start websockets, address already open. This is ok is you wan to run multiple instances.' ) except Exception as ex: logger.warn(f'Could not start websocket, error: {ex}') else: try: listenWS(self.__build_websockets_resource(), interface=self.__bind_address) except error.CannotListenError: logger.warn( 'Could not start websockets, address already open. This is ok is you wan to run multiple instances.' ) except Exception as ex: logger.warn(f'Could not start websocket, error: {ex}') logger.info('Faraday Server is ready') reactor.addSystemEventTrigger('before', 'shutdown', signal_handler) reactor.run() except error.CannotListenError as e: logger.error(e) sys.exit(1) except Exception as e: logger.exception( 'Something went wrong when trying to setup the Web UI') sys.exit(1)
def run(*args): TESTNET = args[0] # database db = Database(TESTNET) # key generation keys = KeyChain(db) # logging # TODO: prune this log file and prevent it from getting too large? logFile = logfile.LogFile.fromFullPath(DATA_FOLDER + "debug.log") log.addObserver(log.FileLogObserver(logFile).emit) log.startLogging(sys.stdout) # stun # TODO: accept port from command line port = 18467 if not TESTNET else 28467 print "Finding NAT Type.." # TODO: maintain a list of backup STUN servers and try them if ours fails response = stun.get_ip_info(stun_host="seed.openbazaar.org", source_port=port) print "%s on %s:%s" % (response[0], response[1], response[2]) ip_address = response[1] port = response[2] # TODO: try UPnP if restricted NAT # TODO: maintain open connection to seed node if STUN/UPnP fail # TODO: use TURN if symmetric NAT def on_bootstrap_complete(resp): mlistener = MessageListenerImpl(ws_factory, db) mserver.get_messages(mlistener) mserver.protocol.add_listener(mlistener) nlistener = NotificationListenerImpl(ws_factory, db) mserver.protocol.add_listener(nlistener) protocol = OpenBazaarProtocol((ip_address, port), testnet=TESTNET) # kademlia node = Node(keys.guid, ip_address, port, signed_pubkey=keys.guid_signed_pubkey) try: kserver = Server.loadState(DATA_FOLDER + 'cache.pickle', ip_address, port, protocol, db, on_bootstrap_complete, storage=PersistentStorage(db.DATABASE)) except Exception: kserver = Server(node, db, KSIZE, ALPHA, storage=PersistentStorage(db.DATABASE)) kserver.protocol.connect_multiplexer(protocol) kserver.bootstrap( kserver.querySeed("seed.openbazaar.org:8080", "ddd862778e3ed71af06db0e3619a4c6269ec7468c745132dbb73982b319fc572"))\ .addCallback(on_bootstrap_complete) # TODO: load seeds from config file kserver.saveStateRegularly(DATA_FOLDER + 'cache.pickle', 10) protocol.register_processor(kserver.protocol) # market mserver = network.Server(kserver, keys.signing_key, db) mserver.protocol.connect_multiplexer(protocol) protocol.register_processor(mserver.protocol) reactor.listenUDP(port, protocol) # websockets api ws_factory = WSFactory("ws://127.0.0.1:18466", mserver, kserver) ws_factory.protocol = WSProtocol ws_factory.setProtocolOptions(allowHixie76=True) listenWS(ws_factory) webdir = File(".") web = Site(webdir) reactor.listenTCP(9000, web, interface="127.0.0.1") # rest api api = OpenBazaarAPI(mserver, kserver, protocol) site = Site(api, timeout=None) reactor.listenTCP(18469, site, interface="127.0.0.1") # TODO: add optional SSL on rest and websocket servers # blockchain # TODO: listen on the libbitcoin heartbeat port instead fetching height def height_fetched(ec, height): print "Libbitcoin server online" try: timeout.cancel() except Exception: pass def timeout(client): print "Libbitcoin server offline" client = None if TESTNET: libbitcoin_client = obelisk.ObeliskOfLightClient( "tcp://libbitcoin2.openbazaar.org:9091") else: libbitcoin_client = obelisk.ObeliskOfLightClient( "tcp://libbitcoin1.openbazaar.org:9091") # TODO: load libbitcoin server url from config file libbitcoin_client.fetch_last_height(height_fetched) timeout = reactor.callLater(5, timeout, libbitcoin_client) protocol.set_servers(ws_factory, libbitcoin_client) reactor.run()
if __name__ == '__main__': if len(sys.argv) > 1 and sys.argv[1] == 'debug': log.startLogging(sys.stdout) debug = True else: debug = False # SSL server context: load server key and certificate # We use this for both WS and Web! # contextFactory = ssl.DefaultOpenSSLContextFactory('keys/server.key', 'keys/server.crt') factory = WebSocketServerFactory("wss://localhost:9000", debug=debug, debugCodePaths=debug) factory.protocol = EchoServerProtocol factory.setProtocolOptions(allowHixie76=True) listenWS(factory, contextFactory) webdir = File(".") webdir.contentTypes['.crt'] = 'application/x-x509-ca-cert' web = Site(webdir) # reactor.listenSSL(8080, web, contextFactory) reactor.listenTCP(8080, web) reactor.run()
class BroadcastPreparedServerFactory(BroadcastServerFactory): """ Functionally same as above, but optimized broadcast using prepareMessage and sendPreparedMessage. """ def broadcast(self, msg): print("broadcasting prepared message '{}' ..".format(msg)) preparedMsg = self.prepareMessage(msg) for c in self.clients: c.sendPreparedMessage(preparedMsg) print("prepared message sent to {}".format(c.peer)) if __name__ == '__main__': log.startLogging(sys.stdout) ServerFactory = BroadcastServerFactory # ServerFactory = BroadcastPreparedServerFactory factory = ServerFactory(u"ws://127.0.0.1:9000") factory.protocol = BroadcastServerProtocol listenWS(factory) webdir = File(".") web = Site(webdir) reactor.listenTCP(8080, web) reactor.run()
def test_connect_replay(): """ Test that when a producer connects, the consumer sends all existing subscription to it. """ print('Running test_connect_replay') handshake = deferLater(reactor, 0.5, lambda: None) producer_connect = handshake publisher_dispatch = Deferred() # Events that should be triggered producer_pubsub_received = Deferred() client1_pubsub_received = Deferred() client2_pubsub_received = Deferred() class WampProducerServerProtocol(wamp.WampServerProtocol): def onSessionOpen(self): self.registerForPubSub('http://example.com/mytopic') publisher_dispatch.addCallback(lambda _: self.dispatch( 'http://example.com/mytopic', {'a': 'b'}, )) class WampProducerServerFactory(ProducerMixin, wamp.WampServerFactory): protocol = WampProducerServerProtocol class WampProducerClientProtocol(wamp.WampClientProtocol): def onSessionOpen(self): self.subscribe('http://example.com/mytopic', self.onEvent) def onEvent(self, topic, event): try: assert topic == 'http://example.com/mytopic' assert event == {'a': 'b'} producer_pubsub_received.callback(None) except: producer_pubsub_received.errback() class WampProducerClientFactory(wamp.WampClientFactory): protocol = WampProducerClientProtocol class WampConsumerServerProtocol(wamp.WampServerProtocol): def onSessionOpen(self): self.registerForPubSub('http://example.com/mytopic') class WampConsumerServerFactory(ConsumerMixin, wamp.WampServerFactory): protocol = WampConsumerServerProtocol class WampConsumerClient1Protocol(wamp.WampClientProtocol): def onSessionOpen(self): self.subscribe('http://example.com/mytopic', self.onEvent) self.subscribe('http://example.com/mytopic2', self.onEvent) def onEvent(self, topic, event): try: assert topic == 'http://example.com/mytopic' assert event == {'a': 'b'} client1_pubsub_received.callback(None) except: client1_pubsub_received.errback() class WampConsumerClient1Factory(wamp.WampClientFactory): protocol = WampConsumerClient1Protocol class WampConsumerClient2Protocol(wamp.WampClientProtocol): def onSessionOpen(self): self.subscribe('http://example.com/mytopic', self.onEvent) def onEvent(self, topic, event): try: assert topic == 'http://example.com/mytopic' assert event == {'a': 'b'} client2_pubsub_received.callback(None) except: client2_pubsub_received.errback() class WampConsumerClient2Factory(wamp.WampClientFactory): protocol = WampConsumerClient2Protocol consumer = ConsumerServer('localhost', 19100) WampConsumerServerFactory.consumer = consumer producer = ProducerClient([]) WampProducerServerFactory.producer = producer producer_connect.addCallback( lambda _: producer.connect('localhost', 19100)) producer_connect.addCallback( lambda _: deferLater(reactor, 0.5, lambda: None), ).chainDeferred( publisher_dispatch) listenWS(WampProducerServerFactory('ws://localhost:19101')) connectWS(WampProducerClientFactory('ws://localhost:19101')) consumer_server = WampConsumerServerFactory('ws://localhost:19102') listenWS(consumer_server) consumer.processor = consumer_server connectWS(WampConsumerClient1Factory('ws://localhost:19102')) connectWS(WampConsumerClient2Factory('ws://localhost:19102')) return DeferredList([ producer_pubsub_received, client1_pubsub_received, client2_pubsub_received, ])