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'})
def _init_socketio(app, context):
from flask_socketio import SocketIO
socketio = SocketIO(app, async_mode='threading')
sio = socketio.server
@sio.on('connect', namespace='/exec')
def connect(sid, environ):
pass
@sio.on('query', namespace='/exec')
def query(sid, data):
exec_id = data
sio.enter_room(sid, str(exec_id), namespace='/exec')
sio.emit('reply', exec_id, namespace='/exec')
socketio.init_app(app)
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'})
class HttpServer:
# prepare may be rewrite it
config = {
'SECRET_KEY': 'someWOrkSD20KMS9330)&#',
'coco': None,
'LOGIN_URL': '/login'
}
init_kwargs = dict(
async_mode="eventlet",
# async_mode="threading",
# ping_timeout=20,
# ping_interval=10,
# engineio_logger=True,
# logger=True
)
def __init__(self):
config = {k: v for k, v in current_app.config.items()}
config.update(self.config)
self.flask_app = Flask(__name__, template_folder='dist')
self.flask_app.config.update(config)
self.socket_io = SocketIO()
self.register_routes()
self.register_error_handler()
def register_routes(self):
self.socket_io.on_namespace(ProxyNamespace('/ssh'))
@staticmethod
def on_error_default(e):
logger.exception(e)
def register_error_handler(self):
self.socket_io.on_error_default(self.on_error_default)
def run(self):
host = self.flask_app.config["BIND_HOST"]
port = self.flask_app.config["HTTPD_PORT"]
print('Starting websocket server at {}:{}'.format(host, port))
self.socket_io.init_app(self.flask_app, **self.init_kwargs)
self.socket_io.run(self.flask_app, port=port, host=host, debug=False)
def shutdown(self):
self.socket_io.stop()
pass
def create_app(test_config=None):
# config an instance of Flask
app = Flask(__name__, instance_relative_config=True)
app.config.from_mapping(
SECRET_KEY='dev',
# database
DATABASE=os.path.join(app.instance_path, 'ispeech.sqlite'),
)
if test_config is None:
app.config.from_pyfile('config.py', silent=True)
else:
app.config.from_mapping(test_config)
socketio = SocketIO(app)
# ensure the instance folder exists
try:
os.makedirs(app.instance_path)
except OSError:
pass
"""
@app.route('/')
def index():
return 'Index Page'
"""
@app.route('/hello', methods=['GET', 'POST'])
def hello():
return "Hello, World!"
# database
from . import db
db.init_app(app)
# apply the blueprints to the app
from . import auth, ispeech
app.register_blueprint(auth.bp)
app.register_blueprint(ispeech.bp)
#app.register_blueprint(audio.bp)
app.add_url_rule('/', endpoint='index')
socketio.init_app(app)
return app
def create_app(environment='development'):
f = Factory(environment)
f.set_flask()
f.set_db()
f.set_migration()
# f.set_api()
from .models.base import Example
app = f.flask
if app.config['TESTING']: # pragma: no cover
# Setup app for testing
@app.before_first_request
def initialize_app():
pass
@app.after_request
def after_request(response):
response.headers.add('Access-Control-Allow-Origin', '*')
response.headers.add('Access-Control-Allow-Headers',
'Content-Type,Authorization')
response.headers.add('Access-Control-Allow-Methods',
'GET,PUT,POST,DELETE')
return response
app.wsgi_app = ProxyFix(app.wsgi_app)
@app.cli.command()
@click.argument('command')
def setup(command):
pass
socketio = SocketIO(async_mode=async_mode, cors_allowed_origins='*', logger=True, engineio_logger=True, allow_upgrades=False)
socketio.init_app(app)
from .views import sample_page
from . import auth, events
app.register_blueprint(sample_page, url_prefix='/')
app.register_blueprint(events.bp, url_prefix='/ws')
return app, socketio
def create_app(debug=False):
global __socketio
__socketio = SocketIO(async_mode="gevent")
"""Create an application."""
app = Flask(__name__)
global __app
__app = app
app.debug = debug
from .routes import data_routes
app.register_blueprint(data_routes)
__socketio.init_app(app)
__start_twitterstream_thread()
return app
def create_app(config_name):
f_config = config_dict[config_name]
app = Flask(__name__,
template_folder=f_config.STATIC_FOLDER,
static_url_path='',
static_folder=f_config.STATIC_FOLDER)
app.config.from_object(f_config)
CORS(app, resources={r"*": {"origins": "*"}})
socket = SocketIO(app)
socket.init_app(app, cors_allowed_origins="*")
api = Api(app)
api.add_resource(Main, '/')
socket.on_event('request_start', communicate_with_guider)
socket.on_event('request_stop', disconnect_with_guider)
return app, socket
def create_app(name):
app = Flask(
name,
template_folder=settings["TEMPLATE_FOLDER"],
static_folder=settings["STATIC_FOLDER"],
static_url_path=settings["STATIC_URL_PATH"],
)
app.config["DEBUG"] = settings["FLASK_DEBUG"]
app.config["ENV"] = settings["FLASK_ENV"]
app.config["SECRET_KEY"] = settings["SECRET_KEY"]
socketio = SocketIO()
socketio.init_app(app)
socketio.on_event("chat", handle_message)
app = add_routes(app)
socketio = add_socketio_handlers(socketio)
return app, socketio
def create_app(redis_url):
socketio = SocketIO(logger=True)
app = Flask(__name__)
app.config["SECRET_KEY"] = config.SECRET_KEY
@app.route("/")
def index():
return jsonify({"name": "%s Event stream" % config.APP_NAME})
@socketio.on("connect", namespace="/events")
def connected():
app.logger.info("New websocket client connected")
@socketio.on_error("/events")
def on_error(error):
app.logger.error(error)
socketio.init_app(app, message_queue=redis_url, async_mode="gevent")
return (app, socketio)
def create_app(config_name):
f_config = config_dict[config_name]
app = Flask(__name__,
template_folder=f_config.STATIC_FOLDER,
static_url_path='',
static_folder=f_config.STATIC_FOLDER)
CORS(app,
resources={
r"/dataset/*": {
"origin": "*"
},
r"/devices/*": {
"origin": "*"
},
r"/slack/*": {
"origin": "*"
},
})
app.config.from_object(f_config)
app.config['MONGODB_SETTINGS'] = config_database
socket = SocketIO(app)
socket.init_app(app, cors_allowed_origins="*")
try:
db.init_app(app)
except Exception as e:
print('Failed to connect MongoDB', e)
api = Api(app)
api.add_resource(Main, '/', '/<path:path>')
api.add_resource(Dataset, '/dataset')
api.add_resource(Devices, '/devices')
api.add_resource(Slack, '/slack/')
socket.on_event('get_dashboard_data', get_dashboard_data)
socket.on_event('get_data_by_command', get_data_by_command)
socket.on_event('stop_command_run', stop_command_run)
socket.on_event('health_check', health_check)
return app, socket
def main(config_name):
if getattr(sys, 'frozen', False):
template_folder = os.path.join(sys._MEIPASS, 'templates')
static_folder = os.path.join(sys._MEIPASS, 'static')
app = Flask(__name__,
template_folder=template_folder,
static_folder=static_folder,
static_url_path='')
else:
app = Flask(__name__)
app.config.from_object(config[config_name])
socketio = SocketIO(app)
socketio.init_app(app)
@app.route('/')
def index():
return render_template('index.html')
socketio.on_namespace(MainNamespace('/data'))
return socketio, app
def create_app(config_name):
f_config = config_dict[config_name]
app = Flask(__name__,
template_folder=f_config.STATIC_FOLDER,
static_url_path='',
static_folder=f_config.STATIC_FOLDER)
app.config.from_object(f_config)
app.config['MONGODB_SETTINGS'] = config_database
socket = SocketIO(app)
socket.init_app(app, cors_allowed_origins="*")
# TODO: exception handling for mongo-engine
db.init_app(app)
api = Api(app)
api.add_resource(Main, '/', '/<path:path>')
api.add_resource(Slack, '/slack/')
socket.on_event('request_start', communicate_with_guider)
socket.on_event('request_stop', disconnect_with_guider)
return app, socket
def define_webserver(player_q):
import eventlet
# Monkey_Patch eventlet to support threads
eventlet.monkey_patch()
from flask import Flask, render_template, session, request
from flask_socketio import SocketIO
# Create Flask_SocketIO App
app = Flask(__name__, static_folder='web', static_url_path='')
app.config['SECRET_KEY'] = 'secret!'
sio = SocketIO(app, async_mode='eventlet')
sio.init_app(app, cors_allowed_origins="*")
@app.route('/')
def root():
print('Serving angular frontend...')
return send_from_directory(app.static_folder, 'index.html')
#@app.route('/<path:path>')
#def send_static(path):
# return send_from_directory(app.static_folder, path)
@sio.on('connect')
def onconnect_event():
print('Web Player instance connected!')
@sio.on('disconnect')
def onconnect_event():
print('Web Player instance disconnected!')
# Custom event
@sio.on('radio')
def handle_radio(data, methods=['GET', 'POST']):
#print('Radio received: ' + str(data))
player_q.put(data)
return [app, sio]
class HttpServer:
# prepare may be rewrite it
settings = {'cookie_secret': '', 'app': None, 'login_url': '/login'}
def __init__(self, app):
self.app = app
# self.settings['cookie_secret'] = self.app.config['SECRET_KEY']
# self.settings['app'] = self.app
self.flask = Flask(__name__, template_folder='dist')
self.flask.config['SECRET_KEY'] = self.app.config['SECRET_KEY']
self.socketio = SocketIO()
def run(self):
host = self.app.config["BIND_HOST"]
port = self.app.config["HTTPD_PORT"]
print('Starting websocket server at {}:{}'.format(host, port))
self.socketio.on_namespace(SSHws('/ssh').app(self.app))
self.socketio.init_app(self.flask, async_mode="threading")
self.socketio.run(self.flask, port=port, host=host)
def shutdown(self):
pass
application.url_map.strict_slashes = True
configure_app(application)
db = SQLAlchemy(application)
db.init_app(application)
cache = Cache(config={'CACHE_TYPE': 'simple'})
cache.init_app(application)
ma = Marshmallow(application)
socketio = SocketIO(engineio_logger=True)
if application.config['ACTIVE_MQ_URL'] is not None:
socketio.init_app(application,
async_mode='eventlet',
message_queue=application.config['ACTIVE_MQ_URL'],
path='/api/v1/socket.io')
else:
socketio.init_app(application, path='/api/v1/socket.io')
# Set socket logging to errors only to reduce log spam
logging.getLogger('socketio').setLevel(logging.ERROR)
logging.getLogger('engineio').setLevel(logging.ERROR)
if application.config['CORS_ALLOWED_ORIGINS'] is not None:
CORS(application,
supports_credentials=True,
origins=application.config['CORS_ALLOWED_ORIGINS'])
api = Api(application, prefix='/api/v1', doc='/api/v1/')
# set the absolute path to the static folder
app.static_folder = app.static_url_path
# Setup Session
app.config['SESSION_TYPE'] = 'redis'
app.config['SECRET_KEY'] = 'mysecretrediskey'
app.config['SESSION_REDIS'] = redis.Redis(host='redis',
port=6379,
password='******')
sess = Session()
sess.init_app(app)
# Setup SocketIO
socketio = SocketIO(app)
socketio.init_app(app,
async_mode=async_mode,
message_queue='redis://:waddup@redis:6379/')
@app.before_first_request
def start_worker():
def run_job():
c = consumer
c.listen_for_commands()
worker = threading.Thread(target=run_job)
worker.setDaemon(True)
worker.start()
def start_reporting(sess_key=None, sid=None):
from config import Config
from flask_restx import Api
app = Flask(__name__)
app.config.from_object(Config)
sess = Session()
db = SQLAlchemy(app)
db.init_app(app)
sess.init_app(app)
from flask_socketio import SocketIO
socketio = SocketIO()
socketio.init_app(app, manage_session=False)
DB_URL = os.environ.get("SQLALCHEMY_DATABASE_URI")
# if database_exists(DB_URL):
# print('DELETING DATABASE.')
# drop_database(DB_URL)
if not database_exists(DB_URL):
print('CREATING DATABASE')
create_database(DB_URL)
from application.models import User
print("CREATING TABLES")
db.create_all()
from application import routes
REGEXCID = re.compile(REGEXCIDSTRING, flags=re.ASCII)
REGEXMGS = re.compile(REGEXMGSSTRING)
REGEXPID = re.compile(REGEXPIDSTRING)
LOGIN_MANAGER = LoginManager()
LOGIN_MANAGER.login_view = "login"
LOGIN_MANAGER.init_app(APP)
SCHEDULER = APScheduler()
SCHEDULER.init_app(APP)
SCHEDULER.start()
ASYNC_MODE = 'eventlet'
THREAD_LOCK = Lock()
SOCKETIO = SocketIO(async_mode=ASYNC_MODE)
SOCKETIO.init_app(APP)
class Task:
def __init__(self):
self.task_id = 0
self.task_index = 0
self.task_queue = deque([])
self.pushlog_finished = False
self.background_thread = None
class User(UserMixin):
def __init__(self, user_id, username, password):
self.id = user_id
self.username = username
import eventlet import redis from flask import Flask from config import Config from flask_sqlalchemy import SQLAlchemy from flask_migrate import Migrate from flask_login import LoginManager from flask_socketio import SocketIO # Greenify all standard libs eventlet.monkey_patch() # Define extensions db = SQLAlchemy() migrate = Migrate() login_manager = LoginManager() socketio = SocketIO() # Create app app = Flask(__name__) app.config.from_object(Config) # config extensions db.init_app(app) migrate.init_app(app, db) login_manager.init_app(app) socketio.init_app(app, message_queue='redis://127.0.0.1:6379/0', async_mode="eventlet") login_manager.login_view = 'app.login' from app import routes, models
""" Handle generic SocketIOEventError. """
if isinstance(error, SocketIOEventError):
LOGGER.warning(f"Error encountered during {request.event}: {error!r}")
emit(error.event, error.response)
else:
error_id = uuid4()
LOGGER.exception(
f"An unexpected {error!r} has ocurred during {request.event}. Error id: {error_id}!"
)
emit("error", {"reason": "An unexpected error ocurred", "id": str(error_id)})
disconnect()
raise error
LOGGER = logging.getLogger("socketio")
log_config = CONFIG.get("logging.socketio")
handler = RotatingFileHandler(**log_config["handler"])
handler.setFormatter(FORMATTER)
LOGGER.setLevel(log_config["level"])
LOGGER.addHandler(handler)
socketio.init_app(app, json=flask.json, logger=LOGGER)
# Set up events
from .login import *
from .player_input import *
from .data_requests import *
from .game_loop import main_loop
'http://localhost:8000/players/api/games/')
generator = getattr(map_generator, settings['GENERATOR'])(settings)
player_manager = AvatarManager()
game_state = generator.get_game_state(player_manager)
turn_manager = ConcurrentTurnManager(game_state=game_state,
end_turn_callback=send_world_update,
completion_url=api_url + 'complete/')
WorkerManagerClass = WORKER_MANAGERS[os.environ.get(
'WORKER_MANAGER', 'local')]
worker_manager = WorkerManagerClass(game_state=game_state,
users_url=api_url,
port=port)
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(int(sys.argv[2]))
socketio.run(
app,
debug=False,
host=sys.argv[1],
port=int(sys.argv[2]),
use_reloader=False,
)
from coco.config import config
from coco.httpd.ws import ProxyNamespace, ElfinderNamespace
logger = get_logger(__file__)
app = Flask(__name__, template_folder='templates', static_folder='static')
app.config.update(config)
socket_io = SocketIO()
socket_io.on_namespace(ProxyNamespace('/ssh'))
socket_io.on_namespace(ElfinderNamespace('/elfinder'))
if os.environ.get('USE_EVENTLET', '1') == '1':
init_kwargs = {'async_mode': 'eventlet'}
else:
init_kwargs = {'async_mode': 'threading'}
socket_io.init_app(app, **init_kwargs),
socket_io.on_error_default(lambda x: logger.exception(x))
class HttpServer:
@staticmethod
def run():
host = config["BIND_HOST"]
port = config["HTTPD_PORT"]
print('Starting websocket server at {}:{}'.format(host, port))
socket_io.run(app, port=port, host=host, debug=False)
@staticmethod
def shutdown():
socket_io.stop()
pass
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
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://*****:*****@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')
import simplejson
from apscheduler.schedulers.background import BackgroundScheduler
from flask import Flask, json, render_template, request, Response
from flask_cors import CORS
from flask_socketio import emit, join_room, SocketIO
from jsonschema import validate, ValidationError
from src.clues.clue_manager import ClueSetType
from src.game.game import Game, InvalidState
# Initialize the application
app = Flask(__name__)
app.debug = True
app.config["SECRET_KEY"] = "secret!" # noqa: S105
socketio = SocketIO(app)
socketio.init_app(app, cors_allowed_origins="*")
# Setup logging
if not os.path.isdir("logs"):
os.makedirs("logs")
logger = logging.getLogger(__name__)
logger.setLevel("DEBUG")
handler = logging.FileHandler("logs/app.log")
shell_handler = logging.StreamHandler(sys.stdout)
handler.setFormatter(
logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s"))
logger.addHandler(handler)
logger.addHandler(shell_handler)
# Initialize CORS
CORS(app)
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_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)
def create_app(redis_url):
socketio = SocketIO(logger=True,
cors_allowed_origins=[],
cors_credentials=False)
app = Flask(__name__)
app.config.from_object(config)
# Application events (feed)
@app.route("/", methods=["GET", "POST"])
def index():
return jsonify({"name": "%s Event stream" % config.APP_NAME})
@socketio.on("connect", namespace="/events")
def connected():
try:
verify_jwt_in_request()
app.logger.info("New websocket client connected")
except Exception:
app.logger.info("New websocket client failed to connect")
disconnect()
return False
@socketio.on("disconnect", namespace="/events")
def disconnected():
try:
verify_jwt_in_request()
except Exception:
pass
user_id = get_jwt_identity()
for room_id in rooms_data:
_leave_room(room_id, user_id)
app.logger.info("Websocket client disconnected")
@socketio.on_error("/events")
def on_error(error):
app.logger.error(error)
# Review rooms (real-time)
@app.route("/rooms", methods=["GET", "POST"])
@jwt_required
def rooms():
return jsonify({"name": "%s Review rooms" % config.APP_NAME})
@socketio.on("preview-room:open-playlist", namespace="/events")
@jwt_required
def on_open_playlist(data):
"""
when a person opens the playlist page he immediately enters the
websocket room. This way he can see in live which people are in the
review room. The user still has to explicitly enter the review room
to actually be in sync with the other users
"""
room_id = data["playlist_id"]
room = rooms_data.get(room_id, _get_empty_room())
rooms_data[room_id] = room
join_room(room_id)
emit("preview-room:room-people-updated", room, room=room_id)
def _update_room_playing_status(data, room):
room["is_playing"] = data.get("is_playing", False)
room["is_repeating"] = data.get("is_repeating", False)
room["current_entity_index"] = data["current_entity_index"]
if "current_frame_number" in data:
room["current_frame_number"] = data["current_frame_number"]
if "comparing" in data:
room["comparing"] = data["comparing"]
return room
@socketio.on("preview-room:sync-newcomer", namespace="/events")
@jwt_required
def on_sync_newcomer(data):
"""
once a new person joins the room, all the people in the room are
alerted (see `on_join` and the emitted
preview-room:room-people-updated) we then listen for their replies,
telling the newcomer where they are in the playlist
"""
on_playing_status_updated(data, only_newcomer=True)
@socketio.on("preview-room:join", namespace="/events")
@jwt_required
def on_join(data):
"""
When a person joins the review room, we notify all its members that a
new person is added to the room.
All the members will then send back the current status of the playlist,
so that the newcomer will be in sync
"""
user_id = get_jwt_identity()
room_id = data["playlist_id"]
room = rooms_data.get(room_id, _get_empty_room())
room["people"] = list(set(room["people"] + [user_id]))
rooms_data[room_id] = room
emit("preview-room:room-people-updated", room, room=room_id)
@socketio.on("preview-room:leave", namespace="/events")
@jwt_required
def on_leave(data):
user_id = get_jwt_identity()
room_id = data["playlist_id"]
_leave_room(room_id, user_id)
@socketio.on("preview-room:update-playing-status", namespace="/events")
@jwt_required
def on_playing_status_updated(data, only_newcomer=False):
room_id = data["playlist_id"]
room = rooms_data.get(room_id, _get_empty_room())
rooms_data[room_id] = _update_room_playing_status(data, room)
event_data = {"only_newcomer": only_newcomer, **rooms_data[room_id]}
emit("preview-room:room-updated", event_data, room=room_id)
socketio.init_app(app, message_queue=redis_url, async_mode="gevent")
return (app, socketio)
os.path.abspath("/home/shashi/Desktop/Anveshan_FYP/SE/Anveshan_Crawler"))
sys.path.append(
os.path.abspath("/home/shashi/Desktop/Anveshan_FYP/SE/Anveshan"))
from constants import MONGODB_LINK
app = Flask(__name__)
app.secret_key = "secret"
app.config["MONGOALCHEMY_DATABASE"] = "AnveshanUser"
app.config.update({
'SESSION_COOKIE_SECURE': True,
'REMEMBER_COOKIE_SECURE': True
})
#cors
cors = CORS(app, origin="*")
login_manager = LoginManager(app)
anveshan_user_db = MongoAlchemy(app)
#socketio
#socketio = SocketIO(app, cors_allowed_origins="*",)
socketio = SocketIO()
app.config['SESSION_TYPE'] = 'filesystem'
socketio.init_app(app, cors_allowed_origins="*", message_queue="redis://")
from routes import routes, socket_routes
if __name__ == "__main__":
socketio.run(app, host="0.0.0.0", port=5001)
#app.run()
def setup_app(
config: str = 'mongo.config.Config',
env: Optional[str] = None,
):
'''
setup flask app from config and pre-configured env
'''
# Reserve a "empty" school
try:
engine.School(abbr='', name='無').save()
except NotUniqueError:
pass
# Create a flask app
app = Flask(__name__)
# Register error handler
@app.errorhandler(SandboxNotFound)
def on_sandbox_not_found(_):
return HTTPError('There are no sandbox available', 503)
app.url_map.strict_slashes = False
app.json_encoder = PyShareJSONEncoder
# Override flask's config by core config
# Note: Although the config is overridden, `ENV` and `DEBUG` should
# still set by env var (according to official document)
# Ref: https://flask.palletsprojects.com/en/2.0.x/config/#environment-and-debug-features
for k in ('TESTING', 'ENV', 'DEBUG'):
app.config[k] = config_lib.config[k]
# Register flask blueprint
api2name = [
(auth_api, '/auth'),
(problem_api, '/problem'),
(test_api, '/test'),
(user_api, '/user'),
(comment_api, '/comment'),
(submission_api, '/submission'),
(tag_api, '/tag'),
(course_api, '/course'),
(attachment_api, '/attachment'),
(notif_api, '/notif'),
(sandbox_api, '/sandbox'),
(school_api, '/school'),
(task_api, '/task'),
(requirement_api, '/requirement'),
]
for api, name in api2name:
app.register_blueprint(api, url_prefix=name)
if config_lib.config.get('DEBUG') == True:
logger().warning(
'Load dummy resource API, don\'t'
' use this under production mode', )
from model.dummy import dummy_api
app.register_blueprint(dummy_api, url_prefix='/dummy')
# Setup SocketIO server
socketio = SocketIO(cors_allowed_origins='*')
socketio.on_namespace(Notifier(Notifier.namespace))
socketio.init_app(app)
try:
init = engine.AppConfig.objects(key='init').get()
except DoesNotExist:
init = engine.AppConfig(
id='init',
value=True,
).save()
# Setup environment for testing
if init.value == True:
logger().info('First run. Start setup process')
if env is not None:
setup_env(env)
sandbox.init()
init.update(value=False)
return app
from flask_login import LoginManager
from flask_socketio import SocketIO
from flask_cors import CORS
from flask_mongoengine import MongoEngine
from fakebook.models import FakeBookUser
from api.utils import get_notifications_for_dashboard
from settings import MONGODB_SETTINGS
import main_sockets
app = Flask(__name__)
app.secret_key = 'FAKEBOOKSECRET'
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 update_friends_list_for_receiver(user_id):
socketio.emit('update_people_list',room=user_id)
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
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)
import flask
from flask import flash, redirect, render_template, request, session, abort, url_for, send_from_directory, jsonify, stream_with_context
from flask_socketio import SocketIO, join_room, leave_room, emit
THREAD = Thread()
########################################################
# FLASK configuration
flask_config['host'] = "my_FLASK_LiveTerminal.com"
app = flask.Flask(__name__)
app.secret_key = 'dljsaklqk24e21cjn!Ew@@dsa5'
SOCKETIO = SocketIO()
SOCKETIO.init_app(app, async_mode='eventlet', async_handlers=True)
########################################################
########################################################
## HELPERS
# queue push function
def enqueue_output(out, queue):
try:
for _line in iter(out.readline, b''):
queue.put(_line)
except:
pass
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 import Flask, render_template, request, redirect, session, flash
from flask_socketio import SocketIO, send, emit, join_room, leave_room
import json
import time
app = Flask(__name__)
socketio = SocketIO()
socketio.init_app(app)
@app.route('/')
def index():
return render_template("index.html")
@app.route('/data', methods=['POST'])
def data():
# print(request.data)
socketio.emit('hb_data', request.data.decode('utf-8'), broadcast=True)
return 'success'
if __name__ == '__main__':
socketio.run(app, host='0.0.0.0', port=80)
server = Flask(__name__, static_url_path="", template_folder=template_dir)
cfg = Config(
os.path.abspath(
os.path.join(cmdline_options.hwr_directory,
"mxcube-server-config.yml")))
server.config.from_object(cfg.FLASK)
server.register_error_handler(Exception, exception_handler)
_session = Session()
_session.init_app(server)
socketio = SocketIO(manage_session=False,
cors_allowed_origins=cfg.FLASK.ALLOWED_CORS_ORIGINS)
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":
logging.getLogger("MX3.HWR").info("Starting MXCuBE3...")
atexit.register(kill_processes)
with open("/tmp/mxcube.pid", "w") as f:
f.write(str(os.getpid()) + " ")
from core import loginutils
# Make the valid_login_only decorator available on server object
server.restrict = loginutils.valid_login_only
