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)
