class Server(): def __init__(self, port): self.port = port self.app = Flask(__name__, static_folder='assets/static', static_url_path='/static', template_folder='assets/templates') self.app.register_blueprint(routes) self.socketio = SocketIO(self.app) # Log to stdout. sh = logging.StreamHandler(sys.stdout) self.app.logger.addHandler(sh) @self.socketio.on('connect') def on_connect(): """ This seems necessary to get the SocketIO emitting working properly... """ pass def start(self): self.app.logger.debug('starting the nomadic server...') self.socketio.run(self.app, port=self.port) def refresh_clients(self): self.socketio.emit('refresh')
def ansible_server(send_queue, recv_queue): app = Flask(__name__) socketio = SocketIO(app) @socketio.on('message') def receive_message(msg): data = json.loads(msg) # Special channel for gamepad data if data['header']['msg_type'] == 'gamepad': mc.set('gamepad', data['content']) else: recv_queue.put_nowait(data) @socketio.on('connect') def on_connect(): print 'Connected to Dawn.' @socketio.on_error() def on_error(e): print e def send_process(send_queue): while True: try: msg = send_queue.get_nowait() socketio.emit('message', msg) time.sleep(.02) except Empty: time.sleep(.02) send_p = Thread(target=send_process, args=(send_queue,)) send_p.daemon = True send_p.start() socketio.run(app, host='0.0.0.0')
def ansible_server(send_queue, recv_queue): app = Flask(__name__) socketio = SocketIO(app) @socketio.on('message') def receive_message(msg): data = json.loads(msg) # Special channel for gamepad data if data['header']['msg_type'] == 'gamepad': mc.set('gamepad', data['content']) else: recv_queue.put_nowait(data) @socketio.on('connect') def on_connect(): print 'Connected to Dawn.' @socketio.on_error() def on_error(e): print e def send_process(send_queue): while True: try: msg = send_queue.get_nowait() socketio.emit('message', msg) time.sleep(.02) except Empty: time.sleep(.02) send_p = Thread(target=send_process, args=(send_queue, )) send_p.daemon = True send_p.start() socketio.run(app, host='0.0.0.0')
class Server(Thread): def __init__(self, __name__): Thread.__init__(self) self.app = Flask(__name__) self.app.config['SECRET_KEY'] = 'secret!' self.app.config['DEBUG'] = False self.socketio = SocketIO(self.app) def run(self): print 'starting run in Server' self.socketio.run(self.app, port=5001, host='0.0.0.0') print 'ERROR ---------------------socket io exited'
def main(): app = Flask(__name__) app.config['SECRET_KEY'] = 'secret!' db.init_app(app) init_login(app) init_admin_view(app, db) with app.app_context(): db.create_all() main_view = views.create_views() app.register_blueprint(url_prefix = '/', blueprint = main_view) socketio = SocketIO(app) socketio.run(app, '0.0.0.0', 8080)
def main(argv): global app, socketio, gpio_controller, rgb_controller handle_args(argv) gpio_controller = GPIOController(); rgb_controller = RGBController(gpio_controller) app = Flask(__name__) app.config['SECRET_KEY'] = 'secret!' app.debug = conf['server']['debug'] socketio = SocketIO(app) server_conf = conf['server'] socketio.run(app, use_reloader=server_conf['reload'], host=server_conf['host'], port=server_conf['port'])
def socketServer(): app = Flask(__name__) socketio = SocketIO(app) @socketio.on('appConnected') def app_connected(json): print('received json: ' + str(json)) @socketio.on('connect', namespace="/main") def startSocket(): print "test message2" @app.route('/') def load(): return render_template("betaIndex.html") @app.route('/launch') def loadLaunch(): return render_template("testLaunch.html") if __name__ == "__main__": socketio.run(app, "localhost", 80)
@socketio.on('my event', namespace='/test') def test_message(message): pass @socketio.on('connect', namespace='/test') def test_connect(): pass @socketio.on('disconnect', namespace='/test') def test_disconnect(): pass # Start MQTT (Mosquitto) mqttc = mosquitto.Mosquitto() mqttc.on_message = on_message mqttc.connect("127.0.0.1", 1883, 60, True) mqttc.subscribe("log", 0) signal.signal(signal.SIGINT, signal_handler) if __name__ == '__main__': mqtt_thread = MQTT_Thread() mqtt_thread.start() socketio.run(app, host='0.0.0.0', port=8000)
@socketio.on_error() def error_handler(e): print e def join_into_room(id): data = False if id is not None: join_room(id) data = True return data # app.threaded=True socketio.run(app, host="127.0.0.1", port=8000, policy_server=False) # server sent events section """from redis import Redis redis = Redis() pubsub = redis.pubsub() import time from datetime import datetime p = redis.pipeline() app.config['ONLINE_LAST_MINUTES'] = 5 def mark_online(user_id): global p now = int(time.time())
host = get_ip_address_from_interface("eth0") port = 8000 p_host = "localhost" p_port = 9000 @app.route('/') def index(): return render_template("synth", host=host, port=port) @socketio.on('connect', namespace='/pendulum') def test_connect(): print "Client connected" sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) try: sock.connect((p_host, p_port)) f = sock.makefile() while True: line = f.readline() emit('data', {'data': line.strip() }) finally: sock.close() @socketio.on('disconnect', namespace='/pendulum') def test_disconnect(): print('Client disconnected') if __name__ == '__main__': socketio.run(app, host=host, port=port)
'id': int(m['data']) }, room='1') else: socketio.emit('new mail', { 'data': "Содержание %s" % cnt, 'date': datetime.now().strftime("%H:%M:%S"), 'title': 'Письмо №%s' % cnt, 'image': '', 'is_new': True }, room='1') def wr(fnc): """ Оборачиваем запуск сервера - запускаем тред для редиса. """ def f(*args, **kwargs): import threading t = threading.Thread(target=redis_thread) t.daemon = True t.start() return fnc(*args, **kwargs) return f from socketio.sgunicorn import NginxGeventSocketIOWorker NginxGeventSocketIOWorker.run = wr(NginxGeventSocketIOWorker.run) if __name__ == "__main__": socketio.run(app, port=8100)
@socketio.on('disconnect', namespace='/test') def test_disconnect(): print('disconnect') @socketio.on('my room event', namespace='/test') def on_join(data): room = data['room'] msg = data['data'] emit('my response', {'data': msg}, room=room) @socketio.on('join', namespace='/test') def on_join(data): room = data['room'] join_room(room) # emit('my response',{'data':' He has entered the room.'}, room=room) print('join') @socketio.on('leave') def on_leave(data): room = data['room'] leave_room(room) send(username + ' has left the room.', room=room) print('leave') if __name__ == "__main__": socketio.run(app, '0.0.0.0', 8080)
rc_interface.clockwise(int(message)) emit('server-message', {'data': "clockwise"}) @socketio.on('counterclockwise', namespace='/test') def counterclockwiseResponse(message): rc_interface.counterclockwise(int(message)) emit('server-message', {'data': "counterclockwise"}) @socketio.on('left', namespace='/test') def leftResponse(message): rc_interface.left(int(message)) emit('server-message', {'data': "left"}) @socketio.on('right', namespace='/test') def rightResponse(message): rc_interface.right(int(message)) emit('server-message', {'data': "right"}) @socketio.on('stop', namespace='/test') def stopResponse(message): rc_interface.stop() emit('server-message', {'data': "stop"}) @socketio.on('connect', namespace='/test') def test_connect(): emit('connection-status', {'data': 'Connected'}) print "control on 5001" if __name__ == '__main__': socketio.run(app, host='0.0.0.0', port=5001)
self.randomNumberGenerator() @app.route('/') def index(): #only by sending this page first will the client be connected to the socketio instance return render_template('index.html') @socketio.on('connect', namespace='/test') def test_connect(): # need visibility of the global thread object global thread print('Client connected') #Start the random number generator thread only if the thread has not been started before. if not thread.isAlive(): print "Starting Thread" thread = RandomThread() thread.start() @socketio.on('disconnect', namespace='/test') def test_disconnect(): print('Client disconnected') thread_stop_event.clear() if __name__ == '__main__': app.debug=True socketio.run(app, host='0.0.0.0', port=5001)
socketio = SocketIO(app) @app.route('/') def main(): return render_template('main.html') @socketio.on('connect', namespace='/socket') def ws_conn(): data = { #'button_1': GPIO.input(pin_out_1) } socketio.emit('status_btn', data, namespace='/socket') @socketio.on('button', namespace='/socket') def ws_btn(message): button = message.get('button') if button == 1: #GPIO.output(pin_out_1, not GPIO.input(pin_out_1)) #data = { # 'button_1': GPIO.input(pin_out_1) #} data = 1 socketio.emit('status_btn', data, namespace='/socket') if __name__ == '__main__': socketio.run(app, "0.0.0.0", port=5678)
application = Flask(__name__) socketio = SocketIO(application) lds = LidarServer() @application.route('/') def get_root(): return render_template('index.html') @application.route('/data/') def index(): return render_template('data.html') # when we get a post full of data, send it! @application.route("/publish/", methods = ['POST']) def publish_data(): response = lds.publish_data() socketio.emit('force_update', lds.get_data()) return response # when we get a request for data, send it! @socketio.on('update') def get_data(): d = lds.get_data() return d if __name__ == '__main__': application.debug = True socketio.run(application)
dog.check_alive() return render_template('index.html') @socketio.on('connect', namespace='/tweets') def tweets_connect(): dog.check_alive() uid = request.namespace.socket.sessid print('Client %s connected' % uid) while True: try: tweet = dog.streamer.queue.get(timeout=5) except gevent.queue.Empty: dog.check_alive() else: emit('tweet', tweet, broadcast=True) @socketio.on('disconnect', namespace='/tweets') def tweets_disconnect(): dog.check_alive() uid = request.namespace.socket.sessid print('Client %s disconnected' % uid) if __name__ == '__main__': try: socketio.run(app, port=port, host="0.0.0.0") except KeyboardInterrupt: pass
cBeta = cdata[1].split('=')[1] cAlpha = cdata[2].split('=')[1] cHeading = cdata[3].split('=')[1] cAccuracy = cdata[4].split('=')[1] #print ('compass:'******'Heading:', cHeading) y2 = scale_heading(cHeading) pwm.setPWM(4, 0, y2) @io.on('gyroUpdate') def update_gyro(data): #print("gyrodata:", data) axis = data.split(';') #split into pairs, grab out the data from the pair ax = axis[0].split('=')[1] ay = axis[1].split('=')[1] az = axis[2].split('=')[1] ra = axis[3].split('=')[1] rb = axis[4].split('=')[1] rg = axis[5].split('=')[1] #print ('orientation:',ax,ay,az,ra,rb,rg) if __name__ == '__main__': app.jinja_env.add_extension('pyjade.ext.jinja.PyJadeExtension') io.run(app, host='0.0.0.0')
quad = 0 print("vert:%s horiz:%s" % (horiz, vert)) if ((horiz > self.neutral) and (vert < self.neutral)): quad = 1 # ahead right print("Quad 1 vert:%s horiz:%s" % (horiz, vert)) if ((horiz < self.neutral) and (vert < self.neutral)): quad = 2 # ahead left print("Quad 2 vert:%s horiz:%s" % (horiz, vert)) if ((horiz < self.neutral) and (vert > self.neutral)): quad = 3 # behind left print("Quad 3 vert:%s horiz:%s" % (horiz, vert)) if ((horiz > self.neutral) and (vert > self.neutral)): quad = 4 # behind right print("Quad 4 vert:%s horiz:%s" % (horiz, vert)) if ((horiz < 20) and (vert > 115) and (vert < 140)): quad = 5 print("Spin Left!") if ((horiz > 230) and (vert > 115) and (vert < 140)): quad = 6 print("Spin Right!") if ((horiz > self.neutral_min) and (horiz < self.neutral_max) and (vert > self.neutral_min) and (vert < self.neutral_max)): quad = 0 # overwrite the neutral square print("Quad 0 vert:%s horiz:%s" % (horiz, vert)) return quad if __name__ == '__main__': socketio.run(app, port=8081)
#!/usr/bin/env python from flask import Flask, render_template from flask.ext.socketio import SocketIO, emit app = Flask(__name__) app.config['SECRET_KEY'] = 'secret!' socketio = SocketIO(app) #event_name = "my_event" #namespace = "/my_namespace" event_name = "text" #namespace = "/my_namespace" #@socketio.on(event_name, namespace=namespace) @socketio.on(event_name) def test_message(message): print("called!") print("receive: ") print(message) #emit('my response', {'data': message['data']}) if __name__ == '__main__': socketio.run(app, host='192.168.101.58', port=8011)
@app.route('/lp', methods=['GET']) def landing_points(): print 'lps' with open('data/landing_points.json') as f: return f.read() @socketio.on('connect', namespace='') def connect(): print 'client connected' emit('connect', {'data': 'Connected'}) @socketio.on('disconnect', namespace='') def disconnect(): print 'Client disconnected' def make_dir(dir): if not os.path.exists(dir): os.makedirs(dir) # RUN APP if __name__ == "__main__": # app.run(host='0.0.0.0',debug=True) socketio.run(app, host='0.0.0.0', debug=True) # socketio.run(app,debug=False, host='0.0.0.0', port=8080)
from flask.ext.socketio import SocketIO,emit app = Flask(__name__) app.config['SECRET_KEY'] = 'secret!' socketio = SocketIO(app) messages=[] @app.route('/') def index(): return app.send_static_file('index.html') @socketio.on('connect',namespace='/chat') def makeConnection(): print "Connected" for message in messages: print message emit('message',message) @socketio.on('message',namespace='/chat') def new_message(message,name): tmp={'text':message,'name':name} print ('\n\n'+ tmp['name']+' said: '+tmp['text']+'\n\n') messages.append(tmp) emit('message',tmp,broadcast=True) if __name__ == '__main__': socketio.run(app, debug=True)
# templates/runtime/dash-3-click-events 'leftgraph': [graph('bubbles')], 'rightgraph': [graph('line-chart')] }, name ) @app.route('/') def index(): return render_template('layouts/layout_two_column_and_controls.html', app_name=name) @socketio.on('pong') def onpong(app_state): messages = dash.on_pong(app_state) emit('postMessage', json.dumps(messages, cls=plotly.utils.PlotlyJSONEncoder)) @socketio.on('replot') def replot(app_state): print app_state messages = dash.replot(app_state) emit('postMessage', json.dumps(messages, cls=plotly.utils.PlotlyJSONEncoder)) if __name__ == '__main__': socketio.run(app, host='0.0.0.0', port=9999)
# # Work out logic to prevent people from rating movies twice. # if rating: print("was the error here?") cur.execute(insertRateQuery, (session['id'], movieID['id'], rating)) db.commit() except Exception as e: print(e) else: pass if review: try: cur.execute(insertReviewQuery, (movieID['id'], session['id'], review)) except Exception as e: print(e) else: pass return redirect(url_for('index')) # start the server if __name__ == '__main__': socketio.run(app, host=os.getenv('IP', '0.0.0.0'), port =int(os.getenv('PORT', 8080)), debug=True)
""" @socketio.on('connect') def test_connect(): emit('my response', {'data': 'Connected', 'count': 0}) """ @socketio.on('disconnect') def test_disconnect(): print('Client disconnected') if __name__ == "__main__": # ces treads seront à lancer lors de la connection du premier client (qui sera alors host auto-proclamé) thread = None thread2 = None if thread is None: thread = Thread(target=backup_thread) thread.start() if thread2 is None: thread2 = Thread(target=fireflies_thread) thread2.start() #fireflies = [] #print fireflies socketio.run(app, port=7777)
@socketio.on('temperatureChange', namespace='/gpio') def handleTemperatureChange(data): roomId = data['roomId'] state = data['state'] pins['temperature'][roomId][1]['overallState'] = state emit('serverResponse', { 'type': 'temperature', 'roomId': roomId, 'state': pins['temperature'][roomId][1]['overallState'] }, broadcast=True) print "Temp change!" return @app.route("/") def index(): return render_template('index.html') def signalHandler(signal, frame): GPIO.cleanup() sys.exit(0) signal.signal(signal.SIGINT, signalHandler) if __name__ == "__main__": socketio.run(app, host='0.0.0.0')
# Load downloads module if enabled if prem_config.getboolean('downloads', 'download_enabled'): from pySmartDL import SmartDL # Load copylinks to clipboard module if enabled if prem_config.getboolean('downloads', 'copylink_toclipboard'): import pyperclip # Start the watchdog if watchdir is enabled if prem_config.getboolean('upload', 'watchdir_enabled'): observer = Observer() observer.schedule(MyHandler(), path=prem_config.get('upload', 'watchdir_location')) observer.start() # start the server with the 'run()' method if __name__ == '__main__': load_tasks() scheduler = APScheduler(GeventScheduler()) scheduler.init_app(app) scheduler.scheduler.add_job(update, 'interval', id='update', seconds=prem_config.getint( 'global', 'active_interval'), max_instances=1) scheduler.start() socketio.run(app, port=prem_config.getint('global', 'server_port'))
@app.route('/') def main(): return render_template('main.html') @app.route('/pymeetups/') def pymeetups(): return render_template('pymeetups.html') @socketio.on('connect', namespace='/dd') def ws_conn(): c = db.incr('connected') socketio.emit('msg', {'count': c}, namespace='/dd') @socketio.on('disconnect', namespace='/dd') def ws_disconn(): c = db.decr('connected') socketio.emit('msg', {'count': c}, namespace='/dd') @socketio.on('city', namespace='/dd') def ws_city(message): print(message['city']) socketio.emit('city', {'city': cgi.escape(message['city'])}, namespace="/dd") if __name__ == '__main__': socketio.run(app, "0.0.0.0", port=5000)
# store document document = mongo.send(message, sender_pair, recipient, collection) # send Updates document_tidy = { "sender": document['sender'], "recipient": document['recipient'], "data": document['data'], "ts": document['ts'] } util.emit_to_relevant_sockets(request, document_tidy, live_sockets) @socketio.on('disconnect') def disconnect(): # if socket is listening if request.sid in all_listeners: # remove from listeners all_listeners[request.sid].connected = False del all_listeners[request.sid] ### Here starts the admin-only functions. Make sure you check user['isAdmin']! ### Here ends the admin-only functions. Make sure you check user['isAdmin']! ### Here ends the auth-only functions. Make sure you check their session cookies! if __name__ == "__main__": # app.run(debug=True) socketio.run(app, debug=True)
width=camera_size[0], height=camera_size[1]) @socketio.on('stream') def stream(camera_id): if camera_id not in cameras: cameras[camera_id] = Camera(camera_id=camera_id, size=camera_size, fps=config.get('cameras', 'fps')) camera = cameras[camera_id] data = { 'id': camera_id, 'raw': 'data:image/jpeg;base64,' + base64.b64encode(camera.get_frame()), 'timestamp': time.time() } emit('frame', data) if __name__ == '__main__': socketio.run(app, host=config.get('server', 'host'), port=config.getint('server', 'port'), policy_server=False, transports='websocket, xhr-polling, xhr-multipart')
emit('globe_data', [randint(0,90), randint(0,90)]) #print 'globe' @socketio.on('input_broadcast_event', namespace='/app') def word_cloud_broadcast(msg): emit('input_broadcast', {'data': msg['data']}) @socketio.on('input_event', namespace='/app') def word_cloud(msg): if len(msg['data'].split()) == 1: limit = 20 # Not more than `limit` antonyms and synonyms antonyms = get_antonyms(msg['data'], limit) synonyms = get_synonyms(msg['data'], limit) words = map(lambda x: {'text': x, 'flag': 1, 'size': randint(10,50)}, synonyms) words.extend(map(lambda x: {'text': x, 'size': randint(10,50)}, antonyms)) else: words = map(lambda x: {'text': x, 'flag': choice([0, 1]), 'size': randint(10,50)}, re.findall("[a-zA-Z\d]+", msg['data'])) emit('input', {'words': words}) @socketio.on('input_broadcast_event', namespace='/app') def test_message(msg): emit('input_broadcast', {'data': msg['data']}, broadcast=True) @socketio.on('disconnect', namespace='/app') def disconnect(): print('Client disconnected!') if __name__ == '__main__': socketio.run(app, debug=True, port=port)
@socketio.on('disconnect', namespace='/deploy') def deploy_disconnect(): pass @app.before_first_request def setup_logging(): logger = logging.getLogger('werkzeug') logger.setLevel(logging.INFO) for handler in logger.handlers: logger.removeHandler(handler) handler = logging.StreamHandler() handler.setFormatter(logging.Formatter("[shipui] %(levelname)s %(message)s")) handler.setLevel(logging.INFO) logger.addHandler(handler) if __name__ == "__main__": try: # Start a new thread which sends the log by websockets t = LogEmitter(app, socketio) t.start() socketio.run(app, host="0.0.0.0", debug=True) except KeyboardInterrupt: t.join() print "bye"
info['publish_date'] = info['publish_date'].strftime('%Y-%m-%d') return predict_power_info @socketio.on('my model', namespace='/index') def get_data_model(): data_model = gateway_model.get_gateway_model(session.get("gateway_id")) admin_uri = None env_str = os.getenv("VCAP_APPLICATION", "") if data_model: if env_str: env_dict = json.loads(env_str) uris = env_dict.get("application_uris", None) if uris: admin_uri = uris[0].split(".") admin_uri[0] = "smarthome-adminportal" admin_uri = ".".join(admin_uri) else: admin_uri = "localhost:4000" emit( 'my model resp', "http://" + admin_uri + "/images/model/" + data_model['data_model']['name'] + ".png" if data_model and admin_uri else data_model) if __name__ == '__main__': logger = logsettings.setup_log() logger.info('init SMART HOME project ...') port = os.getenv('PORT', '3000') socketio.run(app, debug=False, port=int(port), host="0.0.0.0")
for i, alert in enumerate(HomeSurveillance.alerts): with HomeSurveillance.alertsLock: alertData = {'alert_id': alert.id , 'alert_message': "Alert if " + alert.alertString} #print alertData app.logger.info(alertData) alerts.append(alertData) systemData = {'camNum': len(HomeSurveillance.cameras) , 'people': HomeSurveillance.peopleDB, 'cameras': cameras, 'alerts': alerts, 'onConnect': True} socketio.emit('system_data', json.dumps(systemData) ,namespace='/surveillance') @socketio.on('disconnect', namespace='/surveillance') def disconnect(): #print('Client disconnected') app.logger.info("Client disconnected") if __name__ == '__main__': # Starts server on default port 5000 and makes socket connection available to other hosts (host = '0.0.0.0') formatter = logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s") handler = RotatingFileHandler(LOG_FILE, maxBytes=1000000, backupCount=10) handler.setLevel(logging.DEBUG) handler.setFormatter(formatter) app.logger.addHandler(handler) app.logger.setLevel(logging.DEBUG) log = logging.getLogger('werkzeug') log.setLevel(logging.DEBUG) log.addHandler(handler) socketio.run(app, host='0.0.0.0', debug=False, use_reloader=False)
'people': HomeSurveillance.peopleDB, 'cameras': cameras, 'alerts': alerts, 'onConnect': True } socketio.emit('system_data', json.dumps(systemData), namespace='/surveillance') @socketio.on('disconnect', namespace='/surveillance') def disconnect(): #print('Client disconnected') app.logger.info("Client disconnected") if __name__ == '__main__': # Starts server on default port 5000 and makes socket connection available to other hosts (host = '0.0.0.0') formatter = logging.Formatter( "%(asctime)s - %(name)s - %(levelname)s - %(message)s") handler = RotatingFileHandler(LOG_FILE, maxBytes=1000000, backupCount=10) handler.setLevel(logging.DEBUG) handler.setFormatter(formatter) app.logger.addHandler(handler) app.logger.setLevel(logging.DEBUG) log = logging.getLogger('werkzeug') log.setLevel(logging.DEBUG) log.addHandler(handler) socketio.run(app, host='0.0.0.0', debug=False, use_reloader=False)
rtk.readConfigBase() @socketio.on("write config base", namespace="/test") def writeConfigBase(json): rtk.writeConfigBase(json) @socketio.on("update reachview", namespace="/test") def updateReachView(): print("Got signal to update!!!") print("Server interrupted by user to update!!") socketio.server.stop() os.execl("/home/reach/ReachView/update.sh", "", str(os.getpid())) if __name__ == "__main__": try: socketio.run(app, host = "0.0.0.0", port = 80) except KeyboardInterrupt: print("Server interrupted by user!!") # clean up broadcast and blink threads rtk.server_not_interrupted = False rtk.led.blinker_not_interrupted = False if rtk.coordinate_thread is not None: rtk.coordinate_thread.join() if rtk.satellite_thread is not None: rtk.satellite_thread.join() if rtk.led.blinker_thread is not None: rtk.led.blinker_thread.join()
global shell try: cmd = msg['data'].lower() output = '> %s\n' % cmd output += shell.execute(cmd) emit('client_recv', {'data': output}) except Exception as e: emit('client_recv', {'data': 'ERROR: an exception occurred'}) shell.logging = False print '[error]', e @socketio.on('client_connect') def term_connect(): emit('client_recv', {'data': '[connect]'}) if __name__ == '__main__': if app.debug: tests = [ 'bin', '/bin', 'bin/', '/bin/', 'etc', '/etc', 'etc/', '/etc/' 'bin/..', '/bin/..', 'bin/../', '/bin/../', '..', '/..', '../', '/../', '.', '/.', './', '/./', '/var/www/ecwi', '/var/www/ecwi/', '/', '.flag', '/.flag', '.flag/', '/.flag/', 'bin/../.flag', '/bin/../.flag', './.flag', '../termroot/.flag', '/var/www/ecwi/term/termroot/.flag' ] for t in tests: sanitise_filename(t, True) socketio.run(app, host='0.0.0.0', port=9447)
'state': None, }) def run_game(): global worker_manager print("Running game...") my_map = map_generator.generate_map(10, 10, 0.1) player_manager = AvatarManager() game_state = GameState(my_map, player_manager) turn_manager = TurnManager(game_state=game_state, end_turn_callback=send_world_update) WorkerManagerClass = WORKER_MANAGERS[os.environ.get('WORKER_MANAGER', 'local')] worker_manager = WorkerManagerClass(game_state=game_state, users_url=os.environ.get('GAME_API_URL', 'http://localhost:8000/players/api/games/')) worker_manager.start() turn_manager.start() if __name__ == '__main__': logging.basicConfig(level=logging.DEBUG) socketio.init_app(app, resource=os.environ.get('SOCKETIO_RESOURCE', 'socket.io')) run_game() socketio.run( app, debug=False, host=sys.argv[1], port=int(sys.argv[2]), use_reloader=False, )
# #@app.route('/redis_key/<string:key>') #def get_redis_key(key): # return str(r.lrange(key,0,-1)) # #@app.route('/redis_info') #def redis_info(): # return jsonify(r.info()) # #@app.route('/flush_all') #def flush_all(): # r.flushall() # return jsonify(r.info()) # #@app.route('/info123') #def info123(): # return os.environ['VCAP_SERVICES'] ## if os.environ.get('VCAP_SERVICES') is None: # running locally PORT = 8080 DEBUG = True redis_service_name = None else: # running on CF PORT = int(os.getenv("PORT")) DEBUG = False redis_service_name = 'rediscloud' r = helper_functions.connect_redis_db(redis_service_name) socketio.run(app, host='0.0.0.0', port=PORT, debug=DEBUG)
""" @socketio.on('model::GYRO_STREAM', namespace='/model') def heart_gyro_receiver(message): r = redis.Redis(connection_pool=p) # Publish data on Redis PUB-SUB Channel r.publish('model::GYRO_STREAM', message) # Broadcast data to all connected clients emit('model::GYRO_STREAM', message, broadcast=True) @socketio.on('model::ACCEL_STREAM', namespace='/model') def heart_gyro_receiver(message): r = redis.Redis(connection_pool=p) # Publish data on Redis PUB-SUB Channel r.publish('model::ACCEL_STREAM', message) # Broadcast data to all connected clients emit('model::ACCEL_STREAM', message, broadcast=True) @socketio.on('model::COMMANDS', namespace='/model') def heart_commands_receiver(message): r = redis.Redis(connection_pool=p) # Publish data on Redis PUB-SUB Channel r.publish('model::COMMANDS', message) # Broadcast data to all connected clients emit('model::COMMANDS', message, broadcast=True) if __name__ == '__main__': socketio.run(app, host="0.0.0.0")
return link @socketio.on('joined', namespace='/chat') def joined(message): """Sent by clients when they enter a room. A status message is broadcast to all people in the room.""" room = session.get('room') join_room(room) print "joined" emit('status', {'msg': session.get('name') + ' has entered the room.'}, room=room,namespace='/chat') @socketio.on('disp', namespace='/chat') def ws_city(message): print message['disp'] print "jouned new" fina = check(message['disp']) room = session.get('room') print room emit('disp', {'nam': session.get('name')+': ','disp' :fina},room = room,namespace='/chat') @socketio.on("type",namespace='/chat') def auto_print(message): room = session.get('room') print ">>>>>>>>>>>>>>>>>>>>>>"+str(room) emit("atype",{'name':session.get('name')+" is typing ....",'press':message['press']},room=room,namespace='/chat') if __name__ == '__main__' : socketio.run(app,host='0.0.0.0',port=5000,debug=True) #app.run(debug=True)
return render_template('rsvp.html', guests=results, username=username) return render_template('rsvp2.html', guests=results, username=username) @socketio.on('joinRoom', namespace='/chat') def on_join(roomname): print "Joining room" oldroom = session['roomname'] username = session['username'] conn = connectToMessageDB() cur = conn.cursor(cursor_factory=psycopg2.extras.DictCursor) session['roomname'] = roomname leave_room(oldroom) join_room(roomname) cur.execute("SELECT * FROM messages WHERE room = %s;", (roomname,)) messages = cur.fetchall() for message in messages: emit('message', message) # start the server if __name__ == '__main__': socketio.run(app, host=os.getenv('IP', '0.0.0.0'), port =int(os.getenv('PORT', 8080)), debug=True)
def checkSerial(): while True: try: data = port.readline() if data: socketio.emit('my response', {'data':data}, namespace='/imin') sleep(0.3) sleep(0.1) except UnicodeDecodeError: print "uni error" except Exception e: print "exception" @app.route('/') def index(): return render_template('index.html') @app.route('/scripts/<path:filename>') def serve_js(filename): return send_from_directory('./scripts', filename) @socketio.on('connect', namespace='/imin') def test_connect(): print "whooo" emit('my response', {'data': 'Connected'}) if __name__ == "__main__": t1 = Thread(target=checkSerial) t1.start() socketio.run(app,"0.0.0.0",5555)
state = data['state'] pins['temperature'][roomId][1]['overallState'] = state emit('serverResponse', { 'type': 'temperature', 'roomId': roomId, 'state': pins['temperature'][roomId][1]['overallState'] }, broadcast=True) print "Temp change!" return @app.route("/") def index(): return render_template('index.html') def signalHandler(signal, frame): GPIO.cleanup() sys.exit(0) signal.signal(signal.SIGINT, signalHandler) if __name__ == "__main__": socketio.run(app, host='0.0.0.0')
# import json app = Flask(__name__) socketio = SocketIO(app) event_name = 'tieba_dig' @app.route('/') def index(): return render_template('index.html') @socketio.on(event_name) def handle_search_para(para): print para print type(para['rep_num']) posts = [] try: query = Query(para) print 'done' posts = query.find() except StandardError, e: print e emit(event_name, posts) if __name__ == '__main__': socketio.run(app, host='0.0.0.0', port=8888) else: from bae.core.wsgi import WSGIApplication application = WSGIApplication(socketio)
@app.route('/api/query/<string:query_id>/free', methods=['PUT']) @pyclient.decorators.api_err_handler(True) def free_query(query_id): client.free_query(query_id) return json.dumps({'success': True}) @socketio.on('connect', namespace='/api/query/notifications') def test_connect(): print('Client connected') @socketio.on('disconnect', namespace='/api/query/notifications') def test_disconnect(): print('Client disconnected') ## @app.route('/') def static_proxy_index(): return app.send_static_file(os.path.join('app', 'index.html')) @app.route('/<path:path>') def static_proxy(path): # send_static_file will guess the correct MIME type return app.send_static_file(os.path.join('app', path)) if __name__ == "__main__": #app.run(processes=10, host='0.0.0.0', port=8915) socketio.run(app, host='0.0.0.0', port=8915)
if password_sha == user.login(username): gateway_id = user.user_gatewayid(username) # url = user.user_url(username) session['gateway_id'] = str(gateway_id) session['username'] = username info = 'Welcome ' + username print info resp = make_response(redirect(url_for('index'), code=302)) resp.set_cookie('JSESSIONID', 'Sticky session.') return resp else: info = 'Username or password are incorrect' return render_template('login.html', info=info, static_url_prefix=static_url_prefix) @app.route('/logout') def logout(): session.pop('gateway_id', None) session.pop('username', None) resp = make_response(redirect(url_for('login'), code=302)) resp.set_cookie('__VCAP_ID__', '', expires=0) return resp if __name__ == '__main__': logger = logsettings.setup_log() logger.info('init SMART HOME project ...') port = os.getenv('PORT', '3000') socketio.run(app, debug=False, port=int(port), host="0.0.0.0")
@socketio.on('init_projection', namespace='/elderberry') def initial_projection(message): print('asd') view,desc, imp,cs = get_random_view() print(len(desc),len(view)) urls = get_urls() data = [list(view[i])+[desc[i]] for i in range(len(view))] ranking = [[int(imp[i][0]),float(imp[i][1])] for i in range(len(imp))] #print(data, ranking) print("ASAAAAA",cs) emit('projection', {'data': data, 'ranking': ranking, 'urls':urls, 'classes':cs}) @socketio.on('request_points', namespace='/elderberry') def request_points(message): print(message) emit('new_points', {'visible_indices': get_points(message['num'], message['visible_indices'], message['algorithm'])}, broadcast=True) @socketio.on('connect', namespace='/elderberry') def test_connect(): print('Client connected') emit('my response', {'data': 'Connected'}) @socketio.on('disconnect', namespace='/elderberry') def test_disconnect(): print('Client disconnected') if __name__ == '__main__': app.debug=True socketio.run(app,host='0.0.0.0',port=3797)
target=alarm_state, args=()) thread1.start() if not thread2.isAlive(): print "Starting Thread2" thread2 = threading.Thread(name='websocket_process_thread_', target=update_faces, args=()) thread2.start() systemData = { 'camNum': len(Home_Surveillance.cameras), 'people': Home_Surveillance.peopleDB } socketio.emit('system_data', json.dumps(systemData), namespace='/test') #emit('my response', {'data': 'Connected'}) @socketio.on('disconnect', namespace='/test') def test_disconnect(): print('Client disconnected') if __name__ == '__main__': # # app.run(host='0.0.0.0', debug=True) socketio.run( app, host='0.0.0.0', debug=True, use_reloader=False ) #starts server on default port 5000 and makes socket connection available to other hosts (host = '0.0.0.0')
if str(address) in addresses: addresses[str(address)] += 1 else: addresses[str(address)] = 1 if str(address) not in session['addresses']: session['addresses'].append(str(address)) if len(addresses) > maxaddresses: maxaddresses = len(addresses) #speed up initial data load balance_data = get_balancedata(address) emit('address:' + address, balance_data, namespace='/balance') @socketio.on("address:refresh", namespace='/balance') def refresh_address(message): global addresses address = message['data'] if str(address) in addresses: balance_data = get_balancedata(address) emit('address:' + address, balance_data, namespace='/balance') else: add_address(message) if __name__ == '__main__': socketio.run(app, '127.0.0.1', 1091)
twit.login() cityName = twit.getUserTweets() print cityName socketio.emit('newnumber', {'number': cityName}, namespace='/test') sleep(self.delay) def run(self): self.tweetFinder() @application.route('/') def index(): return render_template('index.html') @socketio.on('connect', namespace='/test') def test_connect(): # need visibility of the global thread objects print "We're working" global thread print('Client connected') if not thread.isAlive(): print "Starting Thread" thread = RandomThread() thread.start() if __name__ == '__main__': socketio.run(application)
def get_env(): while True: time.sleep(1) socketio.emit('receive_weather', {'temperature': temperature, 'humidity': humidity, 'pressure': pressure}, namespace='receive_weather') @app.route('/receive_weather') def receive_weather(): threading = None threading = Thread(target=get_env) threading.run() return render_template('get_env.html') @app.route('/query') def query(): env = Environment.query.all() soil = Soil.query.all() env_query = [] soil_query = {} for r in range(len(env)): env_query.append(env[r].serialize) #env_query['Query '+str(r)] = env[r].serialize for s in range(len(soil)): soil_query['Query ' + str(s)] = soil[s].serialize return render_template('query.html', Environment_data=env_query, Soil_data=soil_query) if __name__ == '__main__': socketio.run(app)
def which_quadrant(self, horiz, vert): quad = 0 print("vert:%s horiz:%s" % (horiz, vert)) if ((horiz > self.neutral) and (vert < self.neutral)): quad = 1 # ahead right print("Quad 1 vert:%s horiz:%s" % (horiz, vert)) if ((horiz < self.neutral) and (vert < self.neutral)): quad = 2 # ahead left print("Quad 2 vert:%s horiz:%s" % (horiz, vert)) if ((horiz < self.neutral) and (vert > self.neutral)): quad = 3 # behind left print("Quad 3 vert:%s horiz:%s" % (horiz, vert)) if ((horiz > self.neutral) and (vert > self.neutral)): quad = 4 # behind right print("Quad 4 vert:%s horiz:%s" % (horiz, vert)) if ((horiz < 20) and (vert > 115) and (vert < 140)): quad = 5 print("Spin Left!") if ((horiz > 230) and (vert > 115) and (vert <140)): quad = 6 print("Spin Right!") if ((horiz > self.neutral_min) and (horiz < self.neutral_max) and (vert > self.neutral_min) and (vert < self.neutral_max)): quad = 0 # overwrite the neutral square print("Quad 0 vert:%s horiz:%s" % (horiz, vert)) return quad if __name__ == '__main__': socketio.run(app,port=8081)
def print_client_version(message): print("client version:" + message["version"]) @socketio.on('disconnect') def test_disconnect(): print('CLIENT DISCONNECTED') @socketio.on("entites_received") def entities_received(): print("CLIENT RECEIVED ENTITIES") #------------------------------------------------------------ config = { "consumer_key": consumer_key, "consumer_secret": consumer_secret, "access_token": access_token, "access_token_secret": access_token_secret, "keywords": ['acorn', 'stanford', 'midterm', 'lawnmower', 'fox news', 'usc'], "languages": ["en"] } streamWorker = StreamWorker(config, socketio) main = threading.Thread(target=streamWorker.run) main.start() if __name__ == "__main__": socketio.run(app, host="0.0.0.0", port=8000)
## WEBSERVER STATIC ## # make al /static/ folder available @app.route('/') def root(): return app.send_static_file('index.html') @app.route('/<path:path>') def static_proxy(path): return app.send_static_file(path) ## SOCKET.IO CONNECTION ## # make al /static/ folder available @socketio.on('connect') def connected(): print(">>>>>>>>>>>>>>>>>>>>>>>>>>> connect") emit('msg', {'data': 'Conooooooooooooonected'}) # Data in from browser, JSON format @socketio.on('api') def api(data): print('received api request ' + data) # Message, info or debug information @socketio.on('msg') def message(message): print('received message: ' + message) if __name__ == '__main__': app.debug = True socketio.run(app, port=5000)
def get_public_events(): events = {} for u in USERS: hub_user = hub.get_user('mfwarren') events[u] = hub_user.get_public_events()[0].raw_data return events def background_thread(): while True: events = get_public_events() socketio.emit('response', {'data': 'events', 'events': events}, namespace='') time.sleep(30) @app.route('/') def index(): global thread if thread is None: thread = Thread(target=background_thread) thread.start() return render_template('github_index.html') @socketio.on('event') def message(message): pass # need side effects from having this here if __name__ == '__main__': socketio.run(app)
class NickForm(Form): name = StringField('Nickname: ', validators=[Required()]) submit = SubmitField('Set Nickname') @app.route('/chat') def chat(): if session.get('nick') != None: return render_template('index.html', nickname=session.get('nick')) else: return redirect(url_for('index')) @app.route('/', methods=['GET', 'POST']) def index(): if session.get('nick') != None: return redirect(url_for('chat')) form = NickForm() if form.validate_on_submit(): session['nick'] = form.name.data form.name.data = "" return redirect(url_for('chat')) return render_template('nick.html', form=form) @ws.on('message sent') def message_sent(message): emit('broadcast', message, broadcast=True) if __name__ == '__main__': ws.run(app)
data = {"error": "INVALID_CHALLENGE_ID"} code = 400 else: if request.form["accept"] == "true" or request.form["accept"] == True: code = 200 data = {"msg": "OK"} challenges[challengeID].status = "accepted" elif request.form["accept"] == "false" or request.form["accept"] == False: code = 200 data = {"msg": "OK"} challenges[challengeID].status = "declined" else: data = {"error": "BAD_REQUEST"} code = 400 return jsonify(data), code @app.route("/api/challenges/<int:challengeID>", methods=["GET"]) def api_get_challenge_status(challengeID): if challengeID not in challenges: data = {"error": "INVALID_CHALLENGE_ID"} code = 400 else: challenge = challenges[challengeID] data = {"challenge": challenge.__dict__} code = 200 return jsonify(data), code if __name__ == "__main__": #check_keepalive_users() socketio.run(app, host="0.0.0.0")
traci.init(PORT) def sim(): step = 0 while step < 86400: traci.simulationStep() xy=[] vehicles = traci.vehicle.getIDList() for v in vehicles: x=112.96771+(traci.vehicle.getPosition(v)[0]+1509.33)/98838.1145 y=28.193671+(traci.vehicle.getPosition(v)[1]-105.97)/106287.597 xy.append([x,y]) return xy time.sleep(10) step += 10 traci.close() @socketio.on('update') def update_view(message): #print message[data] emit('test', sim(), broadcast=True) @app.route('/') def sumo(): init() return render_template('sumo2.html') if __name__ == "__main__": app.debug = True socketio.run(app, host='127.0.0.1',port=5000)