def start(self): cherrypy.config.update({ 'server.socket_port': self.port, 'server.socket_host': '0.0.0.0' # Can be reached from everywhere }) # Add the SceneManagerPlugin to the server bus MatchManagerPlugin(cherrypy.engine).subscribe() cherrypy.tools.websocket = WebSocketTool() cherrypy.tree.mount(GoMenu(), '/', self._menu_conf) # cherrypy.tree.mount( # GoMatchDispatcher(), '/match', self._match_conf # ) cherrypy.tree.mount(WebSocketAPI(), '/websocket', self._websocket_conf) # cherrypy.tree.mount( # GoMenuApi(), '/api', self._menu_api_conf # ) # Start the server cherrypy.engine.start() cherrypy.engine.block() return None
def _configure_server(restarting=False): global websocket_plugin # Configure server error log cherrypy.config.update({'log.error_file': 'cherrypy.error.log'}) # Configure server url cherrypy.config.update({'server.socket_host': utils.s2n(autosubliminal.WEBSERVERIP), 'server.socket_port': int(autosubliminal.WEBSERVERPORT) }) # Disable engine plugins (no need for autoreload plugin) cherrypy.config.update({'engine.autoreload.on': False}) # Configure authentication in if a username and password is set by the user if autosubliminal.USERNAME and autosubliminal.PASSWORD: users = {utils.s2n(autosubliminal.USERNAME): utils.s2n(autosubliminal.PASSWORD)} cherrypy.config.update({'tools.auth_digest.on': True, 'tools.auth_digest.realm': 'Auto-Subliminal website', 'tools.auth_digest.get_ha1': auth_digest.get_ha1_dict_plain(users), 'tools.auth_digest.key': 'yek.tsegid_htua.lanimilbuS-otuA' # Can be any random string }) if not restarting: # Enable websocket plugin websocket_plugin = WebSocketPlugin(cherrypy.engine) websocket_plugin.subscribe() cherrypy.tools.websocket = WebSocketTool() else: # When restarting we need to create a new websocket manager thread (you cannot start the same thread twice!) websocket_plugin.manager = WebSocketManager() # When restarting we need to clear the httpserver to force the creation of a new one (needed for ip/port change) cherrypy.server.httpserver = None
def upgrade(self, **kwargs): try: kwargs["handler_cls"].check_authentication() except: raise cherrypy.HTTPError(401, "You must be logged in to establish a websocket connection.") else: return WebSocketTool.upgrade(self, **kwargs)
def run(): global root root = Lobby() WebSocketPlugin(cherrypy.engine).subscribe() cherrypy.tools.websocket = WebSocketTool() # This doesn't work for some reason - #wsconfig = {'/': {'tools.websocket.on': True, # 'tools.websocket.handler_cls': EWS}} #cherrypy.tree.mount(root, '/ws', wsconfig) cherrypy.server.shutdown_timeout = 0 #cherrypy.quickstart(root, '/', 'cpconfig') cherrypy.server.socket_port = config.SERVER_PORT cherrypy.server.socket_host = config.SERVER_IP cherrypy.config.update({'tools.sessions.on': True, 'tools.staticdir.root': config.ASSETS_PATH}) cherrypy.quickstart(root, '/', { '/ws': { 'tools.websocket.on': True, 'tools.websocket.handler_cls': EWS}, '/play_ws': { 'tools.websocket.on': True, 'tools.websocket.handler_cls': GameWS}, '/scripts': { 'tools.staticdir.on': True, 'tools.staticdir.dir': 'scripts'}, '/img': { 'tools.staticdir.on': True, 'tools.staticdir.dir': 'img'}})
def __init__(self, port, address, telemetry, waypoint_generator): super(CherryPyServer, self).__init__() self.name = self.__class__.__name__ # Web monitor config = MonitorApp.get_config(os.path.abspath(os.getcwd())) status_app = cherrypy.tree.mount( MonitorApp(telemetry, waypoint_generator, port), '/', config ) cherrypy.config.update({ 'server.socket_host': address, 'server.socket_port': port, 'server.ssl_module': 'builtin', 'server.ssl_certificate': 'control/web_telemetry/cert.pem', 'server.ssl_private_key': 'control/web_telemetry/key.pem', 'engine.autoreload.on': False, }) WebSocketPlugin(cherrypy.engine).subscribe() cherrypy.tools.websocket = WebSocketTool() # Web telemetry config = WebTelemetryStatusApp.get_config(os.path.abspath(os.getcwd())) web_telemetry_app = cherrypy.tree.mount( WebTelemetryStatusApp(telemetry, port), '/telemetry', config ) # OMG, shut up CherryPy, nobody cares about your problems for app in (status_app, web_telemetry_app, cherrypy): app.log.access_log.setLevel(logging.ERROR) app.log.error_log.setLevel(logging.ERROR)
def main(): cherrypy.config.update({ 'server.socket_port': 27900, 'request.show_tracebacks': True, }) WebSocketPlugin(cherrypy.engine).subscribe() cherrypy.tools.websocket = WebSocketTool() curr_folder = str(Path(__file__).parent.absolute()) Daemon(cherrypy.engine).subscribe() config = { '/': { 'tools.staticdir.root': curr_folder, }, '/public': { 'tools.staticdir.on': True, 'tools.staticdir.dir': 'public', }, '/ws': { 'tools.websocket.on': True, 'tools.websocket.handler_cls': WSHandler, }, } cherrypy.quickstart(Detour(curr_folder + '/public'), '/', config)
def run_cherrypy_server(host="127.0.0.1", port=9008): """ Runs a CherryPy server on Python 2.x. """ import cherrypy from ws4py.server.cherrypyserver import WebSocketPlugin, WebSocketTool from ws4py.websocket import EchoWebSocket cherrypy.config.update({ 'server.socket_host': host, 'server.socket_port': port, 'engine.autoreload.on': False, 'log.screen': False }) WebSocketPlugin(cherrypy.engine).subscribe() cherrypy.tools.websocket = WebSocketTool() class Root(object): @cherrypy.expose def index(self): pass config = { '/': { 'tools.encode.on': False, 'tools.websocket.on': True, 'tools.websocket.handler_cls': EchoWebSocket } } logger = logging.getLogger('autobahn_testsuite') logger.warning("Serving CherryPy server on %s:%s" % (host, port)) cherrypy.quickstart(Root(), '/', config)
def run(): # Registering different API versions app.register_blueprint(api_v1, url_prefix="/v1") app.config.update(PROPAGATE_EXCEPTIONS = True) # Update config and register the websocket plugin cherrypy.config.update({ 'server.socket_port': config.bind_port, 'server.socket_host': config.bind_host }) WebSocketPlugin(cherrypy.engine).subscribe() cherrypy.tools.websocket = WebSocketTool() # Register flask as wsgi callable in cherrypy cherrypy.tree.graft(app, '/') # Register WebSocket cherrypy.tree.mount(websocket_root, '/ws', config={'/': {'tools.websocket.on': True, 'tools.websocket.handler_cls': WebSocketMessagePublisher } } ) if os.path.isfile("cert.pem") and os.path.isfile("privatekey.pem"): cherrypy.server.ssl_module = "builtin" cherrypy.server.ssl_certificate = "cert.pem" cherrypy.server.ssl_private_key = "privatekey.pem" # Start cherrypy cherrypy.engine.start() cherrypy.engine.block()
def start(self): self._running = True cherrypy.config.update({ 'server.socket_port': self.port, 'server.socket_host': '0.0.0.0', 'engine.autoreload.on': False, 'log.screen': False, 'environment': 'production' }) self.plugin = DeployerWebSocketPlugin(cherrypy.engine, self) self.plugin.subscribe() cherrypy.tools.websocket = WebSocketTool() class Root(object): @cherrypy.expose def index(self): pass app = cherrypy.tree.mount(Root(), '/', config={'/': { 'tools.websocket.on': True, 'tools.websocket.handler_cls': DeployerWebSocket }}) # CherryPy forces a log level for some reason # let's undo that app.log.error_log.setLevel(NOTSET) app.log.access_log.setLevel(NOTSET) cherrypy.engine.start() while self._running: time.sleep(2)
def main(): #cherrypy.config.update({'error_page.404': error_page_404}) cherrypy.config.update('webapiner.ini') print cherrypy.__version__ core = AppCore() WebSocketPlugin(cherrypy.engine).subscribe() cherrypy.engine.json_rpc = JSONRPCHanlder(cherrypy.engine, core) cherrypy.engine.json_rpc.subscribe() cherrypy.tools.websocket = WebSocketTool() http_conf = {'/': {'tools.staticdir.on': False}} rest_conf = { '/': { 'request.dispatch': cherrypy.dispatch.MethodDispatcher() } } cherrypy.tree.mount(RESTHandler(), "/api/REST/", config=rest_conf) cherrypy.tree.mount(HTTPHandler(), "/api/HTTP/", config=http_conf) PIDFile(cherrypy.engine, os.path.join(current_dir, "webapiner.pid")).subscribe() cherrypy.engine.subscribe("start", core.inito) cherrypy.engine.subscribe("stop", core.destroy) cherrypy.quickstart(Root(), '/', 'webapiner.ini')
def __init__(self): super(Server, self).__init__() mimetypes.init() port = 80 if os.getuid() == 0 else 8080 cherrypy.config.update({ 'server.socket_host': '::', 'server.socket_port': port, 'tools.sessions.on': True, 'tools.sessions.timeout': 60, 'tools.sessions.httponly': True, }) cherrypy.tree.mount(RequestHandler(self.context), '', config={ '/ws': { 'tools.websocket.on': True, 'tools.websocket.handler_cls': WebSocketHandler } }) cherrypy.engine.autoreload.unsubscribe() WebSocketPlugin(cherrypy.engine).subscribe() cherrypy.tools.websocket = WebSocketTool() cherrypy.engine.start() Application().registerShutdown(self.stop)
def main(): from ws4py import configure_logger configure_logger(level=logging.DEBUG) parser = argparse.ArgumentParser(description='OpenDerby CherryPy Server') parser.add_argument('--host', default='0.0.0.0') parser.add_argument('-p', '--port', default=9000, type=int) parser.add_argument('--ssl', action='store_true') args = parser.parse_args() cherrypy.config.update({ 'server.socket_host': args.host, 'server.socket_port': args.port, 'tools.staticdir.root': os.path.abspath(os.path.join(os.path.dirname(__file__), 'static')) }) if args.ssl: cherrypy.config.update({ 'server.ssl_certificate': './server.crt', 'server.ssl_private_key': './server.key' }) # Setup WebSockets for the scoreboard WebSocketPlugin(cherrypy.engine).subscribe() cherrypy.tools.websocket = WebSocketTool() # Database setup SAEnginePlugin(cherrypy.engine).subscribe() cherrypy.tools.db = SATool() cherrypy.tree.mount(Derby(args.host, args.port, args.ssl), '', config={ '/': { 'tools.db.on': True, 'tools.caching.on': False, }, '/ws': { 'tools.websocket.on': True, 'tools.websocket.handler_cls': WebSocketHandler }, '/js': { 'tools.staticdir.on': True, 'tools.staticdir.dir': 'js' } }) # Use Flask for the Admin from openderby.registration import app from openderby import models cherrypy.tree.graft(app, '/registration') # Start up CherryPy cherrypy.engine.start() cherrypy.engine.block()
def upgrade(self, **kwargs): try: kwargs['handler_cls'].check_authentication() except: raise cherrypy.HTTPError( 401, 'You must be logged in to establish a websocket connection.') else: return WebSocketTool.upgrade(self, **kwargs)
def run_server(): default_ip = get_default_ip() parser = argparse.ArgumentParser( description='Serve a domsocket application.') parser.add_argument( '--server_ip', '-s', dest='server_ip', default=default_ip, help='the ip address where the zmq domsocket app is listening') parser.add_argument( '--zmq_bind_ip', '-i', dest='zmq_bind_ip', default='127.0.0.1', help='the ip address where the zmq domsocket app is listening') parser.add_argument('--server_port', '-p', dest='web_port', default=8443, help='the port for the web server to listen') parser.add_argument('--zmq_port', '-z', dest='zmq_port', default=5555, help='the port for the zmq backend to listen') parser.add_argument( '-v', '--verbose', dest='verbose', action='store_true', help= 'Turn on message debugging (which makes the server seem less responsive' ) args = parser.parse_args() app_websocket.parsed_args = args config_server_openssl(args.server_ip) WebSocketPlugin(cherrypy.engine).subscribe() cherrypy.tools.websocket = WebSocketTool() cherrypy.engine.subscribe('stop', shutdown) server_info = ServerInfo(args) backend = init_backend(args) backend.start() root_factory = RootFactory(server_info) root = root_factory.create_root() root_conf = root_factory.get_conf() try: cherrypy.quickstart(root, '/', config=root_conf) finally: logging.info('finally clause kicked out of cherrypy.quickstart')
def start(): WebSocketPlugin(cherrypy.engine).subscribe() cherrypy.tools.websocket = WebSocketTool() config = { '/': { 'tools.websocket.on': True, 'tools.websocket.handler_cls': NWebSocket, } } cherrypy.tree.mount(WS_API(), '/ws', config=config)
def upgrade(self, **kwargs): try: kwargs['handler_cls'].check_authentication() except WebSocketAuthError: raise cherrypy.HTTPError(401, 'You must be logged in to establish a websocket connection.') except: log.error('unexpected websocket authentication error', exc_info=True) raise cherrypy.HTTPError(401, 'unexpected authentication error') else: return WebSocketTool.upgrade(self, **kwargs)
def extend_server_configuration(cls, engine, config): """Extend the server configuration.""" cp_plugin = WebSocketPlugin(engine) cp_plugin.subscribe() cherrypy.tools.websocket = WebSocketTool() for handler in cls.handlers: config.update({ handler.ws_point: { 'tools.websocket.on': True, 'tools.websocket.handler_cls': handler, }, })
def upgrade(self, **kwargs): try: kwargs['handler_cls'].check_authentication() except WebSocketAuthError: raise cherrypy.HTTPError( 401, 'You must be logged in to establish a websocket connection.') except: log.error('unexpected websocket authentication error', exc_info=True) raise cherrypy.HTTPError(401, 'unexpected authentication error') else: return WebSocketTool.upgrade(self, **kwargs)
def load(info): info['zmqplugin'] = ZMQPlugin(cherrypy.engine) WebSocketPlugin(cherrypy.engine).subscribe() cherrypy.tools.websocket = WebSocketTool() info['apiRoot'].ws = WebSocketAPIEndpoint() cherrypy.config.update({ '/ws': { 'tools.websocket.on': True, 'tools.websocket.handler_cls': EchoWebSocket } })
def StartAgent(trainer=None, port=8765): global workout workout = trainer cherrypy.config.update({'server.socket_port': port}) WebSocketPlugin(cherrypy.engine).subscribe() cherrypy.tools.websocket = WebSocketTool() cherrypy.config.update({'engine.autoreload.on': False}) config = { '/ws': { 'tools.websocket.on': True, 'tools.websocket.handler_cls': AgentServer } } cherrypy.quickstart(Root(), '/', config)
def start(ipaddr='0.0.0.0', ws_handler=WingbotLocalMsgParse): cherrypy.config.update({ 'server.socket_host': ipaddr, 'server.socket_port': 19002 }) WebSocketPlugin(cherrypy.engine).subscribe() cherrypy.tools.websocket = WebSocketTool() cherrypy.quickstart(WingbotServer(), '/', config={ '/ws': { 'tools.websocket.on': True, 'tools.websocket.handler_cls': ws_handler } })
def __init__(self, host, port, **kwargs): super(self.__class__, self).__init__() self.daemon = True self.host = host self.port = port self.root_config = None self.css_config = None cherrypy.config.update({'server.socket_port': int(self.port), 'server.socket_host': self.host, 'engine.autoreload.on': False}) self.websocket = WebChatPlugin(cherrypy.engine) self.websocket.subscribe() cherrypy.tools.websocket = WebSocketTool()
def _configure_server(restarting=False): global websocket_plugin # Configure server error log cherrypy.config.update({'log.error_file': 'cherrypy.error.log'}) # Configure server url cherrypy.config.update({ 'server.socket_host': s2n(autosubliminal.WEBSERVERIP), 'server.socket_port': int(autosubliminal.WEBSERVERPORT) }) # Disable engine plugins (no need for autoreload plugin) cherrypy.config.update({'engine.autoreload.on': False}) # Read and store cherrypy server version (if not set, it returns CherryPy/Unknown because it's not installed) server_header = 'CherryPy/%s' % get_library_version('cherrypy') cherrypy.config.update({'response.headers.server': server_header}) # Configure authentication in if a username and password is set by the user if autosubliminal.USERNAME and autosubliminal.PASSWORD: users = {s2n(autosubliminal.USERNAME): s2n(autosubliminal.PASSWORD)} cherrypy.config.update({ 'tools.auth_digest.on': True, 'tools.auth_digest.realm': 'Auto-Subliminal website', 'tools.auth_digest.get_ha1': auth_digest.get_ha1_dict_plain(users), 'tools.auth_digest.key': 'yek.tsegid_htua.lanimilbuS-otuA' # Can be any random string }) # Configure our custom json_out_handler (Uncomment if it should be used for any @cherrypy.tools.json_out()) # cherrypy.config.update({'tools.json_out.handler': json_out_handler}) if not restarting: # Enable websocket plugin websocket_plugin = WebSocketPlugin(cherrypy.engine) websocket_plugin.subscribe() cherrypy.tools.websocket = WebSocketTool() else: # When restarting we need to create a new websocket manager thread (you cannot start the same thread twice!) websocket_plugin.manager = WebSocketManager() # When restarting we need to clear the httpserver to force the creation of a new one (needed for ip/port change) cherrypy.server.httpserver = None
def __init__(self): self._host = c.conf.YAPT.WebUiAddress self._port = int(c.conf.YAPT.WebUiPort) self._scheme = 'ws' Plugin(cherrypy.engine).subscribe() AMQP(cherrypy.engine).subscribe() cherrypy.tools.websocket = WebSocketTool() yapt_server = Server() yapt_server.socket_host = self._host yapt_server.socket_port = self._port yapt_server.max_request_body_size = 838860800 yapt_server.subscribe()
def __init__(self, host, port, root_folder, **kwargs): super(self.__class__, self).__init__() self.daemon = True self.host = host self.port = port self.root_folder = root_folder self.style = kwargs.pop('style') self.settings = kwargs.pop('settings') cherrypy.config.update({ 'server.socket_port': int(self.port), 'server.socket_host': self.host, 'engine.autoreload.on': False }) WebChatPlugin(cherrypy.engine).subscribe() cherrypy.tools.websocket = WebSocketTool()
def setup_engine(): # we don't need a HTTP server for this test cherrypy.server.unsubscribe() cherrypy.config.update({'log.screen': False}) cherrypy.engine.websocket = WebSocketPlugin(cherrypy.engine) cherrypy.engine.websocket.subscribe() cherrypy.engine.websocket.manager.poller = FakePoller() cherrypy.tools.websocket = WebSocketTool() config={'/ws': {'tools.websocket.on': True, 'tools.websocket.handler_cls': EchoWebSocket}} cherrypy.tree.mount(App(), '/', config) cherrypy.engine.start()
def webserver(app): # init logger for webserver modules loggerws4py = logging.getLogger('ws4py') loggerws4py.setLevel(app.config.get('LOGLEVEL', logging.ERROR)) loggercherry = logging.getLogger('cherrypy') loggercherry.setLevel(app.config.get('LOGLEVEL', logging.ERROR)) loggercherry = logging.getLogger('cherrypy.error') loggercherry.setLevel(app.config.get('LOGLEVEL', logging.ERROR)) cherrypy.server.unsubscribe() cherrypy.tree.graft(app, '/') if app.config.get('service', False): # log to file if used as service cherrypy.config.update({ 'log.error_file': '{}/service.log'.format(app.config.get('PATH_DATA')), 'log.screen': False }) cherrypy.config.update({ 'engine.autoreload.on': False, 'engine.SIGHUP': None, 'engine.SIGTERM': None, 'environment': 'embedded' }) cherrypy.server.thread_pool = app.config.get('SERVER_THREADS', 30) cherrypy.server.thread_pool_max = 20 cherrypy.server.socket_port = int(app.config.get('PORT')) cherrypy.server.socket_host = "0.0.0.0" cherrypy.log.screen = False WebSocketPlugin(cherrypy.engine).subscribe() cherrypy.tools.websocket = WebSocketTool() cherrypy.tree.mount(Root(), '/ws', config={ '/': { 'tools.websocket.on': True, 'tools.trailing_slash.on': False, 'tools.websocket.handler_cls': SocketHandler } }) cherrypy.server.subscribe() # Start the CherryPy WSGI web server cherrypy.engine.start() cherrypy.engine.block()
def main(port, version, queue): # sys.stdout = open('stdfile.txt', 'w') # sys.stderr = open('errfile.txt', 'w') # try: cherrypy.config.update({ 'server.socket_port': port, 'log.access_file': 'access.txt' }) WebSocketPlugin(cherrypy.engine).subscribe() cherrypy.tools.websocket = WebSocketTool() cherrypy.quickstart(BlocklyServer(version, queue), '/', config={ '/serial.connect': { 'tools.websocket.on': True, 'tools.websocket.handler_cls': SerialSocket } })
def run(self): # Disable cherryPy log propagation logging.getLogger('cherrypy').propagate = False logging.getLogger('ws4py').propagate = False # Setup server cherrypy.config.update("user_interface/server.conf") # Mount Django app application = get_wsgi_application() cherrypy.tree.graft(application, "/") # Mount the static folder cherrypy.tree.mount(None, '/static', "user_interface/static.conf") # Mount websocket server WebSocketPlugin(cherrypy.engine).subscribe() cherrypy.tools.websocket = WebSocketTool() cherrypy.tree.mount(WebSocketRoot(), '/ws', config={ '/console': { 'tools.websocket.on': True, 'tools.websocket.handler_cls': ConsoleWebSocketHandler, 'tools.websocket.protocols': ['console'] } }) # Launch a second server to listen on port 9000 server2 = cherrypy._cpserver.Server() server2.socket_port = 9000 server2._socket_host = "0.0.0.0" server2.thread_pool = 30 server2.subscribe() # Start engine cherrypy.engine.signals.subscribe() cherrypy.engine.start() logging.info("Web server listening on port 80") logging.info("Waiting for distant shell on port 9000")
def run(self): # load the configuration abspath = path.abspath(path.join(path.dirname(__file__), path.pardir)) configfile = abspath + '/conf/smsgw.conf' cfg = SmsConfig(configfile) pisglobals.pisid = cfg.getvalue('pisid', 'pis-dummy', 'pis') ipaddress = cfg.getvalue('ipaddress', '127.0.0.1', 'pis') pisport = cfg.getvalue('port', '7788', 'pis') if ipaddress == "0.0.0.0": pisglobals.pisurl = ("http://" + socket.gethostname() + ":" + pisport) else: pisglobals.pisurl = ("http://" + ipaddress + ":" + pisport) wisurlcfg = cfg.getvalue('wisurllist', '[{"url": "http://127.0.0.1:7777"}]', 'pis') # convert json to list of dictionary entriesi pisglobals.wisurllist = json.loads(wisurlcfg) pisglobals.maxwaitpid = int(cfg.getvalue('maxwaitpid', '10', 'pis')) pisglobals.retrywisurl = int(cfg.getvalue('retrywisurl', '2', 'pis')) pisglobals.retrywait = int(cfg.getvalue('retrywait', '5', 'pis')) # prepare ws4py cherrypy.config.update({'server.socket_host': ipaddress}) cherrypy.config.update({'server.socket_port': int(pisport)}) MyWebSocketPlugin(cherrypy.engine).subscribe() cherrypy.tools.websocket = WebSocketTool() # come back to config as dictionary as i was not able to bind web # socket class unsing the pis-web-conf file cfg = { '/': {}, '/ws': { 'tools.websocket.on': True, 'tools.websocket.handler_cls': WebSocketHandler } } cherrypy.quickstart(Root(), '/', cfg)
def run(self): cherrypy.config.update({ 'server.socket_host': '127.0.0.1', 'server.socket_port': 9999, 'server.thread_pool': 10, 'engine.autoreload.on': False }) WebSocketPlugin(cherrypy.engine).subscribe() cherrypy.tools.websocket = WebSocketTool() cherrypy.quickstart(Root(), '', config={ '/ws': { 'tools.websocket.on': True, 'tools.websocket.handler_cls': JsRealtimeWebSocketHandler } })
def upgrade(self, protocols=None, extensions=None, version=WS_VERSION, handler_cls=WebSocket, heartbeat_freq=None): _ = protocols # ws4py doesn't support protocols the way we like (using them for authentication) request = cherrypy.serving.request allowed_protocols = [] requested_protocols = request.headers.get('Sec-WebSocket-Protocol') if requested_protocols: for protocol in requested_protocols.split(','): protocol = protocol.strip() if 'authorization.bearer.' in protocol: allowed_protocols.append(protocol) return WebSocketTool.upgrade(self, protocols=allowed_protocols, extensions=extensions, version=version, handler_cls=handler_cls, heartbeat_freq=heartbeat_freq)