import socketio
sio = socketio.Server()
app = socketio.WSGIApp(sio, static_files={'/': './public/'})
# backgound task
# call combines emit and callback
def task(sid):
sio.sleep(5)
result = sio.call('mult', {'numbers': [3, 4]}, to=sid)
print(result)
# connect event
@sio.event
def connect(sid, environ):
print(sid, 'connected')
sio.start_background_task(task, sid)
# disconnect event
@sio.event
def disconnect(sid):
print(sid, 'disconnected')
# message event
@sio.event
def sum(sid, data):
result = data['numbers'][0] + data['numbers'][1]
def get_app(sio):
# create a Socket.IO server
app = socketio.WSGIApp(sio)
return app
import os
monkey.patch_all()
from chat import hub, route
async_mode = 'gevent'
PORT = int(os.environ.get('PORT', 3000))
SECRET_KEY = os.environ.get('SECRET_KEY', 'schwanfc')
PEER = os.environ.get('PEER', 'false').lower() == 'true'
if PEER:
print('Running in peer mode!')
mgr = socketio.RedisManager('redis://')
sio = socketio.Server(client_manager=mgr,
logger=True,
async_mode=async_mode)
else:
sio = socketio.Server(logger=True, async_mode=async_mode)
app = Flask(__name__)
app.wsgi_app = socketio.WSGIApp(sio, app.wsgi_app)
app.config['SECRET_KEY'] = SECRET_KEY
hub.init(sio)
route.init(app)
if __name__ == '__main__':
print(f'Server is running on port {PORT}')
pywsgi.WSGIServer(('', PORT), app,
handler_class=WebSocketHandler).serve_forever()
import eventlet
import socketio
import pickle
from PIL import Image
import PIL
import cv2
sio = socketio.Server()
app = socketio.WSGIApp(sio)
@sio.event
def connect(sid, environ):
print('connect', sid)
@sio.event
def my_image(sid,bytes):
frame=pickle.loads(bytes)
img=PIL.Image.fromarray(frame)
img.save('testrgb.png')
img_ = cv2.imread('testrgb.png')
cv2.imshow('frame',img_)
cv2.waitKey(1)
print("frame is saved")
@sio.event
def disconnect(sid):
print('disconnect ', sid)
if __name__== '__main__':
eventlet.wsgi.server(eventlet.listen(('', 5000)), app)
import os
from django.core.wsgi import get_wsgi_application
import socketio
from socketio_app.views import sio
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "bpo.settings")
django_app = get_wsgi_application()
application = socketio.WSGIApp(sio, django_app)
import eventlet
import socketio
sio = socketio.Server(cors_allowed_origins='*')
app = socketio.WSGIApp(sio, static_files={
'/': {'content_type': 'text/html', 'filename': './index.html'}
})
@sio.event
def connect(sid, environ):
print('connect ', sid)
@sio.on('motor_command')
def motor_command(sid, data):
print('message ', data)
delta = 0
direction = data['direction']
value = data['value']
if direction == 'left':
delta -= int(value)
elif direction == 'right':
delta += int(value)
print(f'motor_command: {direction} value: {value} delta: {delta}')
@sio.on('generator_type_of_signal')
def type_of_signal(sid, data):
print('message ', data)
type_of_signal = data['typeofSignal']
def create_app(script_info=None):
engineio_logger = logging.getLogger("EngineIO")
socketio_logger = logging.getLogger("SocketioIO")
engineio_logger.setLevel(logging.WARNING)
socketio_logger.setLevel(logging.WARNING)
socketIO = socketio.Server(ping_timeout=600,
logger=socketio_logger,
engineio_logger=engineio_logger)
# instantiate the app
app = Flask(__name__)
app.wsgi_app = socketio.WSGIApp(socketIO, app.wsgi_app)
# WebSocket
app.config['SECRET_KEY'] = 'secret!'
# workflow instance with tasks stack
flow = Workflow()
# worker manager/explorer
hr = Recruit(flow, socketIO)
hr.status()
# Front-end clients
front_clients = []
# ---------------------------------------- HTTP
@app.route('/')
def index():
return jsonify({
'index': 'Please stand by!',
'workers': str(hr.workers),
"results": hr.result,
'stack': hr.flow.get_stack(),
'front-end': front_clients
}), 200
# -------------------------------------- EVENTS
#
#------------- Main-node events ------------------
#
@socketIO.on('ping', namespace='/main_node')
def main_ping(self, *params):
print("\tReceived ping from main node. Arguments:", params)
socketIO.emit("ping_response", hr.workers, namespace='/main_node')
@socketIO.on('add_tasks', namespace='/main_node')
def add_tasks_event(self, tasks):
if len(tasks) > 0:
print('Received new tasks: %s' % len(tasks))
try:
id_list, task_list = task_parser(tasks)
for item in task_list:
hr.new_task(item)
socketIO.emit('task_accepted', id_list, namespace='/main_node')
except Exception as error:
logging.error(
"ERROR '%s' in parsing received task, nothing will be added to task stack. "
% error)
logging.error("Received task: " % tasks)
socketIO.emit("wrong_task_structure",
tasks,
namespace='/main_node')
@socketIO.on('terminate_tasks', namespace='/main_node')
def terminate_tasks_event(self, ids):
print("Terminating tasks: %s" % str(ids))
for task_id in ids:
socketIO.emit("terminate", task_id, namespace="/worker_management")
#------------- Workers management events ------------------
#
# Checking if worker confirm a task
@socketIO.on('assign', namespace='/worker_management')
def task_confirm(sid, data):
hr.task_confirm(data)
# Listen to the results from the worker
@socketIO.on('result', namespace='/worker_management')
def handle_result(sid, json):
temp_id = hr.analysis_res(json)
if temp_id is not None:
socketIO.emit('task_results', json, namespace='/main_node')
@socketIO.on('register_worker', namespace='/worker_management')
def register(sid):
hr.workers.append(sid)
print('Worker ' + sid + ' has been registered at Worker Service')
socketIO.emit('reg_response', namespace='/worker_management', room=sid)
return 'Server confirmed registration'
@socketIO.on('unregister_worker', namespace='/worker_management')
def unregister(sid):
hr.workers.remove(sid)
# ------------ General events --------------------
#
# managing array with curent workers
@socketIO.on('connect')
def connected(sid, environ):
print(sid + ' has been connected to Worker Service')
@socketIO.on('disconnect')
def disconnect(sid):
print(sid + 'has been disconnected from Worker Service')
if (hr.workers.__contains__(sid)):
hr.workers.remove(sid)
@socketIO.on('ping')
def ping_pong(sid, data):
print(' Ping from: ' + str(sid))
socketIO.emit("ping")
return socketIO, app
client.connect("http://localhost:3000")
# Server that opens the connection to the JS display interface
server = socketio.Server(logger=True)
server_app = socketio.WSGIApp(server, static_files={
'/': {'content_type': 'text/html', 'filename': 'index.html'},
'/static/assets/stylesheets/milligram.min.css': {
'content_type': 'text/css',
'filename': 'static/assets/stylesheets/milligram.min.css',
},
'/static/assets/stylesheets/normalize.css': {
'content_type': 'text/css',
'filename': 'static/assets/stylesheets/normalize.css',
},
'/static/assets/stylesheets/style.css': {
'content_type': 'text/css',
'filename': 'static/assets/stylesheets/style.css',
},
'/static/client.js': {
'content_type': 'text/javascript',
'filename': 'static/client.js',
},
'/static/node_modules/socket.io-client/dist/socket.io.js': {
'content_type': 'text/javascript',
'filename': 'static/node_modules/socket.io-client/dist/socket.io.js',
},
})
connected_ids = []
def send_pom_info(info):
"""
WSGI config for backend project.
It exposes the WSGI callable as a module-level variable named ``application``.
For more information on this file, see
https://docs.djangoproject.com/en/3.0/howto/deployment/wsgi/
"""
import os
from django.core.wsgi import get_wsgi_application
import socketio
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'backend.settings')
application = get_wsgi_application()
sio = socketio.Server()
application = socketio.WSGIApp(sio, application)
for u_id in users["modify_users"]:
sockio.sm.emit_update_permission(u_id, current_p_id)
for u_id in users["delete_users"]:
sockio.sm.emit_revoke_permission(u_id, current_p_id)
sockio.sm.remove_collaborator_from_room(u_id, current_p_id)
sockio.sm.emit_project_permissions_updated(user.id, current_p_id)
return jsonify({"success": True})
return jsonify({
"success":
False,
"message":
"Some error occurred! Could not import permissions. Please try again."
})
def start_server(app, sockio, cm, fm, port=8083):
create_files()
sockio.run(app, port=port)
def main():
start_server(_app, sockio, cm, fm)
# for wsgi
application = socketio.WSGIApp(sockio)
if __name__ == '__main__':
main()
def html_picture():
service_camera_id = 0
if len(camera_captures) > 1:
service_camera_id = 1
cap = camera_captures[service_camera_id][1]
response = False
if cap != None:
params = ["picture", cap, 2, 100]
response = html_sendImage(params)
return response
sio = socketio.Server(cors_allowed_origins="*")
app = socketio.WSGIApp(sio, wsgi_handler)
class setInterval:
def __init__(self, interval, action, parameters=None, iter=0):
self.interval = interval
self.action = action
self.stopEvent = threading.Event()
self.parameters = parameters
self.iter = iter
self.currIter = iter
thread = threading.Thread(target=self.__setInterval)
thread.start()
def __setInterval(self):
nextTime = time.time()+self.interval
def run(self):
app = socketio.WSGIApp(self.sio)
pywsgi.WSGIServer(('', self.port), app,
handler_class=WebSocketHandler).serve_forever()
#!/usr/bin/python3
import eventlet # eventlet包提供了协程的支持
import socketio
from control_car import Control_Car
from control_function import Control_Function
import get_ip
print('初始化socketio服务')
sio = socketio.Server(cors_allowed_origins="*") #1 创建socketio服务器
app = socketio.WSGIApp(sio) #2 创建应用
carControl = Control_Car() # 实例化车辆控制（舵机和电调）
carControl.initCarControl()
functionControl = Control_Function() # 实例化功能控制（开关灯、开关摄像头....）
#functionControl.initWebServer() # 初始化web服务
functionControl.initFlask() # 初始化Flask web服务
@sio.event
def connect(sid, environ):
print('客户端连接成功，id: ', sid)
carControl.initCarControl()
sio.emit(
'init', {
'direction_add': carControl.direction_add,
'direction_per': carControl.direction_per,
'direction_reverse': carControl.direction_reverse,
'speed_add': carControl.speed_add,
'speed_per': carControl.speed_per
})
def __init__(self, datawrangler, port=5000, url=''):
self.port = port
self.url = url
self.sio = socketio.Server(async_mode='eventlet')
self.sio.on('getLineData', self.handle_line_data)
self.sio.on('visualizeData', self.handle_visualize_data)
self.app = socketio.WSGIApp(
self.sio,
static_files={
'/': {
'content_type': 'text/html',
'filename': 'public/index.html'
},
'/index.html': {
'content_type': 'text/html',
'filename': 'public/index.html'
},
'/js/d3-extended/d3-extended.min.js': {
'content_type': 'text/javascript',
'filename': 'public/js/d3-extended/d3-extended.min.js'
},
'/js/classes/DistanceMatrix.js': {
'content_type': 'text/javascript',
'filename': 'public/js/classes/DistanceMatrix.js'
},
'/js/classes/DetailPathContainer.js': {
'content_type': 'text/javascript',
'filename': 'public/js/classes/DetailPathContainer.js'
},
'/js/classes/SparkLineContainer.js': {
'content_type': 'text/javascript',
'filename': 'public/js/classes/SparkLineContainer.js'
},
'/js/bootstrap/bootstrap-slider.min.js': {
'content_type': 'text/javascript',
'filename': 'public/js/bootstrap/bootstrap-slider.min.js'
},
'/js/d3-lasso.min.js': {
'content_type': 'text/javascript',
'filename': 'public/js/d3-lasso.min.js'
},
'/js/detailPath.js': {
'content_type': 'text/javascript',
'filename': 'public/js/detailPath.js'
},
'/js/details.js': {
'content_type': 'text/javascript',
'filename': 'public/js/details.js'
},
'/js/filter.js': {
'content_type': 'text/javascript',
'filename': 'public/js/filter.js'
},
'/js/genmain.js': {
'content_type': 'text/javascript',
'filename': 'public/js/genmain.js'
},
'/js/heatmap.js': {
'content_type': 'text/javascript',
'filename': 'public/js/heatmap.js'
},
'/js/highlight.js': {
'content_type': 'text/javascript',
'filename': 'public/js/highlight.js'
},
'/js/linechart.js': {
'content_type': 'text/javascript',
'filename': 'public/js/linechart.js'
},
'/js/main.js': {
'content_type': 'text/javascript',
'filename': 'public/js/main.js'
},
'/js/scatterplot.js': {
'content_type': 'text/javascript',
'filename': 'public/js/scatterplot.js'
},
'/js/sparklines.js': {
'content_type': 'text/javascript',
'filename': 'public/js/sparklines.js'
},
'/css/bootstrap-slider.css': {
'content_type': 'text/css',
'filename': 'public/css/bootstrap-slider.css'
},
'/css/spinner.css': {
'content_type': 'text/css',
'filename': 'public/css/spinner.css'
},
'/css/style.css': {
'content_type': 'text/css',
'filename': 'public/css/style.css'
}
})
self.datawrangler = datawrangler
import socketio
import html
from serverhandler.serverHandler import ServerHandler
from serverhandler.player import Player
sio = socketio.Server()
app = socketio.WSGIApp(sio, static_files={"/": "./static/"})
serverhandler = ServerHandler(sio)
@sio.event
def connect(
sid, environ
): # sid: session id, environ: dict containing client request details
print(f"New user ({sid}) connected")
@sio.event
def disconnect(sid):
print(f"Client ({sid}) disconnected")
# handle player disconnect
roomId = serverhandler.get_room_by_player(sid)
serverhandler.handle_disconnect(sid)
notify_member_change(roomId)
@sio.event
