def serve(blocking = False):
ws_server = WSGIServer(('localhost', int(Config.get('server', 'ws_port'))), WebSocketWSGIApplication(handler_cls=_LAUWebSocketHandler))
if blocking == True:
ws_server.serve_forever() # Non-blocking serve
else:
ws_server.start() # Non-blocking serve
pass
pass
class WSServer(object):
def __init__(self, listen, app_factory):
WSServerTransport.APP_FACTORY = app_factory
self._listen = listen
def server_forever(self):
self._server = WSGIServer(self._listen, WebSocketWSGIApplication(handler_cls=WSServerTransport), log=logging.getLogger('websocket server'))
log.info("Starting websocket server on {0}".format(self._listen))
self._server.serve_forever()
def run_gevent_server(host="127.0.0.1", port=9001):
from gevent import monkey; monkey.patch_all()
from ws4py.websocket import EchoWebSocket
from ws4py.server.geventserver import WebSocketWSGIApplication, WSGIServer
server = WSGIServer((host, port), WebSocketWSGIApplication(handler_cls=EchoWebSocket))
logger = logging.getLogger('autobahn_testsuite')
logger.warning("Serving gevent server on %s:%s" % (host, port))
server.serve_forever()
def serve(blocking=False):
ws_server = WSGIServer(
('localhost', int(Config.get('server', 'ws_port'))),
WebSocketWSGIApplication(handler_cls=_LAUWebSocketHandler))
if blocking == True:
ws_server.serve_forever() # Non-blocking serve
else:
ws_server.start() # Non-blocking serve
pass
pass
def serve(wsgi_app, global_config, **kw):
ws_handler = kw.get('websocket_resource')
host = kw.get('host', '0.0.0.0')
port = int(kw.get('port', 8080))
print('Starting WebSocket (ws4py) enabled Gevent HTTP server on http://%s:%s' % (
host, port))
s = WSGIServer((host, port), WrapWebSocket(host, port, wsgi_app, ws_handler))
s.serve_forever()
def run_gevent_server(host="127.0.0.1", port=9001):
from gevent import monkey
monkey.patch_all()
from ws4py.websocket import EchoWebSocket
from ws4py.server.geventserver import WebSocketWSGIApplication, WSGIServer
server = WSGIServer((host, port), WebSocketWSGIApplication(handler_cls=EchoWebSocket))
logger = logging.getLogger("autobahn_testsuite")
logger.warning("Serving gevent server on %s:%s" % (host, port))
server.serve_forever()
class WSServer(object):
def __init__(self, listen, app_factory):
WSServerTransport.APP_FACTORY = app_factory
self._listen = listen
def server_forever(self):
self._server = WSGIServer(
self._listen,
WebSocketWSGIApplication(handler_cls=WSServerTransport))
log.info("Starting server on {0}".format(self._listen))
self._server.serve_forever()
def run_gevent_server(host="127.0.0.1", port=9001):
"""
Runs a gevent server on Python 2.x
"""
from gevent import monkey; monkey.patch_all()
import wsaccel
wsaccel.patch_ws4py()
from ws4py.websocket import EchoWebSocket
from ws4py.server.geventserver import WebSocketWSGIApplication, WSGIServer
server = WSGIServer((host, port), WebSocketWSGIApplication(handler_cls=EchoWebSocket))
logger = logging.getLogger('autobahn_testsuite')
logger.warning("Serving gevent server on %s:%s" % (host, port))
server.serve_forever()
class WSDemoServer(threading.Thread):
'''A threaded wrapper around the websockets server so that we can run the Flask and Websockets in parallel together.
Args:
port (int): The port number for the Websockets server to run on.
'''
def __init__(self, host, port):
threading.Thread.__init__(self)
self.log = logs.Logger('WebSocketsServer').getLogger()
self.port = int(port)
self.host = host
self.daemon = True
self.flag = True
self.server = WSGIServer((self.host, self.port), WSDemoApp())
pass
def run(self):
'''Runs the threaded server
Args:
N/A
Returns:
N/A
'''
self.log.info('Starting websockets server')
self.server.serve_forever()
def broadcast(self, data):
'''A wrapper on the server's broadcast method so that it can be easily accessed from the flask application
Args:
data (str): A string message to send to the client.
Returns:
N/A
'''
self.server.application.broadcast(data)
def stop(self):
'''Stops the websockets server'''
self.server.stop()
def run_server(host, port, routes):
compiled_routes = [(re.compile(route), app) for route, app in routes]
def router(environ, start_response):
query_path = environ.get('PATH_INFO', '')
for route, app in compiled_routes:
if route.match(query_path):
if hasattr(app, 'get_wsgi_application'):
app = app.get_wsgi_application()
return app(environ, start_response)
start_response("404 Not Found", [('Content-type', 'text/plain')])
return []
server = WSGIServer((host, port), router)
server.serve_forever()
def main(address=None):
args = parser.parse_args()
conf = create_settings(args=args)
address = address or conf.get_address()
print('Run', address)
server = WSGIServer(address, SessionServer(handler_cls=SessionClient))
session = setup_session(server, settings=conf)
server.environ['WEBSOCKET_SESSION'] = session
try:
server.serve_forever()
except KeyboardInterrupt as e:
print('.. Stopped')
session.close()
server.stop()
server.close()
def main():
import argparse
from ws4py import configure_logger
configure_logger()
parser = argparse.ArgumentParser(description='Twister Server')
parser.add_argument('--host', default='127.0.0.1')
parser.add_argument('-p', '--port', default=9000, type=int)
args = parser.parse_args()
server = WSGIServer((args.host, args.port),
WebSocketWSGIApplication(handler_cls=Twister))
print "Twister running on %s:%s" % (args.host, args.port)
server.serve_forever()
class WSDemoServer(threading.Thread):
'''A threaded wrapper around the websockets server so that we can run the Flask and Websockets in parallel together.
Args:
port (int): The port number for the Websockets server to run on.
'''
def __init__(self, host, port):
threading.Thread.__init__(self)
self.log = logs.Logger('WebSocketsServer').getLogger()
self.port = int(port)
self.host = host
self.daemon = True
self.flag = True
self.server = WSGIServer((self.host, self.port), WSDemoApp())
pass
def run(self):
'''Runs the threaded server
Args:
N/A
Returns:
N/A
'''
self.log.info('Starting websockets server')
self.server.serve_forever()
def broadcast(self, data):
'''A wrapper on the server's broadcast method so that it can be easily accessed from the flask application
Args:
data (str): A string message to send to the client.
Returns:
N/A
'''
self.server.application.broadcast(data)
def stop(self):
'''Stops the websockets server'''
self.server.stop()
to_id = int(data['oid'])
channel = '%s-%d' % (to_type, to_id)
from_type = self.user_type
from_id = self.obj.oid
msg['path'] = data['path']
msg['from_type'] = from_type
msg['from_id'] = from_id
if 'body' in msg:
created_at = Message.save(from_type, from_id, to_type, to_id, msg['body'])
msg['created_at'] = created_at
ret = self.redis.publish(channel, json.dumps(msg))
return {'status': 'ok'}
def message(self, data):
print 'message.data:', data
msg = { 'body': data['body'] }
return self._message(data, msg)
def typing(self, data):
msg = { 'typing': data['typing'] } # True | False
return self._message(data, msg)
### API methods END ###
server = WSGIServer(('0.0.0.0', 9000),
WebSocketWSGIApplication(handler_cls=ChatWebSocket))
server.serve_forever()
class WebfrontEngine(object):
"""
The client-facing web interface.
"""
def __init__(self):
logger.debug("Initializing webfront engine...")
global webfront
webfront = self
self._http_listener = None
self._https_listener = None
self.listen_port = 5000
self.listen_addr = '127.0.0.1'
self.secure_listen_port = 0 # 0 means not binding
self.local_base_url = "http://127.0.0.1:%d/" % (self.listen_port,)
self.secure_base_url = "https://127.0.0.1:%d/" % \
(self.secure_listen_port,)
self._token = None
@property
def access_token(self):
return self._token
def _acquire_access_token(self):
self._token = os.environ.get('AVA_ACCESS_TOKEN',
base58.b58encode(os.urandom(16)))
def start(self, ctx=None):
logger.debug("Starting webfront engine...")
disabled = settings[_CONF_SECTION].get('disabled')
if disabled:
logger.debug("Webfront is not enabled.")
return
self._acquire_access_token()
logger.info("Access Token: %s", self._token)
self.listen_port = settings[_CONF_SECTION]['listen_port']
self.listen_addr = settings[_CONF_SECTION]['listen_addr']
self.secure_listen_port = settings[_CONF_SECTION]['secure_listen_port']
self.local_base_url = "http://127.0.0.1:%d/" % (self.listen_port,)
logger.debug("Local base URL:%s", self.local_base_url)
if self.listen_port > 0:
ctx.add_child_greenlet(gevent.spawn(self._run_http))
if self.secure_listen_port > 0:
ctx.add_child_greenlet(gevent.spawn(self._run_https))
else:
logger.debug("HTTPS listener is disabled.")
ctx.bind('webfront', self)
logger.debug("Webfront engine started.")
def stop(self, ctx=None):
logger.debug("Webfront engine stopped.")
def _run_https(self):
logger.debug("Webfront engine(HTTPS) is running...")
conf_dir = environ.conf_dir()
keyfile = os.path.join(conf_dir, 'ava.key')
certfile = os.path.join(conf_dir, 'ava.crt')
self._https_listener = WSGIServer(
(self.listen_addr, self.secure_listen_port),
dispatcher,
keyfile=keyfile,
certfile=certfile)
logger.debug("Webfront engine(HTTPS) is listening on port: %d",
self._https_listener.address[1])
self._https_listener.serve_forever()
def _run_http(self):
logger.debug("Webfront engine(HTTP) is running...")
self._http_listener = WSGIServer(
(self.listen_addr, self.listen_port),
dispatcher)
logger.debug("Webfront engine(HTTP) is listening on port: %d",
self._http_listener.address[1])
self._http_listener.serve_forever()
try:
from gunicorn.workers.ggevent import GeventPyWSGIWorker, PyWSGIHandler
class WSGIHandler(PyWSGIHandler, WebSocketWSGIHandler):
pass
class Worker(GeventPyWSGIWorker):
"""Worker for Gunicorn.
"""
server_class = WSGIServer
wsgi_handler = WSGIHandler
except ImportError:
pass
REDIS_URL = 'redis://127.0.0.1:6379/0'
application = WebSocketChannelApp(redis_url=REDIS_URL)
if __name__ == '__main__':
logger = ws4py.configure_logger(level='INFO')
parser = argparse.ArgumentParser(description='Echo gevent Server')
parser.add_argument('--host', default='127.0.0.1')
parser.add_argument('--port', default=9000, type=int)
args = parser.parse_args()
server = WSGIServer((args.host, args.port), application)
server.serve_forever()
class WebfrontEngine(object):
"""
The client-facing web interface.
"""
def __init__(self):
logger.debug("Initializing webfront engine...")
global webfront
webfront = self
self._http_listener = None
self._https_listener = None
self.listen_port = 5000
self.listen_addr = '127.0.0.1'
self.secure_listen_port = 0 # 0 means not binding
self.local_base_url = "http://127.0.0.1:%d/" % (self.listen_port, )
self.secure_base_url = "https://127.0.0.1:%d/" % \
(self.secure_listen_port,)
self._token = None
@property
def access_token(self):
return self._token
def _acquire_access_token(self):
self._token = os.environ.get('AVA_ACCESS_TOKEN',
base58.b58encode(os.urandom(16)))
def start(self, ctx=None):
logger.debug("Starting webfront engine...")
disabled = settings[_CONF_SECTION].get('disabled')
if disabled:
logger.debug("Webfront is not enabled.")
return
self._acquire_access_token()
logger.info("Access Token: %s", self._token)
self.listen_port = settings[_CONF_SECTION]['listen_port']
self.listen_addr = settings[_CONF_SECTION]['listen_addr']
self.secure_listen_port = settings[_CONF_SECTION]['secure_listen_port']
self.local_base_url = "http://127.0.0.1:%d/" % (self.listen_port, )
logger.debug("Local base URL:%s", self.local_base_url)
if self.listen_port > 0:
ctx.add_child_greenlet(gevent.spawn(self._run_http))
if self.secure_listen_port > 0:
ctx.add_child_greenlet(gevent.spawn(self._run_https))
else:
logger.debug("HTTPS listener is disabled.")
ctx.bind('webfront', self)
logger.debug("Webfront engine started.")
def stop(self, ctx=None):
logger.debug("Webfront engine stopped.")
def _run_https(self):
logger.debug("Webfront engine(HTTPS) is running...")
conf_dir = environ.conf_dir()
keyfile = os.path.join(conf_dir, 'ava.key')
certfile = os.path.join(conf_dir, 'ava.crt')
self._https_listener = WSGIServer(
(self.listen_addr, self.secure_listen_port),
dispatcher,
keyfile=keyfile,
certfile=certfile)
logger.debug("Webfront engine(HTTPS) is listening on port: %d",
self._https_listener.address[1])
self._https_listener.serve_forever()
def _run_http(self):
logger.debug("Webfront engine(HTTP) is running...")
self._http_listener = WSGIServer((self.listen_addr, self.listen_port),
dispatcher)
logger.debug("Webfront engine(HTTP) is listening on port: %d",
self._http_listener.address[1])
self._http_listener.serve_forever()
class WSServer(object):
def __init__(self,
listen,
request_handler,
msg_handler_pool_size=1024,
indent='indented',
pingpong_trigger=0,
pingpong_timeout=0,
keyfile=None,
certfile=None):
"""
:param listen: string ip:port
:param request_handler: instance of januscloud.proxy.core.request:RequestHandler
:param msg_handler_pool_size:
:param keyfile:
:param certfile:
"""
if msg_handler_pool_size == 0:
msg_handler_pool_size = None
self._msg_handler_pool = Pool(size=msg_handler_pool_size)
self._request_handler = request_handler
self._listen = listen
if keyfile or certfile:
self._server = WSGIServer(
self._listen,
WebSocketWSGIApplication(protocols=['janus-protocol'],
handler_cls=WSServerConn),
log=logging.getLogger('websocket server'),
keyfile=keyfile,
certfile=certfile)
else:
self._server = WSGIServer(
self._listen,
WebSocketWSGIApplication(protocols=['janus-protocol'],
handler_cls=WSServerConn),
log=logging.getLogger('websocket server'),
)
self._server.set_environ({
'app.recv_msg_cbk': self._async_incoming_msg_handler,
'app.closed_cbk': self._request_handler.transport_gone,
'json_indent': indent,
'pingpong_trigger': pingpong_trigger,
'pingpong_timeout': pingpong_timeout
})
def serve_forever(self):
log.info("Starting websocket server on {0}".format(self._listen))
self._server.serve_forever()
def stop(self):
self._server.stop()
def _async_incoming_msg_handler(self, transport_session, message,
exception_handler):
greenlet = Greenlet(
self._incoming_msg_handler,
transport_session,
message,
)
greenlet.link_exception(exception_handler)
self._msg_handler_pool.start(greenlet, blocking=True)
def _incoming_msg_handler(self, transport_session, message):
if self._request_handler:
response = self._request_handler.incoming_request(
Request(transport_session, message))
if response:
transport_session.send_message(response)
class ConnectionServer:
def __init__(self, host, port, public_address, registration_port):
self.server = WSGIServer((host, port), ConnectionApplication(self))
self.public_address = public_address
self.game_servers = []
self.next_gs_port = port + 1
self.next_loader_port = registration_port + 1
self.loaders = []
self.requested_games = []
self.registration_port = registration_port
self.registration_server = StreamServer((host, self.registration_port), self.handle_registration)
self.registration_server.start()
def find_game_server(self, message):
game_id = int(message["GameID"])
server = None
for game_server in self.game_servers:
if game_server["game_id"] == game_id:
return ConnectProtocol.AvailabilityStates.AVAILABLE, game_server
if server is None:
response = ConnectProtocol.AvailabilityStates.PENDING, None
if game_id in self.requested_games:
print "server to be created is already requested"
else:
if os.path.isfile("server/data/replays/{}.dem".format(game_id)):
self.create_game_server(game_id)
else:
response = ConnectProtocol.AvailabilityStates.UNAVAILABLE, None
return response
def handle_registration(self, socket_, address):
message = socket_.recv(1024)
data = message.split(" ")
if data[0] == "GAME_SERVER" and len(data) is 4:
server = dict()
server["host"] = data[1]
server["port"] = int(data[2])
server["game_id"] = int(data[3])
print "registered game server for game {} at ({},{})".format(server["game_id"], server["host"], server["port"])
self.game_servers.append(server)
self.requested_games.remove(server["game_id"])
socket_.sendall("ACCEPTED")
elif data[0] == "REMOVE_GAME_SERVER" and len(data) is 2:
print "removed game server at host"
self.game_servers[:] = [s for s in self.game_servers if s["game_id"] != int(data[1])]
socket_.sendall("ACCEPTED")
elif data[0] == "LOADER" and len(data) is 3:
loader = dict()
loader["game_id"] = int(data[1])
loader["port"] = int(data[2])
print "registered loader for game {} at port {}".format(loader["game_id"], loader["port"])
self.loaders.append(loader)
socket_.sendall("ACCEPTED")
if loader["game_id"] in self.requested_games:
self.create_game_server(loader["game_id"])
elif data[0] == "REMOVE_LOADER" and len(data) is 2:
print "removed loader at host"
self.loaders[:] = [l for l in self.loaders if l["game_id"] != int(data[1])]
socket_.sendall("ACCEPTED")
else:
socket_.sendall("ERROR")
print "Bad message: {} parsed: {}".format(message, data)
print "{}, {}, {}".format(data[0] == "GAME_SERVER", data[0] == "LOADER", len(data))
socket_.close()
def create_game_server(self, game_id):
print "Trying to create server for game {}".format(game_id)
loader_port = -1
for loader in self.loaders:
if loader["game_id"] == game_id:
loader_port = loader["port"]
break
if loader_port < 0:
print "Spawning Loader"
loader_port = self.next_loader_port
subprocess.Popen(["python", "server/executables/loader_main.py", str(game_id), str(loader_port), str(self.registration_port)])
self.next_loader_port += 1
self.requested_games.append(game_id)
else:
print "Creating server for game {} that registers at {}".format(game_id, self.registration_port)
subprocess.Popen(["python", "server/executables/gameserver_main.py", str(game_id), str(self.next_gs_port), str(self.registration_port), self.public_address, str(loader_port)])
self.next_gs_port += 1
def start(self):
self.server.serve_forever()
class WebfrontEngine(object):
"""
The client-facing web interface.
"""
def __init__(self):
logger.debug("Initializing webfront engine...")
self._http_listener = None
self._https_listener = None
self.listen_port = 5000
self.listen_addr = '127.0.0.1'
self.secure_listen_port = 0 # o means not binding
self.local_base_url = "http://127.0.0.1:%d/" % (self.listen_port,)
def start(self, ctx=None):
logger.debug("Starting webfront engine...")
self.listen_port = settings[_CONF_SECTION]['listen_port']
self.listen_addr = settings[_CONF_SECTION]['listen_addr']
self.secure_listen_port = settings[_CONF_SECTION]['secure_listen_port']
self.local_base_url = "http://127.0.0.1:%d/" % (self.listen_port,)
logger.debug("Local base URL:%s", self.local_base_url)
if self.listen_port != 0:
ctx.add_child_greenlet(gevent.spawn(self._run_http))
if self.secure_listen_port != 0:
ctx.add_child_greenlet(gevent.spawn(self._run_https))
logger.debug("Webfront engine started.")
def stop(self, ctx=None):
logger.debug("Webfront engine stopped.")
def _run_https(self):
logger.debug("Webfront engine(HTTPS) is running...")
conf_dir = environ.conf_dir()
keyfile = os.path.join(conf_dir, 'ava.key')
certfile = os.path.join(conf_dir, 'ava.crt')
self._https_listener = WSGIServer(
(self.listen_addr, self.secure_listen_port),
dispatcher,
keyfile=keyfile,
certfile=certfile)
logger.debug("Webfront engine(HTTPS) is listening on port: %d",
self._https_listener.address[1])
self._https_listener.serve_forever()
def _run_http(self):
logger.debug("Webfront engine(HTTP) is running...")
self._http_listener = WSGIServer(
(self.listen_addr, self.listen_port),
dispatcher)
logger.debug("Webfront engine(HTTP) is listening on port: %d",
self._http_listener.address[1])
self._http_listener.serve_forever()
def listen(self, host, port):
server = WSGIServer((host, port), self.get_wsgi_application())
server.serve_forever()
