Python flask_socketio.SocketIO类代码示例

def run_flask():
    root_dir = os.path.join(os.getcwd(), 'web')
    app = Flask(__name__, static_folder=root_dir)
    app.use_reloader = False
    app.debug = False
    app.config["SECRET_KEY"] = "OpenPoGoBot"
    socketio = SocketIO(app, logging=False, engineio_logger=False)

    logging_buffer = []

    @app.route("/")
    def index():
        return app.send_static_file("index.html")

    @app.route('/<path:path>')
    def static_proxy(path):
        return app.send_static_file(path)

    @manager.on("logging")
    def logging_event(event_name, output, color):
        line = {"output": output, "color": color}
        logging_buffer.append(line)
        socketio.emit("logging", [line], namespace="/event")

    @socketio.on("connect", namespace="/event")
    def connect():
        emit("logging", logging_buffer, namespace="/event")
        logger.log("Client connected", "yellow", fire_event=False)

    @socketio.on("disconnect", namespace="/event")
    def disconnect():
        logger.log("Client disconnected", "yellow", fire_event=False)

    socketio.run(app, host="0.0.0.0", port=8000, debug=False, use_reloader=False, log_output=False)

class PServer():
    __metaclass__ = Singleton

    def __init__(self):
        # Flask Elements
        self.IO_SPACE = "/io"

        # self.test = "[TEST1]"

        self.app = Flask(__name__)
        self.app.config['DEBUG'] = False
        self.app.config['SECRET_KEY'] = "supersecret";

        # self.socketio = SocketIO(self.app)
        self.socketio = SocketIO(self.app, async_mode='threading')

    # LIttle spleeper
    def sleep_state(voice):
        time.sleep(SLEEP_TIME)

        self.send("sleep")
        logger.debug("WORKS")

        voice.stop_all()
        self.is_sleeping = True

    def send(self, event, data=""):
        lock.acquire(True)
        self.socketio.emit(event, data, namespace="/io")
        lock.release()


    def start(self):
        print "[STARTING SERVERS]"

def main(**kwargs):
    opt = parse_cmdline()
    app = Flask('supcast.wsapp')
    app.config['SECRET_KEY'] = 'TODO: some secret?'
    socketio = SocketIO(app, async_mode='eventlet')
    eventlet.spawn(redis_listener, socketio)
    supcast.config.set_redis_url(opt.redis)
    socketio.run(app, host=opt.host, port=opt.port, **kwargs)

def socket_emit(meta=None, event='others'):
    try:
        socketio = SocketIO(message_queue=current_app.config['SOCKETIO_REDIS_URL'])
        socketio.emit(event, meta, namespace='/deyunio')
    except Exception as e:
        logger.warning('error in loading sitestatus ' + str(e))
        return {'failed': e}
    return {("sent " + str(event)) : meta}

def main():
    global socketio
    
    signal.signal(signal.SIGINT, signal_handler)
    
    print('Flask-SocketIO running...')
    app = Flask(__name__)
#    c = SimpleCache()
#    c.clear()
    Bootstrap(app)
    app.debug = False    
    socketio = SocketIO(app)

    ser = myComm.mySerial()
    net = myComm.myNet()
    
    @app.before_first_request
    def initialize():
        print('Called only once, when the first request comes in')
        ser.onMsg = onSerialMsg
#        ser.connect('COM3')
        ser.connect('COM5')
#        ser.connect('/dev/ttyACM0')
        net.onMsg = onNetMsg
#        net.connect('192.168.1.91', 12345)
        net.connect('10.0.0.4', 12345)
    
    @app.route('/')
    def index():
        print('Rendering index.html')
        return render_template('index.html')
    
    @app.route('/2')
    def index2():
        return render_template('index2.html')

    @app.route('/3')
    def index3():
        return render_template('index3.html')

    @socketio.on('ledACtrl', namespace='/test')
    def ledACtrl(message):
        print(message['led'])
        if message['led']:
            ser.sendMsg('l1')
        else:
            ser.sendMsg('l0')
    
    @socketio.on('ledRCtrl', namespace='/test')
    def ledRCtrl(message):
        print(message['led'])
        if message['led']:
            net.sendMsg('l1')
        else:
            net.sendMsg('l0')

    socketio.run(app, host = '0.0.0.0', port = 5001)

def new_server(viewer_queue, stop_page, port, secret_key):
    # create server
    app = Flask(__name__, static_url_path='/static')
    app.config['SECRET_KEY'] = secret_key
    # must be 'threading' for broadcast emitting
    socketio = SocketIO(app, async_mode='threading',
                        logger=False, engineio_logger=False)

    # rooting
    @app.route('/')
    def __index():
        logger.info('Render viewer page')
        return render_template('index.html', script="index.js")

    if stop_page:
        @app.route('/stop')
        def __stop():
            socketio.stop()
            logger.info('Server stop request')
            return 'This server is stopped'

    @socketio.on('connect', namespace=IO_NAMESPACE)
    def __on_viewer_connect():
        logger.info('New viewer connection is established')

    @socketio.on('disconnect', namespace=IO_NAMESPACE)
    def __on_viewer_disconnect():
        logger.info('Viewer connection is closed')

    @socketio.on('update', namespace=IO_NAMESPACE)
    def __on_update():
        logger.info('Image updating request is received')
        # get all of current data
        emit_data = buffering_thread.get_data_all()
        # emit all
        logger.debug('Emit for update all')
        emit('update', emit_data, namespace=IO_NAMESPACE)

    def update_event(tab, name, data):
        emit_data = [[tab, name, data]]  # single data
        # broadcast emit
        logger.debug('Broadcast emit for update (tab: %s, name: %s)' %
                     (str(tab), str(name)))
        socketio.emit('update', emit_data, namespace=IO_NAMESPACE)

    # create image updating thread
    if viewer_queue:
        logger.info('Start image buffering thread')
        buffering_thread = ImageBufferingThread(viewer_queue)
        buffering_thread.daemon = True
        buffering_thread.start()
        buffering_thread.register_update_event_func(update_event)

    # start server
    logger.info('Start server on port %d' % port)
    socketio.run(app, host='0.0.0.0', port=port, debug=False, log_output=False)
    logger.info('Stop server on port %d' % port)

