Python SocketIO.run方法代码示例

# 需要导入模块: from flask_socketio import SocketIO [as 别名]
# 或者: from flask_socketio.SocketIO import run [as 别名]
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)

# 需要导入模块: from flask_socketio import SocketIO [as 别名]
# 或者: from flask_socketio.SocketIO import run [as 别名]
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)

# 需要导入模块: from flask_socketio import SocketIO [as 别名]
# 或者: from flask_socketio.SocketIO import run [as 别名]
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)

# 需要导入模块: from flask_socketio import SocketIO [as 别名]
# 或者: from flask_socketio.SocketIO import run [as 别名]
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)

# 需要导入模块: from flask_socketio import SocketIO [as 别名]
# 或者: from flask_socketio.SocketIO import run [as 别名]
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

# 需要导入模块: from flask_socketio import SocketIO [as 别名]
# 或者: from flask_socketio.SocketIO import run [as 别名]
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)

# 需要导入模块: from flask_socketio import SocketIO [as 别名]
# 或者: from flask_socketio.SocketIO import run [as 别名]
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'])

# 需要导入模块: from flask_socketio import SocketIO [as 别名]
# 或者: from flask_socketio.SocketIO import run [as 别名]
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)

# 需要导入模块: from flask_socketio import SocketIO [as 别名]
# 或者: from flask_socketio.SocketIO import run [as 别名]
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)

# 需要导入模块: from flask_socketio import SocketIO [as 别名]
# 或者: from flask_socketio.SocketIO import run [as 别名]
def entry_point():

    # Graceful shutdown when kill are received
    signal.signal(signal.SIGTERM, lambda sig, frame: shutdown())

    # Graceful shutdown when terminal session are closed
    signal.signal(signal.SIGHUP, lambda sig, frame: shutdown())

    main()

    try:

        _config = settings.get_config_file()

        app.config['SECRET_KEY'] = _config.get('server', 'cookie_secret_key')
        app.config['DEBUG'] = _config.getboolean('server', 'debug', fallback=True)

        from scrapy_eagle.dashboard.views import servers, processes, root, jobs, react_app

        app.register_blueprint(root.root, url_prefix='/')
        app.register_blueprint(react_app.react_app, url_prefix='/app')
        app.register_blueprint(servers.servers, url_prefix='/servers')
        app.register_blueprint(processes.processes, url_prefix='/processes')
        app.register_blueprint(jobs.jobs, url_prefix='/jobs')

        CORS(app)

        socketio = SocketIO(app, async_mode='gevent')

        start_periodics(socketio)

        # use_reloader: avoid Flask execute twice
        socketio.run(
            app=app,
            host=_config.get('server', 'host', fallback='0.0.0.0'),
            port=_config.getint('server', 'port', fallback=5000),
            use_reloader=False
        )

    except (KeyboardInterrupt, SystemExit):

        shutdown()

# 需要导入模块: from flask_socketio import SocketIO [as 别名]
# 或者: from flask_socketio.SocketIO import run [as 别名]
    def run_socket_server(self):
        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(self.bot, socketio, state, self.event_manager)
        UiEvents(self.bot, socketio, state, self.event_manager, self.logger)

        self.log("Starting socket server...")

        socketio.run(
            app,
            host=self.config['socket_server']['host'] or '0.0.0.0',
            port=self.config['socket_server']['port'] or 8080,
            debug=False,
            use_reloader=False,
            log_output=False
        )

# 需要导入模块: from flask_socketio import SocketIO [as 别名]
# 或者: from flask_socketio.SocketIO import run [as 别名]
class Listener():
    def __init__(self, generator_domain):
        self.generator_domain = generator_domain

    def find_generator_by_url(self, url):
        return generators.find_generator_by_url(url)

    def on(self, url, callback):
        generator = self.find_generator_by_url(url)
        generator.set_callback(callback)

    def emit(self, url, callback):
        generator = self.find_generator_by_url(url)
        #dictToSend = {'question':'what is the answer?', 'data':[1,2,3]}
        # res = requests.post(self.generator_domain+'/'+url, json=dictToSend)
        try:
            res = requests.post(self.generator_domain+'/'+url)
            callback(np.array(res.json()))
        except:
            callback({ "err": "post to dategenerator from listener failed!"})

    def run(self, app, debug, port, host):
        self.init_routers(app)
        self.socketio = SocketIO(app)
        return self.socketio.run(app, debug=debug, port=port, host=host)

    def init_routers(self, app):
        @app.route('/', defaults={'url': ''})
        @app.route('/<path:url>', methods=['GET', 'POST'])
        def catch_url_generator_request(url):
            if(request.method == 'POST'):
                generator = self.find_generator_by_url(url)
                if(generator is None):
                    return 'no url match with a datagenerator!'
                else:
                    generator.execute_callback(np.array(request.json))
                    return 'data transfered to client listener!'
            else:
                return generators.handle('listener', url)

