Python SocketIO.init_app方法代码示例

# 需要导入模块: from flask_socketio import SocketIO [as 别名]
# 或者: from flask_socketio.SocketIO import init_app [as 别名]
    def test_delayed_init(self):
        app = Flask(__name__)
        socketio = SocketIO(allow_upgrades=False, json=flask_json)

        @socketio.on('connect')
        def on_connect():
            send({'connected': 'foo'}, json=True)

        socketio.init_app(app, cookie='foo')
        self.assertFalse(socketio.server.eio.allow_upgrades)
        self.assertEqual(socketio.server.eio.cookie, 'foo')

        client = socketio.test_client(app)
        received = client.get_received()
        self.assertEqual(len(received), 1)
        self.assertEqual(received[0]['args'], {'connected': 'foo'})

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

    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,
    )

# 需要导入模块: from flask_socketio import SocketIO [as 别名]
# 或者: from flask_socketio.SocketIO import init_app [as 别名]
from flask_socketio import SocketIO
from pingpong.utils import assets
from pingpong.utils import logger

app = Flask(__name__)
app.config.from_pyfile("../config.cfg")

logger.setupLogging(app)

assets.setupAssets(app)

login_manager = LoginManager()
login_manager.init_app(app)

socketio = SocketIO()
socketio.init_app(app)

mail = Mail()
mail.init_app(app)

sess = Session()
sess.init_app(app)

app.url_map.strict_slashes = False

from pingpong.controllers.AdminController import adminController
from pingpong.controllers.ApiController import apiController
from pingpong.controllers.AuthenticationController import authenticationController
from pingpong.controllers.ErrorController import errorController
from pingpong.controllers.IsmController import ismController
from pingpong.controllers.CourtesyController import courtesyController

# 需要导入模块: from flask_socketio import SocketIO [as 别名]
# 或者: from flask_socketio.SocketIO import init_app [as 别名]
from flask_login import LoginManager
from flask_socketio import SocketIO
from flask_cors import CORS
from flask_mongoengine import MongoEngine
from delhivery.models import DelhiveryUser
from api.utils import get_notifications_for_dashboard
from app.settings import MONGODB_SETTINGS
import app.main_sockets as main_sockets
app = Flask(__name__)
app.secret_key = 'delhiverySECRET'
app.config['TEMPLATES_AUTO_RELOAD'] = True
app.config['MONGODB_SETTINGS'] = MONGODB_SETTINGS
app.config['WTF_CSRF_SECRET_KEY']="SECRETCSRFKEY"
CORS(app)
socketio = SocketIO(manage_session=False)
socketio.init_app(app,message_queue='redis://')
login_manager = LoginManager(app)
db = MongoEngine(app)
socketio.on_event('connect',main_sockets.connect)
socketio.on_event('create_room',main_sockets.create_room)
socketio.on_event('disconnect',main_sockets.disconnect)
socketio.on_event('send_message',main_sockets.send_message)
socketio.on_event('typing',main_sockets.typing_message)
socketio.on_event('no_longer_typing',main_sockets.no_longer_typing)
def notify_user(person_id):
    notifications = get_notifications_for_dashboard(person_id)
    socketio.emit('received_friend_request',notifications,room=person_id)


def refresh_online_friends(user_id):
    socketio.emit('refresh_online_friends',room = user_id)

# 需要导入模块: from flask_socketio import SocketIO [as 别名]
# 或者: from flask_socketio.SocketIO import init_app [as 别名]
t0 = time.time()

template_dir = os.path.join(os.path.dirname(__file__), "templates")
server = Flask(__name__,  static_url_path='', template_folder=template_dir)

server.debug = False
server.config['SESSION_TYPE'] = "redis"
server.config['SESSION_KEY_PREFIX'] = "mxcube:session:"
server.config['SECRET_KEY'] = "nosecretfornow"
server.register_error_handler(Exception, exception_handler)

_session = Session()
_session.init_app(server)

socketio = SocketIO(manage_session=False)
socketio.init_app(server)

# the following test prevents Flask from initializing twice
# (because of the Reloader)

if not server.debug or os.environ.get("WERKZEUG_RUN_MAIN") == "true":
    mxcube.init(hwr, cmdline_options.hwr_directory,
                cmdline_options.allow_remote,
                cmdline_options.ra_timeout,
                cmdline_options.video_device,
                cmdline_options.log_file)

    from core import loginutils

    # Make the valid_login_only decorator available on server object
    server.restrict = loginutils.valid_login_only

# 需要导入模块: from flask_socketio import SocketIO [as 别名]
# 或者: from flask_socketio.SocketIO import init_app [as 别名]
import print_helper

import exe

# Set this variable to "threading", "eventlet" or "gevent" to test the
# different async modes, or leave it set to None for the application to choose
# the best option based on installed packages.
async_mode = "eventlet"
# async_mode = "threading"

app = Flask(__name__)
application = app
# app.config['SECRET_KEY'] = 'secret!'
# socketio = SocketIO(app, async_mode=async_mode)
socketio = SocketIO(app)
socketio.init_app(app, async_mode=async_mode, log_output=True, message_queue='redis://redis-test:6379/12')
# thread = None
# thread_lock = Lock()


process_dict = {}

@app.route('/')
def index():
    return render_template('index.html', async_mode=socketio.async_mode)

@app.route('/execution/run/<id>')
def run(id):
    print("in execution request")
    # json_data.p()
    socketio.emit('result_event', {"msg":"start..."}, namespace='/execution')

# 需要导入模块: from flask_socketio import SocketIO [as 别名]
# 或者: from flask_socketio.SocketIO import init_app [as 别名]
    t.daemon = True
    t.start()
    print("Updated gallery", file=sys.stderr)
    filenames, _ = get_rnd_db_entries(N=4)
    URL = "http://127.0.0.1:5000/images/"
    filenames = {i: URL + s for i, s in enumerate(filenames)}
    socket.emit("update", {"img_tl": filenames[0],
                           "img_bl": filenames[1],
                           "img_tr": filenames[2],
                           "img_br": filenames[3],
                           })


# Init flask SocketIO
socket = SocketIO()
socket.init_app(app)


# Client mobile page
@app.route("/")
def client():
    """ Client site, for sending pictures and comments """
    return render_template("client.html", error=request.args.get("error"))


# Passive image gallery
@app.route("/gallery")
def gallery():
    """ Gallery site, for displaying sent pictures and comments """
    # Fetch 5 images from database
    filenames, comments = get_rnd_db_entries(N=5)

# 需要导入模块: from flask_socketio import SocketIO [as 别名]
# 或者: from flask_socketio.SocketIO import init_app [as 别名]
app = Flask(__name__)
login_manager = LoginManager()
db = SQLAlchemy()
socketio = SocketIO()
oauth = OAuth(app)
redis = Redis()
moment = Moment()

with app.app_context():

    config_name = os.getenv('FLASK_CONFIG') or 'development'
    app.config.from_object(config[config_name])
    config[config_name].init_app(app)

    db.app = app
    db.init_app(app)

    login_manager.init_app(app)
    login_manager.session_protection = 'strong'
    login_manager.login_view = 'login'
    login_manager.login_message = u'请先登陆系统,若遗忘密码，请联系管理员'
    login_manager.login_message_category = 'warning'

    socketio.init_app(app, async_mode=async_mode)
    redis.init_app(app)
    moment.init_app(app)

from .views import *  # noqa
from .models import *  # noqa