def __init__(self,
engineio_options=None,
client_manager_class=None,
logger=False,
binary=False):
if client_manager_class is None:
client_manager_class = base_manager.BaseManager
self.manager = client_manager_class(self)
if engineio_options is None:
engineio_options = {}
self.eio = engineio.Server(**engineio_options)
self.eio.on('connect', self._handle_eio_connect)
self.eio.on('message', self._handle_eio_message)
self.eio.on('disconnect', self._handle_eio_disconnect)
self.binary = binary
self.environ = {}
self.handlers = {}
self.callbacks = {}
self._binary_packet = None
self._attachment_count = 0
self._attachments = []
if not isinstance(logger, bool):
self.logger = logger
else:
logging.basicConfig()
self.logger = logging.getLogger('socketio')
if logger:
self.logger.setLevel(logging.INFO)
else:
self.logger.setLevel(logging.ERROR)
def bind_websocket(app):
if os.getenv(CONST.ENV_LIGHT_APP_WEBSOCKET, 'on') == 'off':
return
async_mode = 'gevent_uwsgi'
if os.getenv(CONST.ENV_LIGHT_APP_DEV) == 'true':
async_mode = 'gevent'
eio = engineio.Server(async_mode=async_mode)
@eio.on('connect')
def connect(sid, environ):
print('websocket connect')
cookie = cookies.SimpleCookie(environ['HTTP_COOKIE'])
session = websocket.create_session(app, cookie)
websocket.connect(sid, eio, session, environ)
@eio.on('disconnect')
def disconnect(sid):
print('websocket disconnect')
websocket.disconnect(sid)
@eio.on('message')
def message(sid, data):
websocket.message(sid, data)
return eio
def __init__(self,
client_manager=None,
logger=False,
binary=False,
json=None,
async_handlers=False,
**kwargs):
engineio_options = kwargs
engineio_logger = engineio_options.pop('engineio_logger', None)
if engineio_logger is not None:
engineio_options['logger'] = engineio_logger
if json is not None:
packet.Packet.json = json
engineio_options['json'] = json
engineio_options['async_handlers'] = False
self.eio = engineio.Server(**engineio_options)
self.eio.on('connect', self._handle_eio_connect)
self.eio.on('message', self._handle_eio_message)
self.eio.on('disconnect', self._handle_eio_disconnect)
self.binary = binary
self.environ = {}
self.handlers = {}
self.namespace_handlers = {}
self._binary_packet = []
if not isinstance(logger, bool):
self.logger = logger
else:
self.logger = logging.getLogger('socketio')
if not logging.root.handlers and \
self.logger.level == logging.NOTSET:
if logger:
self.logger.setLevel(logging.INFO)
else:
self.logger.setLevel(logging.ERROR)
self.logger.addHandler(logging.StreamHandler())
if client_manager is None:
client_manager = base_manager.BaseManager()
self.base_manager = base_manager.BaseManager()
self.manager = client_manager
self.manager_initialized = False
self.async_handlers = async_handlers
self.async_mode = self.eio.async_mode
def test(eio_version, payload):
s = engineio.Server()
start = time.time()
count = 0
s.handle_request({
'REQUEST_METHOD': 'GET',
'QUERY_STRING': eio_version,
}, lambda s, h: None)
sid = list(s.sockets.keys())[0]
while True:
environ = {
'REQUEST_METHOD': 'POST',
'QUERY_STRING': eio_version + '&sid=' + sid,
'CONTENT_LENGTH': '6',
'wsgi.input': io.BytesIO(payload)
}
s.handle_request(environ, lambda s, h: None)
count += 1
if time.time() - start >= 5:
break
return count
def __init__(self,
client_manager_class=None,
logger=False,
binary=False,
**kwargs):
if client_manager_class is None:
client_manager_class = base_manager.BaseManager
self.manager = client_manager_class(self)
engineio_options = kwargs
engineio_logger = engineio_options.pop('engineio_logger', None)
if engineio_logger is not None:
engineio_options['logger'] = engineio_logger
self.eio = engineio.Server(**engineio_options)
self.eio.on('connect', self._handle_eio_connect)
self.eio.on('message', self._handle_eio_message)
self.eio.on('disconnect', self._handle_eio_disconnect)
self.binary = binary
self.environ = {}
self.handlers = {}
self.callbacks = {}
self._binary_packet = None
self._attachment_count = 0
self._attachments = []
if not isinstance(logger, bool):
self.logger = logger
else:
self.logger = logging.getLogger('socketio')
if not logging.root.handlers and \
self.logger.level == logging.NOTSET:
if logger:
self.logger.setLevel(logging.INFO)
else:
self.logger.setLevel(logging.ERROR)
self.logger.addHandler(logging.StreamHandler())
from flask import Flask, render_template
import engineio
# set async_mode to 'threading', 'eventlet' or 'gevent' to force a mode
async_mode = None
eio = engineio.Server(async_mode=async_mode)
app = Flask(__name__)
app.wsgi_app = engineio.Middleware(eio, app.wsgi_app)
@app.route('/')
def index():
return render_template('latency.html')
@eio.on('message')
def message(sid, data):
eio.send(sid, 'pong', binary=False)
if __name__ == '__main__':
if eio.async_mode == 'threading':
# deploy with Werkzeug
app.run(threaded=True)
elif eio.async_mode == 'eventlet':
# deploy with eventlet
import eventlet
from eventlet import wsgi
wsgi.server(eventlet.listen(('', 5000)), app)
import engineio
from gevent import pywsgi
import logging
logging.basicConfig(level=logging.DEBUG)
eio = engineio.Server()
@eio.on('message')
def message(sid, msg):
eio.send(sid, "Server received: %s" % msg)
app = engineio.Middleware(eio)
pywsgi.WSGIServer(('', 8000), app).serve_forever()
