def run_python_wsgi_async(host="127.0.0.1", port=9010, async_=True):
"""
Runs wsgi server on python 2.x with async middleware"
"""
from wsgiref.simple_server import make_server
from ws4py.websocket import EchoWebSocket
from ws4py.server.wsgirefserver import WSGIServer, WebSocketWSGIRequestHandler
from ws4py.server.wsgiutils import WebSocketWSGIApplication
app = WebSocketWSGIApplication(handler_cls=EchoWebSocket)
if async_:
def middleware(app):
def later(environ, start_response):
for part in app(environ, start_response):
yield part
return later
app = middleware(app)
server = make_server(host,
port,
server_class=WSGIServer,
handler_class=WebSocketWSGIRequestHandler,
app=app)
server.initialize_websockets_manager()
server.serve_forever()
def __init__(self, platformweb, host, port):
self.platformweb = platformweb
self.port = port
self.host = host
self.ws = WebSocketWSGIApplication(handler_cls=VolttronWebSocket)
self.clients = []
self.endpoint_clients = {}
self._wsregistry = {}
def __init__(self, masterweb, host, port):
self.masterweb = masterweb
self.port = port
self.host = host
self.ws = WebSocketWSGIApplication(handler_cls=VolttronWebSocket)
self.clients = []
self.endpoint_clients = {}
self._wsregistry = {}
self._log = logging.getLogger(self.__class__.__name__)
def __init__(self, host, port):
self.host = host
self.port = port
self.ws = WebSocketWSGIApplication(handler_cls=BroadcastWebSocket)
# keep track of connected websocket clients
# so that we can brodcasts messages sent by one
# to all of them. Aren't we cool?
self.clients = []
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 __init__(self, host, port):
register("ws4py", WebSocketChaussette)
logger = configure_logger()
self.server = make_server(
app=WebSocketWSGIApplication(handler_cls=WebSocketGevent),
host=host,
port=port,
backend="ws4py",
address_family=socket.AF_INET,
logger=logger)
self.server.serve_forever()
def get_wsgi_application(self):
def wrapper(ws_app, environ, start_response):
try:
ws_app(environ, start_response)
except HandshakeError as he:
sock = environ['wsgi.input'].rfile._sock
ws = self._handler_factory(sock, environ=environ)
client = self._create_client(ws)
self.on_handshake_error(client, he)
return []
if not self._wsgi_app:
ws_app = WebSocketWSGIApplication(
handler_cls=self._handler_factory)
self._wsgi_app = lambda *args: wrapper(ws_app, *args)
return self._wsgi_app
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 __init__(self, host, port):
self.host = host
self.port = port
self.ws = WebSocketWSGIApplication(handler_cls=BroadcastWebSocket)
Runs wsgi server on python 2.x"
"""
run_python_wsgi_async(host, port, False)
def run_python_wsgi_async(host="127.0.0.1", port=9010, async=True):
"""
Runs wsgi server on python 2.x with async middleware"
"""
from wsgiref.simple_server import make_server
from ws4py.websocket import EchoWebSocket
from ws4py.server.wsgirefserver import WSGIServer, WebSocketWSGIRequestHandler
from ws4py.server.wsgiutils import WebSocketWSGIApplication
app = WebSocketWSGIApplication(handler_cls=EchoWebSocket)
if async:
def middleware(app):
def later(environ, start_response):
for part in app(environ, start_response):
yield part
return later
app = middleware(app)
server = make_server(host,
port,
server_class=WSGIServer,
handler_class=WebSocketWSGIRequestHandler,
app=app)
def __init__(self):
self.ws = WebSocketWSGIApplication(handler_cls=EchoWebSocket)