# 需要导入模块: from flask_socketio import SocketIO [as 别名]
# 或者: from flask_socketio.SocketIO import run [as 别名]
    socketio.emit('my response',
                      {'data': 'Falling', 'count': count, 'date': str(led_state)},
                      namespace='/test')
    
GPIO.add_event_detect(pin,GPIO.FALLING,callback = eventgpio,bouncetime = 100)

@app.route('/')
def index():
    """Renders the home page."""
    return render_template(
            'device.html',
            title='Home Page',
            year=datetime.now().year,
    )


@socketio.on('my event', namespace='/test')
def test_message(message):
    session['receive_count'] = session.get('receive_count', 0) + 1
    emit('my response',
         {'data': message['data'], 'count': session['receive_count'], 'date': str(datetime.now().time())})


@socketio.on('connect', namespace='/test')
def test_connect():
    emit('my response', {'data': 'Connected', 'count': 0, 'date': str(datetime.now().time())})


if __name__ == '__main__':
    socketio.run(app, host = '0.0.0.0')

# 需要导入模块: from flask_socketio import SocketIO [as 别名]
# 或者: from flask_socketio.SocketIO import run [as 别名]
    if (data['resp'] == "Accept"):
        print data['from'] + " has accepted trade offer."
    else:
        print "Rejected trade offer"

# {
#     'name': 'neko' (Player name)
# }
@socketio.on('leave')
def leave(data):
    name = data['name']
    global game
    if game is not None:
        game.playerLeft(name)
    
    print name + ' has left!'

    global player_names
    player_names.remove(name)

    leave_room(room)
    emit('playerLeft', player_names, room=room)


@socketio.on('disconnect')
def disconnect():
    print('Client disconnected', request.sid)

if __name__ == '__main__':
    socketio.run(app, debug=True, host='0.0.0.0')

# 需要导入模块: from flask_socketio import SocketIO [as 别名]
# 或者: from flask_socketio.SocketIO import run [as 别名]
@socketio.on("my_room_event", namespace="/trape")
def send_room_message(message):
    try:
        session['receive_count'] = session.get('receive_count', 0) + 1
        hookAction = attacks_hook_message(message['data']['type'])
        utils.Go(utils.Color['white'] + "[" + utils.Color['blueBold'] + "@" + utils.Color['white'] + "]" + " " + hookAction + utils.Color['blue'] + message['data']['message'] + utils.Color['white'] + ' in '  + utils.Color['green'] + message['room'] + utils.Color['white'])
        emit('my_response', {'data': message['data'], 'count': session['receive_count']},room = message['room'])
    except Exception as error:
        pass

@socketio.on("disconnect_request", namespace="/trape")
def disconnect_request(d):
    try:
        session['receive_count'] = session.get('receive_count', 0) + 1
        emit('my_response', {'data': 'Disconnected!', 'count': session['receive_count']})
        utils.Go(utils.Color['white'] + "[" + utils.Color['redBold'] + "-" + utils.Color['white'] + "]" + utils.Color['red'] + " " + "A victim has closed her connection with the following id:" + " " + utils.Color['green'] + d['vId'] + utils.Color['white'])
        db.sentences_victim('disconnect_victim', d['vId'], 2)
    except Exception as error:
        pass

@socketio.on_error("/trape")
def error_handler(e):
    pass

@app.route("/" + trape.home_path)
def home():
    return render_template("home.html", async_mode=socketio.async_mode)

if __name__ == 'core.sockets':
    socketio.run(app, host= '0.0.0.0', port=trape.app_port, debug=False)