def simulate(restaurant,sid):
    simsocket = SocketIO(message_queue=REDIS_URL)
    layout = json.loads(restaurant)
    print("making rdq here")
    rdq = RestaurantDayQueue(sid)
    print("rdq has been made")
    r = Restaurant("Sophie's Kitchen", layout["equipment"], layout["tables"], layout["staff"], day_log=rdq, verbose=False)
    r.simulate(days=int(layout["days"]))
    report = r.ledger.generate_final_report()
    simsocket.emit("sim_report", report, room=sid)

class RestaurantDayQueue(Queue):
    def __init__(self,room):
        self.room = room
        self.socketio = SocketIO(message_queue=REDIS_URL)
        super().__init__()
    def put(self, report, block=True, timeout=None):
        self.socketio.emit('day_report', report.get_report(),room=self.room)
        #print(report.get_report())
        super().put(report, block, timeout)
        self.socketio.sleep(0)

def front(port, working_dir, redis_host):
    """start the frontend server"""
    import eventlet
    eventlet.monkey_patch() # for flask_socketio message queue support
    from flask_socketio import SocketIO
    static = os.path.abspath(os.path.join(working_dir, 'static'))
    templs = os.path.abspath(os.path.join(working_dir, 'templates'))
    app = front_app(static_folder=static, template_folder=templs)
    socketio = SocketIO(app, message_queue=redis_host)
    socketio.run(app, host='0.0.0.0', port=port) # doesn't seem to work if debug=True

def run_socket_server():
    app = Flask(__name__)
    app.config["SECRET_KEY"] = "OpenPoGoBotSocket"
    socketio = SocketIO(app, logging=False, engineio_logger=False, json=myjson)

    state = {}

    botevents.register_bot_events(socketio, state)
    uievents.register_ui_events(socketio, state)

    socketio.run(app, host="0.0.0.0", port=8000, debug=False, use_reloader=False, log_output=False)

class SocketsHandler(logging.Handler):
    def emit(self, record):
        if not hasattr(self, 'socketio'):
            self.socketio = SocketIO(message_queue='redis://localhost:6379')
        try:
            # format: 'CHAN:DATA'
            chan, datastr = record.getMessage().split(':', 1)
            self.socketio.emit(chan, json.loads(datastr), namespace='/simulation')
        except (KeyboardInterrupt, SystemExit):
            raise
        except:
            self.handleError(record)

def self_test(x=16, y=16,url=None):
    x = int(x)
    y = int(y)
    res = x + y
    context = {"id": "test", "x": x, "y": y}
    result = "add((x){}, (y){})".format(context['x'], context['y'])
    goto = "{}".format(context['id'])
    time.sleep(10)
    meta = json.dumps({'result':result, 'goto':goto})
    #post(url, json=meta)
    socketio = SocketIO(message_queue='redis://localhost:6379/0')
    socketio.emit('connect', meta, namespace='/deyunio')
    return meta

def run_socket_server():
    app = Flask(__name__)
    app.config["SECRET_KEY"] = "OpenPoGoBotSocket"
    socketio = SocketIO(app, logging=False, engineio_logger=False, json=myjson)

    @app.route("/")
    def redirect_online():
        return redirect("http://openpogoui.nicontoso.eu")

    state = {}

    botevents.register_bot_events(socketio, state)
    uievents.register_ui_events(socketio, state)

    socketio.run(app, host="0.0.0.0", port=8000, debug=False, use_reloader=False, log_output=False)

def main():
    app = flask.Flask('espelhos_sonoros')
    app.config.from_object('config.Config')

    socketio = SocketIO(app, async_mode='threading')
    db = SQLAlchemy(app)

    espelhos_sonoros(app, socketio, db)

    app.logger.info('Started server.')

    if not app.config['DEBUG']:
        SSLify(app)

    socketio.run(app, host=app.config['HOST'], port=app.config['PORT'])

class Server(threading.Thread):

    def __init__(self, jukebox):
        threading.Thread.__init__(self)
        self.jukebox = jukebox


    def run(self):
        self.app = Flask(__name__)
        self.app.config['SECRET_KEY'] = 'secret!'
        self.socketio = SocketIO(self.app)

        @self.socketio.on('connect')
        def handle_connect():
            emit('newSong', self.jukebox.current_song_name)

        @self.socketio.on('playback')
        def handle_message(playback):
            if playback == "pause":
                self.jukebox.pause()
            elif playback == "play":
                self.jukebox.play()
            elif playback == "next":
                self.jukebox.play_next_song()
                return self.jukebox.current_song_name
            print(playback)

        @self.socketio.on('addToQueue')
        def handle_add_to_queue(song):
        	if self.jukebox.add_to_queue(song):
			return True
		else:
			return False

        @self.app.route("/")
        def index():
            return render_template("queue.html")

        @self.app.route("/playstyring")
	@requires_auth
        def control():
            return render_template("index.html")

        self.socketio.run(self.app, host='0.0.0.0', port=80)

    def new_song(self, song):
        with self.app.test_request_context('/'):
            self.socketio.send('newSong', song)