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 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 __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
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 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_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 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 __init__(self, hostname, port):
PadBaseServer.__init__(self, hostname, port)
pad_server = self
class PadWsApplication(WebSocketWSGIApplication):
def make_websocket(self, sock, protocols, extensions, environ):
connection = WebSocketWSGIApplication.make_websocket(self, sock, protocols, extensions, environ)
connection.conn_id = sock.fileno()
pad_server.new_connection(connection)
return connection
pass
WSGIServer.__init__(self, (hostname, port), PadWsApplication(handler_cls=self.PadConnection))
self.pool = GEventWebSocketPool()
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 startupagent(self, sender, **kwargs):
if not self.bind_web_address:
_log.info('Web server not started.')
return
import urlparse
parsed = urlparse.urlparse(self.bind_web_address)
hostname = parsed.hostname
port = parsed.port
_log.info('Starting web server binding to {}:{}.' \
.format(hostname, port))
self.registeredroutes.append(
(re.compile('^/discovery/$'), 'callable', self._get_discovery))
self.registeredroutes.append(
(re.compile('^/discovery/allow$'), 'callable', self._allow))
self.registeredroutes.append(
(re.compile('^/$'), 'callable', self._redirect_index))
port = int(port)
vhome = os.environ.get('VOLTTRON_HOME')
logdir = os.path.join(vhome, "log")
if not os.path.exists(logdir):
os.makedirs(logdir)
self.appContainer = WebApplicationWrapper(self, hostname, port)
svr = WSGIServer((hostname, port), self.appContainer)
self._server_greenlet = gevent.spawn(svr.serve_forever)
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()
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 __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
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 __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 __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 _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 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 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 __init__(self, host, port, public_address, game_id):
self.host = host
self.port = port
self.public_address = public_address
self.clients = []
self.game_id = game_id
self.game = Game()
self.server = WSGIServer((host, port), GameApplication(self))
self.subscribers = dict()
self.subscribers["Current"] = []
self.subscribers["Past"] = []
self.subscribers["Event"] = []
self.running = True
self.webserver_thread = Thread(target=self.server.serve_forever, args=(0.5,))
self.past_subscribers_thread = Thread(target=self.serve_past_subscribers)
self.timeout_thread = Thread(target=self.timeout)
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()
from ws4py.websocket import WebSocket
class ExampleServer(WebSocket):
def received_message(self, message):
print(message)
super().received_message(message)
if __name__ == '__main__':
from gevent import monkey
monkey.patch_all()
from ws4py.server.geventserver import WSGIServer
from ws4py.server.wsgiutils import WebSocketWSGIApplication
server = WSGIServer(('localhost', 9000),
WebSocketWSGIApplication(handler_cls=ExampleServer))
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 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()
$('#message').val("");
return false;
});
});
</script>
</head>
<body>
<form action='#' id='chatform' method='get'>
<textarea id='chat' cols='35' rows='10'></textarea>
<br />
<label for='message'>%(username)s: </label><input type='text' id='message' />
<input id='send' type='submit' value='Send' />
</form>
</body>
</html>
""" % {'username': "******" % random.randint(0, 100),
'host': self.host,
'port': self.port}
if __name__ == '__main__':
from ws4py import configure_logger
configure_logger()
parser = argparse.ArgumentParser(description='Echo gevent 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), EchoWebSocketApplication(args.host, args.port))
server.serve_forever()
}
logging.exception(exception)
handler = self.handler(request, response)
return handler.get()
app.error_handlers[403] = Webapp2HandlerAdapter(errors.Error403Handler)
app.error_handlers[404] = Webapp2HandlerAdapter(errors.Error404Handler)
app.error_handlers[503] = Webapp2HandlerAdapter(errors.Error503Handler)
app.error_handlers[500] = Webapp2HandlerAdapter(errors.Error500Handler)
if __name__ == '__main__':
logger = logging.getLogger()
logger.setLevel(logging.DEBUG)
http_server = WSGIServer(('', 8080), app)
ws_server = WSGIServer(('', 9000), WebSocketWSGIApplication(handler_cls=sample_websocket.Commands))
greenlets = [
gevent.spawn(http_server.serve_forever),
gevent.spawn(utils.background_service),
gevent.spawn(ws_server.serve_forever)
]
try:
gevent.joinall(greenlets)
except KeyboardInterrupt:
http_server.stop()
print 'Stopping'
def startupagent(self, sender, **kwargs):
import urlparse
parsed = urlparse.urlparse(self.bind_web_address)
ssl_key = self.web_ssl_key
ssl_cert = self.web_ssl_cert
if parsed.scheme == 'https':
# Admin interface is only availble to rmq at present.
if self.core.messagebus == 'rmq':
self._admin_endpoints = AdminEndpoints(
self.core.rmq_mgmt,
self._certs.get_cert_public_key(
get_fq_identity(self.core.identity)))
if ssl_key is None or ssl_cert is None:
# Because the master.web service certificate is a client to rabbitmq we
# can't use it directly therefore we use the -server on the file to specify
# the server based file.
base_filename = get_fq_identity(self.core.identity) + "-server"
ssl_cert = self._certs.cert_file(base_filename)
ssl_key = self._certs.private_key_file(base_filename)
if not os.path.isfile(ssl_cert) or not os.path.isfile(ssl_key):
self._certs.create_ca_signed_cert(base_filename,
type='server')
hostname = parsed.hostname
port = parsed.port
_log.info('Starting web server binding to {}://{}:{}.'.format(
parsed.scheme, hostname, port))
# Handle the platform.web routes here.
self.registeredroutes.append(
(re.compile('^/discovery/$'), 'callable', self._get_discovery))
self.registeredroutes.append(
(re.compile('^/discovery/allow$'), 'callable', self._allow))
# these routes are only available for rmq based message bus
# at present.
if self.core.messagebus == 'rmq':
# We need reference to the object so we can change the behavior of
# whether or not to have auto certs be created or not.
self._csr_endpoints = CSREndpoints(self.core)
for rt in self._csr_endpoints.get_routes():
self.registeredroutes.append(rt)
for rt in self._admin_endpoints.get_routes():
self.registeredroutes.append(rt)
ssl_private_key = self._certs.get_private_key(
get_fq_identity(self.core.identity))
for rt in AuthenticateEndpoints(ssl_private_key).get_routes():
self.registeredroutes.append(rt)
static_dir = os.path.join(os.path.dirname(__file__), "static")
self.registeredroutes.append((re.compile('^/.*$'), 'path', static_dir))
port = int(port)
vhome = os.environ.get('VOLTTRON_HOME')
logdir = os.path.join(vhome, "log")
if not os.path.exists(logdir):
os.makedirs(logdir)
self.appContainer = WebApplicationWrapper(self, hostname, port)
if ssl_key and ssl_cert:
svr = WSGIServer((hostname, port),
self.appContainer,
certfile=ssl_cert,
keyfile=ssl_key)
else:
svr = WSGIServer((hostname, port), self.appContainer)
self._server_greenlet = gevent.spawn(svr.serve_forever)
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 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 listen(self, host, port):
server = WSGIServer((host, port), self.get_wsgi_application())
server.serve_forever()
def closed(self, code, reason):
print(("Closed down", code, reason))
def received_message(self, m):
self.cnt += 1
if self.cnt < 1000:
self.send(msg)
else:
self.close(reason='Bye bye')
print(time.time() - self.started_at)
global patched
if not patched:
patched = True
wsaccel.patch_ws4py()
start_client()
else:
server.stop()
def start_client():
ws = EchoClient('ws://127.0.0.1:9000/ws')
ws.connect()
if __name__ == '__main__':
server = WSGIServer(('127.0.0.1', 9000), EchoWebSocketApplication())
server.start()
start_client()
while not server.closed:
gevent.sleep(1)
from ws4py.websocket import WebSocket
from ws4py.server.geventserver import WSGIServer
from ws4py.server.wsgiutils import WebSocketWSGIApplication
import time, random
class EchoWebSocket(WebSocket):
def received_message(self, message):
"""
Automatically sends back the provided ``message`` to
its originating endpoint.
"""
print message.__dict__
while True:
try:
value = random.uniform(50, 900000)
s = "x" * int(value)
self.send(s, message.is_binary)
time.sleep(0.01)
print "send " + str(value)
except BaseException:
print "error"
server = WSGIServer(('0.0.0.0', 9700), WebSocketWSGIApplication(handler_cls=EchoWebSocket))
server.serve_forever()
dest="emulate",
action="store_true",
help="Emulate the hw interface")
parser.add_option("-d",
"--debug",
dest="debug",
action="store_true",
help="Provide some debugging output")
(options, args) = parser.parse_args()
DEBUG = options.debug
dirname = os.path.dirname(sys.argv[0])
controller = SingleVolumeController(dirname, options)
try:
server = WSGIServer(('', 8888),
WebSocketWSGIApplication(handler_cls=VolumeServer))
def handleHup(signum, frame):
print 'SIGHUP received: taking no action...'
def handleTerm(signum, frame):
print 'SIGTERM received: closing down...'
server.stop()
signal.signal(signal.SIGHUP, handleHup)
signal.signal(signal.SIGTERM, handleTerm)
server.serve_forever()
except KeyboardInterrupt:
pass
except Termination:
class HQCWebSocketApplication(object):
def __init__(self, host, port):
self.host = host
self.port = port
self.ws = WebSocketWSGIApplication(handler_cls=HQCWebSocket)
self.clients = []
# TODO: remove clients when they exit
self.current_clients = {}
def __call__(self, environ, start_response):
environ['ws4py.app'] = self
return self.ws(environ, start_response)
if __name__ == '__main__':
try:
try:
PORT = int(sys.argv[1])
except IndexError:
PORT = 9000
print "Port not specified"
server = WSGIServer(('0.0.0.0', PORT),
HQCWebSocketApplication('localhost', PORT))
print "Running server on port " + str(PORT)
server.serve_forever()
except KeyboardInterrupt:
server.close()
except socket.error:
print "Server could not start properly. The socket may already be bound by another instance."
def run_server(host, port, application, kill_event):
server = WSGIServer((host, port), application)
server.start()
while not kill_event.is_set():
sleep(0.1)
to_append = {} if obj['expected'] else []
#print obj['expected'], row
for x in range(len(row)) :
if type(to_append) == type({}) :
to_append[obj['expected'][x]] = row[x]
else :
to_append.append(row[x])
out[obj['name']].append(to_append)
except Exception as e :
print "failed:", e
if jobj.has_key('subsequent') :
out['subsequent'] = jobj['subsequent']
to_prune = []
if jobj.has_key('return') :
for key in WSM.keys() :
if WSM[key].terminated :
to_prune.append(key)
elif (jobj['return'] == "*") or re.match(jobj['return'], key) :
WSM[key].send(json.dumps(out), False)
for key in to_prune :
del WSM[key]
server = WSGIServer((_HOST_NAME, _PORT_NUMBER), WebSocketWSGIApplication(handler_cls=Engraver))
print time.asctime(), "Server Starts - %s:%s" % (_HOST_NAME, _PORT_NUMBER)
try:
server.serve_forever()
except KeyboardInterrupt:
pass
server.server_close()
print time.asctime(), "Server Stops - %s:%s" % (_HOST_NAME, _PORT_NUMBER)
monkey.patch_all()
from ws4py.websocket import EchoWebSocket
from ws4py.server.geventserver import WSGIServer
from ws4py.server.wsgiutils import WebSocketWSGIApplication
class CopyPastaSocket(WebSocket):
def received_message(self, message):
self.send(CopyPasta.generate_copy_pasta(message.data),
message.is_binary)
print(message.data)
self.send(CopyPasta.generate_copy_pasta(message.data),
message.is_binary)
server = WSGIServer(('localhost', 3001),
WebSocketWSGIApplication(handler_cls=CopyPastaSocket))
server.serve_forever()
# @asyncio.coroutine
# def hello(websocket, path):
# message = yield from websocket.recv()
# print("Received message {}".format(message))
# result = CopyPasta.generate_copy_pasta(message)
# yield from websocket.send(result)
# print("Sent message: {}".format(result))
# start_server = websockets.serve(hello, 'localhost', 3001)
# asyncio.get_event_loop().run_until_complete(start_server)
# asyncio.get_event_loop().run_forever()
from gevent import monkey; monkey.patch_all()
from ws4py.websocket import EchoWebSocket
from ws4py.server.geventserver import WSGIServer
from ws4py.server.wsgiutils import WebSocketWSGIApplication
server = WSGIServer(('localhost', 8088), WebSocketWSGIApplication(handler_cls=EchoWebSocket))
server.serve_forever()
start_response(status, headers)
return PAGE % {
'username': "******" % random.randint(0, 100),
'host': self.host,
'port': self.port
}
class NoLog(object):
def write(*args, **kw):
pass
if __name__ == '__main__':
parser = argparse.ArgumentParser(description='Echo gevent 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),
EchoWebSocketApplication(args.host, args.port),
log=NoLog(),
backlog=100000)
try:
server.serve_forever()
except KeyboardInterrupt:
pass
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()
def main():
config = copy.deepcopy(SHARED_DEFAULTS)
parser = argparse.ArgumentParser(add_help=True)
parser.add_argument(
"-i", "--ini", dest="ini", help="Config file path", default=None
)
parser.add_argument(
"-v",
"--version",
dest="version",
help="Print version info and exit",
default=None,
nargs="*",
)
args = parser.parse_args()
if args.version is not None:
print(channelstream.__version__)
exit()
ini_path = args.ini or os.environ.get("CHANNELSTREAM_INI")
# set values from ini/cli
if ini_path:
parser = configparser.ConfigParser()
parser.read(ini_path)
settings = dict(parser.items("channelstream"))
for key in CONFIGURABLE_PARAMS:
try:
config[key] = settings[key]
except KeyError:
pass
else:
for key in CONFIGURABLE_PARAMS:
conf_value = os.environ.get(f"channelstream_{key}".upper())
if conf_value is not None:
config[key] = conf_value
config = set_config_types(config)
log_level = getattr(logging, (config.get("log_level") or "INFO").upper())
logging.basicConfig(level=log_level)
log.setLevel(log_level)
log.debug(pprint.pformat(config))
log.info("Starting channelstream {}".format(channelstream.__version__))
url = "http://{}:{}".format(config["host"], config["port"])
log.info("Starting flash policy server on port 10843")
gevent.spawn(gc_conns_forever)
gevent.spawn(gc_users_forever)
server = StreamServer(("0.0.0.0", 10843), client_handle)
server.start()
log.info("Serving on {}".format(url))
log.info("Admin interface available on {}/admin".format(url))
if config["secret"] == "secret":
log.warning("Using default secret! Remember to set that for production.")
if config["admin_secret"] == "admin_secret":
log.warning("Using default admin secret! Remember to set that for production.")
log.warning(f"IP's allowed to post to API {config['allow_posting_from']}")
server = WSGIServer(
(config["host"], config["port"]),
RoutingApplication(config),
log=logging.getLogger("channelstream.WSGIServer"),
)
server.serve_forever()
def cli_start():
if sys.version_info.major < 3 or (sys.version_info.major <= 3
and sys.version_info.minor < 6):
logging.warning(
"\n---\n Version 0.6.9 is the last version to support Python older than 3.6\n---\n"
)
config = copy.deepcopy(SHARED_DEFAULTS)
parser = argparse.ArgumentParser(add_help=True)
parser.add_argument("-i",
"--ini",
dest="ini",
help="Config file path",
default=None)
parser.add_argument("-s",
"--secret",
dest="secret",
help="Secret used to secure your API requests")
parser.add_argument("-u",
"--admin_username",
dest="admin_user",
help="Administrator username")
parser.add_argument(
"-a",
"--admin_secret",
dest="admin_secret",
help="Secret used to secure your admin panel",
)
parser.add_argument("-host",
"--host",
dest="host",
help="Host ip on which the server listens to")
parser.add_argument(
"-p",
"--port",
type=int,
dest="port",
help="Port on which the server listens to",
)
parser.add_argument("-d",
"--debug",
dest="debug",
help="Does nothing for now")
parser.add_argument("-l",
"--log-level",
dest="log_level",
help="Does nothing for now")
parser.add_argument("-e",
"--demo",
dest="demo",
help="Does nothing, BW.compat")
parser.add_argument(
"-x",
"--allowed_post_ip",
dest="allow_posting_from",
help="comma separated list of ip's "
"that can post to server",
)
parser.add_argument(
"-c",
"--allow_cors",
dest="allow_cors",
help="comma separated list of domains's "
"that can connect to server",
)
parser.add_argument(
"--validate-requests",
dest="validate_requests",
help="Enable timestamp check on signed requests",
)
args = parser.parse_args()
parameters = (
"debug",
"log_level",
"port",
"host",
"secret",
"admin_user",
"admin_secret",
"allow_posting_from",
"allow_cors",
"validate_requests",
)
if args.ini:
parser = configparser.ConfigParser()
parser.read(args.ini)
settings = dict(parser.items("channelstream"))
for key in parameters:
try:
config[key] = settings[key]
except KeyError:
pass
else:
for key in parameters:
conf_value = getattr(args, key)
if conf_value:
config[key] = conf_value
# convert types
config["debug"] = asbool(config["debug"])
config["port"] = int(config["port"])
config["validate_requests"] = asbool(config["validate_requests"])
for key in ["allow_posting_from", "allow_cors"]:
if not config[key]:
continue
try:
listed = [ip.strip() for ip in config[key].split(",")]
config[key] = listed
except ValueError:
pass
log_level = getattr(logging, config.get("log_level", "INFO").upper())
logging.basicConfig(level=log_level)
log.info("Starting channelstream {}".format(channelstream.__version__))
url = "http://{}:{}".format(config["host"], config["port"])
log.info("Starting flash policy server on port 10843")
gc_conns_forever()
gc_users_forever()
server = StreamServer(("0.0.0.0", 10843), client_handle)
server.start()
log.info("Serving on {}".format(url))
log.info("Admin interface available on {}/admin".format(url))
if config["secret"] == "secret":
log.warning(
"Using default secret! Remember to set that for production.")
if config["admin_secret"] == "admin_secret":
log.warning(
"Using default admin secret! Remember to set that for production.")
server = WSGIServer(
(config["host"], config["port"]),
RoutingApplication(config),
log=logging.getLogger("channelstream.WSGIServer"),
)
server.serve_forever()
def startupagent(self, sender, **kwargs):
from urllib.parse import urlparse
parsed = urlparse(self.bind_web_address)
ssl_key = self.web_ssl_key
ssl_cert = self.web_ssl_cert
rpc_caller = self.vip.rpc
if parsed.scheme == 'https':
# Admin interface is only availble to rmq at present.
if self.core.messagebus == 'rmq':
self._admin_endpoints = AdminEndpoints(
rmq_mgmt=self.core.rmq_mgmt,
ssl_public_key=self._certs.get_cert_public_key(
get_fq_identity(self.core.identity)),
rpc_caller=rpc_caller)
if ssl_key is None or ssl_cert is None:
# Because the master.web service certificate is a client to rabbitmq we
# can't use it directly therefore we use the -server on the file to specify
# the server based file.
base_filename = get_fq_identity(self.core.identity) + "-server"
ssl_cert = self._certs.cert_file(base_filename)
ssl_key = self._certs.private_key_file(base_filename)
if not os.path.isfile(ssl_cert) or not os.path.isfile(ssl_key):
self._certs.create_signed_cert_files(base_filename,
cert_type='server')
if ssl_key is not None and ssl_cert is not None and self._admin_endpoints is None:
self._admin_endpoints = AdminEndpoints(
ssl_public_key=CertWrapper.get_cert_public_key(ssl_cert),
rpc_caller=rpc_caller)
else:
self._admin_endpoints = AdminEndpoints(rpc_caller=rpc_caller)
hostname = parsed.hostname
port = parsed.port
_log.info('Starting web server binding to {}://{}:{}.'.format(
parsed.scheme, hostname, port))
# Handle the platform.web routes here.
self.registeredroutes.append(
(re.compile('^/discovery/$'), 'callable', self._get_discovery))
self.registeredroutes.append(
(re.compile('^/discovery/allow$'), 'callable', self._allow))
self.registeredroutes.append(
(re.compile(r'/gs'), 'callable', self.jsonrpc))
# these routes are only available for rmq based message bus
# at present.
if self.core.messagebus == 'rmq':
# We need reference to the object so we can change the behavior of
# whether or not to have auto certs be created or not.
self._csr_endpoints = CSREndpoints(self.core)
for rt in self._csr_endpoints.get_routes():
self.registeredroutes.append(rt)
# Register the admin endpoints regardless of whether there is an ssl context
# or not.
for rt in self._admin_endpoints.get_routes():
self.registeredroutes.append(rt)
# Allow authentication endpoint from any https connection
if parsed.scheme == 'https':
if self.core.messagebus == 'rmq':
ssl_private_key = self._certs.get_pk_bytes(
get_fq_identity(self.core.identity))
else:
ssl_private_key = CertWrapper.get_private_key(ssl_key)
for rt in AuthenticateEndpoints(
tls_private_key=ssl_private_key).get_routes():
self.registeredroutes.append(rt)
else:
# We don't have a private ssl key if we aren't using ssl.
for rt in AuthenticateEndpoints(
web_secret_key=self._web_secret_key).get_routes():
self.registeredroutes.append(rt)
static_dir = os.path.join(os.path.dirname(__file__), "static")
self.registeredroutes.append((re.compile('^/.*$'), 'path', static_dir))
port = int(port)
self.appContainer = WebApplicationWrapper(self, hostname, port)
if ssl_key and ssl_cert:
svr = WSGIServer((hostname, port),
self.appContainer,
certfile=ssl_cert,
keyfile=ssl_key)
else:
svr = WSGIServer((hostname, port), self.appContainer)
self._server_greenlet = gevent.spawn(svr.serve_forever)
class GameServer:
def __init__(self, host, port, public_address, game_id):
self.host = host
self.port = port
self.public_address = public_address
self.clients = []
self.game_id = game_id
self.game = Game()
self.server = WSGIServer((host, port), GameApplication(self))
self.subscribers = dict()
self.subscribers["Current"] = []
self.subscribers["Past"] = []
self.subscribers["Event"] = []
self.running = True
self.webserver_thread = Thread(target=self.server.serve_forever, args=(0.5,))
self.past_subscribers_thread = Thread(target=self.serve_past_subscribers)
self.timeout_thread = Thread(target=self.timeout)
def start(self):
self.webserver_thread.start()
self.past_subscribers_thread.start()
self.timeout_thread.start()
print "Started game server on {}, {}".format(self.host, self.port)
def serve_past_subscribers(self):
while self.running:
for subscriber, past_state in self.subscribers["Past"]:
if past_state.finished():
continue
updates, events = past_state.pass_time(PAST_SEND_INTERVAL*subscriber.speed)
for update in updates:
subscriber.send_update(update)
for event in events:
subscriber.send_event(event)
self.subscribers["Past"][:] = [(s, ps) for s, ps in self.subscribers["Past"] if not ps.finished()]
time.sleep(PAST_SEND_INTERVAL * TIME_PER_TICK)
def timeout(self):
timeout = SERVICE_TIMEOUT
while self.running:
time.sleep(TIMEOUT_INTERVAL)
print "Checking Timeout"
total_subscribers = len(self.subscribers["Current"])+len(self.subscribers["Past"])+len(self.subscribers["Event"])
if total_subscribers > 0 or not self.game.complete:
timeout = SERVICE_TIMEOUT
else:
timeout -= TIMEOUT_INTERVAL
print "{}".format(timeout)
if timeout < 0:
print "Timeout: shutting down gameserver"
self.running = False
self.server.stop()
print "Finished timeout-thread"
def find_client(self, client_id):
for client in self.clients:
if client.id == client_id:
return client
print "Couldn't find client"
return None
def create_client(self):
client = Client(Protocols.generate_id())
self.clients.append(client)
return client
def remove_client(self, client):
self.remove_subscriber(client)
self.clients[:] = [c for c in self.clients if c.id != client.id]
def provides_game(self, game_id):
return self.game_id == game_id
def add_subscriber(self, client, mode, time):
if mode == GameProtocol.SubscribeModes.CURRENT:
self.subscribers["Event"].append(client)
self.subscribers["Current"].append(client)
elif mode == GameProtocol.SubscribeModes.PAST:
client.set_time(time)
self.subscribers["Past"].append((client, self.game.past_state(time)))
def remove_subscriber(self, client):
self.subscribers["Event"][:] = [c for c in self.subscribers["Event"] if c.id != client.id]
self.subscribers["Current"][:] = [(s, it) for s, it in self.subscribers["Past"] if s.id != client.id]
self.subscribers["Past"][:] = [(s, it) for s, it in self.subscribers["Past"] if s.id != client.id]
def register_update(self, update):
self.game.add_update(update)
for client in self.subscribers["Current"]:
client.send_update(update)
def register_event(self, event):
self.game.add_event(event)
for client in self.subscribers["Event"]:
client.send_event(event)
def finish(self):
self.game.finish()
self.send(msg)
def closed(self, code, reason):
print(("Closed down", code, reason))
def received_message(self, m):
self.cnt += 1
if self.cnt < 1000:
self.send(msg)
else:
self.close(reason='Bye bye')
print(time.time() - self.started_at)
global patched
if not patched:
patched = True
wsaccel.patch_ws4py()
start_client()
else:
server.stop()
def start_client():
ws = EchoClient('ws://127.0.0.1:9000/ws')
ws.connect()
if __name__ == '__main__':
server = WSGIServer(('127.0.0.1', 9000), EchoWebSocketApplication())
server.start()
start_client()
while not server.closed:
gevent.sleep(1)
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)
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...")
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()
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()
import os
import gevent
from django.core.wsgi import get_wsgi_application
from gevent import pywsgi
from ws4py.server.geventserver import WSGIServer
from ws4py.server.wsgiutils import WebSocketWSGIApplication
from implement_table.core.settings import DJANGO_HOST, WEBSOCKET_HOST
from implement_table.ws.websocket import MnWebSocket
os.environ.setdefault("DJANGO_SETTINGS_MODULE",
"implement_table.core.settings")
http_server = pywsgi.WSGIServer(DJANGO_HOST, get_wsgi_application())
ws_server = WSGIServer(WEBSOCKET_HOST,
WebSocketWSGIApplication(handler_cls=MnWebSocket))
g = [
gevent.spawn(http_server.serve_forever),
gevent.spawn(ws_server.serve_forever),
# scheduler.start()
]
gevent.joinall(g, raise_error=True)
application = get_wsgi_application()
