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) self.socketio.run(self.flask, port=port, host=host) def shutdown(self): pass
def init_flask(config, loglevel, quiet): global socketio flask_app = flask.Flask( "aprsd", static_url_path="/static", static_folder="web/static", template_folder="web/templates", ) setup_logging(config, flask_app, loglevel, quiet) server = APRSDFlask() server.set_config(config) flask_app.route("/", methods=["GET"])(server.index) flask_app.route("/stats", methods=["GET"])(server.stats) flask_app.route("/messages", methods=["GET"])(server.messages) flask_app.route("/packets", methods=["GET"])(server.packets) flask_app.route("/send-message", methods=["GET"])(server.send_message) flask_app.route("/send-message-status", methods=["GET"])(server.send_message_status) flask_app.route("/save", methods=["GET"])(server.save) flask_app.route("/plugins", methods=["GET"])(server.plugins) socketio = SocketIO( flask_app, logger=False, engineio_logger=False, async_mode="threading", ) # import eventlet # eventlet.monkey_patch() socketio.on_namespace(SendMessageNamespace("/sendmsg", config=config)) socketio.on_namespace(LoggingNamespace("/logs")) return socketio, flask_app
def create_app(config_class=Config): app = Flask(__name__) logging.basicConfig(filename='debug.log', level=logging.DEBUG, format=("%(asctime)s %(levelname)s %(name)s" "%(threadName)s : %(message)s")) app.config.from_object(config_class) app.logger.debug('Starting application') db.init_app(app) migrate.init_app(app, db) # Queue needs the app context to be filled on __init__ with app.app_context(): db.create_all() from app.controllers import bp as queue_bp from app.helpers.errors import bp as errors_bp from app.models.players.youtube import YouTubePlayer app.register_blueprint(queue_bp) app.register_blueprint(errors_bp) socketio = SocketIO(app, async_mode='gevent', message_queue='redis://localhost:6379/0') socketio.on_namespace(YouTubePlayer.instance()) return app, socketio
def create_app(config_name): app = Flask(__name__, static_folder='../static') app.config.from_object(config[config_name]) config[config_name].init_app(app) bootstrap.init_app(app) socketio = SocketIO(app, message_queue="redis://") global redis redis = redis_srv.from_url(app.config['REDIS_URL']) if not app.debug and not app.testing and not app.config['SSL_DISABLE']: from flask_sslify import SSLify sslify = SSLify(app) app.url_map.converters['regex'] = RegexConverter from .main import main as main_blueprint app.register_blueprint(main_blueprint) socketio.on_namespace(SetupNamespace(redis, '/setup')) socketio.on_namespace(GameNamespace(redis, '/game')) return app, socketio
def create_socketio(app): app.config['SECRET_KEY'] = 'secret!' socketio = SocketIO(app, cors_allowed_origins="*") socketio.on_namespace(TradeNamespace("/flask")) TradeNamespace.set_socketio(socketio) TradeNamespace.set_send_time(app.config.get("FIX_PUSH_TIME")) return socketio
def create_app(): app = Flask(__name__, static_folder='../dist', static_url_path='') from .config import Config app.config.from_object(Config) @app.route('/') @app.errorhandler(404) def index(e=None): if request.path.startswith('/api/'): return jsonify(status=404), 404 entry = os.path.join('../dist', 'index.html') return send_file(entry) from . import api app.register_blueprint(api.bp) from . import db db.init_app(app) from .user import get_user_by_id, User login_manager = LoginManager() @login_manager.user_loader def load_user(user_id): u = get_user_by_id(user_id) return User(u) if u is not None else None login_manager.init_app(app) socketio = SocketIO(app) from .gomoku import GomokuSocket socketio.on_namespace(GomokuSocket()) return app
class HttpServer: # prepare may be rewrite it config = {'SECRET_KEY': '', 'coco': None, 'LOGIN_URL': '/login'} async_mode = "threading" def __init__(self, coco): config = coco.config config.update(self.config) config['coco'] = coco self.flask_app = Flask(__name__, template_folder='dist') self.flask_app.config.update(config) self.socket_io = SocketIO() self.register_routes() def register_routes(self): self.socket_io.on_namespace(ProxyNamespace('/ssh')) def run(self): host = self.flask_app.config["BIND_HOST"] port = self.flask_app.config["HTTPD_PORT"] self.socket_io.init_app(self.flask_app, async_mode=self.async_mode) self.socket_io.run(self.flask_app, port=port, host=host, debug=False) def shutdown(self): pass
class Server(flask.Flask): def __init__(self): super().__init__("Connecticut", root_path=path) self.blacklist = set() self.config["SECRET_KEY"] = secrets.token_urlsafe(40) self.config["SECRET_KEY"] = "test" self.config["JWT_TOKEN_LOCATION"] = "cookies" self.config['JWT_BLACKLIST_ENABLED'] = True self.config['JWT_BLACKLIST_TOKEN_CHECKS'] = ['access', 'refresh'] self.jwt = JWTManager(self) self.socketio = SocketIO(self, async_mode="threading") @self.jwt.invalid_token_loader def on_invalid_token(): response = redirect("/", code=302) flask_jwt_extended.unset_access_cookies(response) flask_jwt_extended.unset_refresh_cookies(response) return response @self.jwt.revoked_token_loader def on_revoked_token(): response = redirect("/", code=302) flask_jwt_extended.unset_access_cookies(response) flask_jwt_extended.unset_refresh_cookies(response) return response @self.jwt.expired_token_loader def on_expired_token(): response = redirect("/", code=302) flask_jwt_extended.unset_access_cookies(response) flask_jwt_extended.unset_refresh_cookies(response) return response @self.jwt.token_in_blacklist_loader def check_if_token_in_blacklist(decrypted_token): jti = decrypted_token['jti'] return jti in self.blacklist @self.errorhandler(404) def handle_404(error): return flask.render_template("404.html"), 404 self.socketio.on_namespace(SocketNamespace('/websocket')) routes(self) def run_in_thread(self, *args, **kwargs): threading.Thread(target=self.socketio.run, args=( self, Config.get_config_option("address"), int(Config.get_config_option("port")), ), kwargs={ "log_output": True }).start()
def __init__(self, app, auth, render_template): self.app = app self.render_template = render_template socketio = SocketIO(app) a1 = auth.login_required(self.get_socket_test_page) app.add_url_rule("/socket_test", "socket_test", a1, methods=["GET"]) socketio.on_namespace(MyCustomNamespace('/test'))
def create_socket(app): """Create a socketio object""" # We don't want to monkey patch the naive python functions # which destuct some of the PyPPL functionalities # We might be swtiching to gevent or eventlet if PyPPL is # switching to greenlet. namespace = RootNamespace('/') socketio = SocketIO(app, async_mode='threading', engineio_logger=False) socketio.on_namespace(namespace) return socketio, namespace
def start_dashboard(your_modules=[], include_defaults=True, port=5555): server = AutomatorDashboard(your_modules, include_defaults=include_defaults) socketio = SocketIO(server, async_mode='threading') socketio.on_namespace(DashboardMessages(server.dispatch, server.automations_list)) def do(): with server.test_request_context('/'): monitor_clipboard(socketio.emit) server.queue.put(Task(do)) socketio.run(server, port=port)
def create_app(): """ :return: """ app = Flask(__name__) app.config['SECRET_KEY'] = os.environ.get('FLASK_SECRET_KEY', open(os.path.join(os.path.dirname(os.path.realpath(__file__)), "../db.key"),'r').read()) app.config['SQLALCHEMY_DATABASE_URI'] = db_path app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False db.init_app(app) global socketio socketio = SocketIO(app) from .timer import Timer global timer timer = Timer() from .models import User, Role UserManager.USER_ENABLE_EMAIL = False user_manager = UserManager(app, db, User) user_manager.login_manager.login_view = 'auth.login' # @user_manager.login_manager.user_loader # def load_user(user_id): # """ # :param user_id: # :return: # """ # return User.query.get(int(user_id)) # blueprint for auth routes in our app from .auth import auth as auth_blueprint app.register_blueprint(auth_blueprint) # blueprint for non-auth parts of app from .main import main as main_blueprint app.register_blueprint(main_blueprint) from .checkin import checkin as checkin_blueprint app.register_blueprint(checkin_blueprint) from .device import device as device_blueprint, restart_all_timers, DeviceNamespace app.register_blueprint(device_blueprint, url_prefix='/device') socketio.on_namespace(DeviceNamespace('/device')) timer.add_timer('/device/timer', datetime.now() + timedelta(seconds=2)) from .queue import queue as queue_blueprint, QueueNamespace app.register_blueprint(queue_blueprint, url_prefix='/queue') socketio.on_namespace(QueueNamespace('/queue')) from .user import user as user_blueprint app.register_blueprint(user_blueprint, url_prefix='/user') return app
def bind_socketio(app, **kws): """Create and return a SocketIO instance bound to the Flask app. Install appropriate event handlers and Monitor. kws is passed to the SocketIO constructor. """ slog = app.logger.getChild("sockio") elog = slog.getChild("engineio") sio = SocketIO(app, logger=slog, engineio_logger=elog, **kws) sio.on_namespace(Simsvc_namespace(slog)) app.monitor = Monitor(app, sio) return sio
def main(): server_config, logger_config = get_configs() logger = create_logger(logger_config) namespace = create_namespace(server_config) app = Flask(__name__) socketio = SocketIO(app, cors_allowed_origins='*') socketio.on_namespace(namespace) logger.info("Server launched") socketio.run(app, host="0.0.0.0", port=9090)
def init_app(app): _socketio = SocketIO(app) _socketio.on_namespace(GeneralNamespace('/general')) # 启动任务守护线程 global _daemon _daemon = TaskDaemon() _daemon.setDaemon(True) _daemon.start() # 程序退出时退出任务守护线程 atexit.register(exit_running_daemon_by_atexit) signal.signal(signal.SIGTERM, exit_running_daemon_by_signal) return _socketio
def create_app(): app = Flask(__name__) app.config['SECRET_KEY'] = 'secret!' from .views import main as main_blueprint app.register_blueprint(main_blueprint) socketio = SocketIO(async_mode='eventlet') socketio.init_app(app) updater = StatusUpdater(socketio, NAMESPACE) handler = SocketIOEventHandler(updater, NAMESPACE) socketio.on_namespace(handler) return app, socketio, updater
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.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): # return host = config["BIND_HOST"] port = 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
class Server(object): """ Server represents the game server, and encapsulates everythong about it. This includes the flask app, socket app, views, and event handlers. """ def __init__(self, config, host=None, port=None): self._app = Flask(__name__) self._app.config.from_object(config) self._host = config.SERVER_HOST if not host else host self._port = config.SERVER_PORT if not port else port self._socketio = SocketIO(self._app) self._socketio.on_namespace(_ServerNamespace('/play')) def run(self): self._socketio.run(self._app, host=self._host, port=self._port)
def create_socket_io(app: Flask) -> SocketIO: # Create SocketIO instance, using same messageq queue as Celery socketio = SocketIO(app, message_queue=app.config['BROKER_URL'], cors_allowed_origins='*') app.socketio = socketio # Calm down socket.io loggers logging.getLogger('socketio').setLevel(logging.ERROR) logging.getLogger('engineio').setLevel(logging.ERROR) logging.getLogger('werkzeug').setLevel(logging.ERROR) # Register namespaces and listeners default_namespace = TaskMessageNamespace( app.config['DEFAULT_SOCKETIO_NAMESPACE']) socketio.on_namespace(default_namespace) return socketio
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 on_room_message(self, message): session['receive_count'] = session.get('receive_count', 0) + 1 emit('room_message', { 'data': message['data'], 'count': session['receive_count'] }, room=message['room']) def on_disconnect_request(self): session['receive_count'] = session.get('receive_count', 0) + 1 emit('my_response', { 'data': 'Disconnected!', 'count': session['receive_count'] }) disconnect() def on_ping(self): emit('pong') def on_connect(self): return def on_disconnect(self): print('Client disconnected', request.sid, session['type']) socketio.on_namespace(RegieNamespace('/regie')) if __name__ == '__main__': socketio.run(app, debug=True, host="0.0.0.0", port=5000)
request.sid, request.environ['REMOTE_ADDR'], request.environ['REMOTE_PORT']) logger.info(msg) global total_connection total_connection += 1 # self.send('ACK', room=request.sid) pass def on_disconnect(self): logger.info('disconnect sid = {}'.format(request.sid)) global total_connection total_connection -= 1 pass def on_message(self, message): pass def on_my_event(self, message): pass socketio.on_namespace(FanoutNamespace(ns_name)) if __name__ == '__main__': import sys port = 8080 if len(sys.argv) >= 2: port = int(sys.argv[1]) socketio.run(app, debug=False, port=port, host='0.0.0.0')
server_config = ServerConfig() host=server_config['host'] port=server_config['port'] debug=server_config['debug'] tolerance=0.05 state: HeaterState superviser: Superviser app = Flask(__name__) app.config['SECRET_KEY'] = 'super_secret' socketio = SocketIO(app, logger=True, engineio_logger=True) status_socket = StateSocket('/state') socketio.on_namespace(status_socket) @app.route('/', methods=['GET']) def index(): global state, superviser return render_template('main.html', temp_is=state.get_temp_is(), temp_should=state.get_temp_should()) @app.route('/history', methods=['GET']) def history(): return render_template('history.html') @app.route('/temperatur', methods=['GET']) def get_curr_temps(): global temp_is, temp_should temps = get_temps() temp_is.value = get_temperature()
@app.route('/api/terminal/v2/sessions/<pk>/replay/') def get_session_replay(pk): # return jsonify({ # 'type': 'guacamole', # 'src': 'http://localhost/media/2018-05-07/5c205f0a-b5ae-405a-9444-c0d59262ec29.gz', # 'status': 'DONE' # }) return jsonify({ 'type': 'json', 'src': 'http://localhost/media/replay/2018-06-08/581a12ca-fa8f-4399-8800-f97935219ddf.replay.gz', 'status': 'DONE', }) @app.route('/luna/i18n/<i18n>') def i18n(i18n): return send_file('./i18n/' + i18n) def read_file(filename, charset='utf-8'): with open(filename, 'rb') as f: return f.read().decode(charset) if __name__ == '__main__': socketio = SocketIO(app, async_mode=async_mode) socketio.on_namespace(SSHws('/ssh')) socketio.run(app, port=5001)
@app.route('/<path:resource>') def serveStaticResource(resource): return send_from_directory('static/', resource) @app.route('/test') def test(): return '<strong>It\'s Alive!</strong>' @app.errorhandler(jinja2.exceptions.TemplateNotFound) def template_not_found(e): return not_found(e) @app.errorhandler(404) def not_found(e): return '<strong>Page Not Found!</strong>', 404 @socketio.on('my_ping', namespace='/test') def ping_pong(): emit('my_pong') if __name__ == '__main__': socketio.on_namespace(MyCustomNamespace('/test')) socketio.run(app, host='0.0.0.0', port=9000, debug=True)
from yeti.server import app, rabbitmq import namespaces from flask_socketio import SocketIO import logging logger = logging.getLogger(__name__) socketio = SocketIO(app) socketio.on_namespace(namespaces.Cam('/cam')) socketio.on_namespace(namespaces.Web('/web')) @socketio.on_error_default # handles all namespaces without an explicit error handler def default_error_handler(e): logger.exception('Socket error occurred') def send_event_web(event, data): socketio.emit(event, data, namespace='/web', broadcast=True) def send_event_cam(event, data): socketio.emit(event, data, namespace='/cam', broadcast=True) #start listening to messages from www server queue = rabbitmq.EventHandler() queue.receive(send_event_web)
if isinstance(identity, int): return db.Authenticatable.get(identity) else: return identity # ------------------------------------------------------------------------------ # Setup flask-socketio # ------------------------------------------------------------------------------ try: socketio = SocketIO(app, async_mode='gevent_uwsgi') except: socketio = SocketIO(app) # socketio.on_namespace(DefaultSocketNamespace("/")) socketio.on_namespace(DefaultSocketNamespace("/tasks")) def start_interpreter(): # create child process attached to a pty we can read from and write to if TERMINAL_AVAILABLE: env = app.config['environment'] cmd = ['ipython', '-m', 'vantage6.server.shell', '-i', '--', env] log.debug("opening pty") master_fd, slave_fd = pty.openpty() log.debug("starting process") child = subprocess.Popen(cmd, stdin=slave_fd, stdout=slave_fd,
oidc.init_app(app) celery.conf.update(app.config) app.logger.setLevel(LOG_LEVEL) app.logger.addHandler(log_handler) app.register_blueprint(bp_index) app.register_blueprint(bp_host_api) app.register_blueprint(bp_cluster_api) app.register_blueprint(bp_stat_api) app.register_blueprint(bp_auth_api) app.register_blueprint(bp_user_api) app.register_blueprint(front_rest_user_v2) @app.errorhandler(404) def page_not_found(error): return jsonify(error=404, text=str(error)), 404 @app.errorhandler(500) def internal_error(error): return jsonify(error=500, text=str(error)), 500 socketio.on_namespace(CustomSockets('/socket.io')) if __name__ == '__main__': socketio.run(app, port=8080, host="0.0.0.0", debug=os.environ.get('DEBUG', app.config.get("DEBUG", True)))
"Latitude": result[2], "Longitude": result[3] }) agencies.append(result[4]) #query for getting aggregate sales data for all agencies salesQuery = ''' SELECT SALE_DATE, SUM(TOTAL_PRICE) FROM STRANSACTIONS WHERE AGENCYNUM IN (%s) AND SALE_DATE > ADD_DAYS(CURRENT_DATE, -28) GROUP BY SALE_DATE ORDER BY SALE_DATE ASC ''' % (str(agencies)[1:-1]) #execute query + prepare response result = executeQuery(connectDB('spatial-db'), salesQuery) x = [str(i[0]) for i in result] y = [i[1] for i in result] salesResponse = {'x': x, 'y': y} #send back selected agency names + aggregate sales data response = [agencyResponse, salesResponse] return response socketio.on_namespace(SpeechWsNamespace('/geospatial')) #initialize geospatial endpoint ''' START APP ''' if __name__ == '__main__': socketio.run(app, port=app_port)
def on_connect(self): logger.info('Connected to client!') send('Connected to server!') def on_message(self, msg): logger.info('Received from client: %s' % msg) def on_streamForTranscription(self, blob): command = transcribe(blob) emit('transcribeSuccess', command, broadcast=True) response, read = executeCommand(command) logger.info('Command: %s. Response: %s. Read: %s.' % (command, response, read)) if (read): resAudio = audioSynthesis(response) emit('speechResponse', {"audio": resAudio, "text": response}, broadcast=True) else: emit('textResponse', response, broadcast=True) logger.info('response sent after transcription') def on_error(self, e): logger.info('Error in websocket connection: %s' % e) socketio.on_namespace(SpeechWsNamespace('/transcribe')) ''' START APP ''' if __name__ == '__main__': socketio.run(app, port=app_port)
class Serve(object): def __init__(self, config, mongo): self.app = Flask(__name__) self.app.config['yada_config'] = config self.app.config['yada_mongo'] = mongo self.app.debug = True self.app.secret_key = '23ljk2l9a08sd7f09as87df09as87df3k4j' CORS(self.app, supports_credentials=True) endpoints.BaseGraphView.get_base_graph = self.get_base_graph self.app.add_url_rule( '/transaction', view_func=endpoints.TransactionView.as_view('transaction'), methods=['GET', 'POST']) self.app.add_url_rule('/get-graph-info', view_func=endpoints.GraphView.as_view('graph'), methods=['GET', 'POST']) self.app.add_url_rule( '/get-graph-sent-friend-requests', view_func=endpoints.GraphSentFriendRequestsView.as_view( 'graphsentfriendrequests'), methods=['GET', 'POST']) self.app.add_url_rule( '/get-graph-friend-requests', view_func=endpoints.GraphFriendRequestsView.as_view( 'graphfriendrequests'), methods=['GET', 'POST']) self.app.add_url_rule( '/get-graph-friends', view_func=endpoints.GraphFriendsView.as_view('graphfriends'), methods=['GET', 'POST']) self.app.add_url_rule( '/get-graph-posts', view_func=endpoints.GraphPostsView.as_view('graphposts'), methods=['GET', 'POST']) self.app.add_url_rule( '/get-graph-messages', view_func=endpoints.GraphMessagesView.as_view('graphmessages'), methods=['GET', 'POST']) self.app.add_url_rule('/get-graph-new-messages', view_func=endpoints.GraphNewMessagesView.as_view( 'graphnewmessages'), methods=['GET', 'POST']) self.app.add_url_rule( '/get-graph-comments', view_func=endpoints.GraphCommentsView.as_view('get-comments'), methods=['POST']) self.app.add_url_rule( '/get-graph-reacts', view_func=endpoints.GraphReactsView.as_view('get-reacts'), methods=['POST']) self.app.add_url_rule( '/get-graph-wallet', view_func=endpoints.RidWalletView.as_view('get-wallet')) self.app.add_url_rule('/wallet', view_func=endpoints.WalletView.as_view('wallet')) self.app.add_url_rule('/faucet', view_func=endpoints.FaucetView.as_view('faucet')) self.app.add_url_rule( '/pool', view_func=endpoints.MiningPoolView.as_view('pool')) self.app.add_url_rule( '/pool-submit', view_func=endpoints.MiningPoolSubmitView.as_view('poolsubmit'), methods=['GET', 'POST']) self.app.add_url_rule( '/pool-explorer', view_func=endpoints.MiningPoolExplorerView.as_view( 'pool-explorer')) self.app.add_url_rule( '/get-block', view_func=endpoints.GetBlockByHashView.as_view('get-block'), methods=['GET']) self.app.add_url_rule( '/getblockheight', view_func=endpoints.GetBlockHeightView.as_view('get-block-height')) self.app.add_url_rule( '/newtransaction', view_func=endpoints.NewTransactionView.as_view('new-transaction'), methods=['POST']) self.app.add_url_rule( '/newblock', view_func=endpoints.NewBlockView.as_view('new-block'), methods=['POST']) self.app.add_url_rule( '/get-blocks', view_func=endpoints.GetBlocksView.as_view('get-blocks-range')) self.app.add_url_rule( '/create-raw-transaction', view_func=endpoints.CreateRawTransactionView.as_view( 'create-raw-transaction'), methods=['POST']) self.app.add_url_rule( '/sign-raw-transaction', view_func=endpoints.SignRawTransactionView.as_view( 'sign-raw-transaction'), methods=['POST']) self.app.add_url_rule( '/generate-wallet', view_func=endpoints.GenerateWalletView.as_view('generate-wallet')) self.app.add_url_rule( '/generate-child-wallet', view_func=endpoints.GenerateChildWalletView.as_view( 'generate-child-wallet'), methods=['POST']) self.app.add_url_rule( '/explorer-search', view_func=endpoints.ExplorerSearchView.as_view('explorer-search')) self.app.add_url_rule( '/get-latest-block', view_func=endpoints.GetLatestBlockView.as_view('get-latest-block')) self.app.add_url_rule( '/register', view_func=endpoints.RegisterView.as_view('register')) self.app.add_url_rule( '/create-relationship', view_func=endpoints.CreateRelationshipView.as_view( 'create-relationship'), methods=['POST']) self.app.add_url_rule('/post-fastgraph-transaction', view_func=endpoints.PostFastGraphView.as_view( 'post-fastgraph-transaction'), methods=['POST']) self.app.add_url_rule( '/yada_config.json', view_func=endpoints.GetYadaConfigView.as_view('yada-config')) self.app.add_url_rule( '/login', view_func=endpoints.GetSiginCodeView.as_view('login')) self.app.add_url_rule('/', view_func=endpoints.HomeView.as_view('home')) self.app.add_url_rule('/search', view_func=endpoints.SearchView.as_view('search')) self.app.add_url_rule('/react', view_func=endpoints.ReactView.as_view('react'), methods=['POST']) self.app.add_url_rule( '/comment-react', view_func=endpoints.CommentReactView.as_view('comment-react'), methods=['POST']) self.app.add_url_rule('/get-comment-reacts', view_func=endpoints.GetCommentReactsView.as_view( 'get-comment-reacts'), methods=['POST']) self.app.add_url_rule( '/get-comment-reacts-detail', view_func=endpoints.GetCommentReactsDetailView.as_view( 'get-comment-reacts-detail'), methods=['POST']) self.app.add_url_rule( '/comment', view_func=endpoints.CommentView.as_view('comment'), methods=['POST']) self.socketio = SocketIO(self.app) self.socketio.on_namespace(endpoints.BlockchainSocketServer('/chat')) def get_base_graph(self): bulletin_secret = request.args.get('bulletin_secret').replace(' ', '+') if request.json: ids = request.json.get('ids') else: ids = [] graph = Graph(self.app.config['yada_config'], self.app.config['yada_mongo'], bulletin_secret, ids) return graph
send(data, json=True, broadcast=True) if not data.get('noackargs'): return data def on_my_custom_event(self, data): emit('my custom response', data) if not data.get('noackargs'): return data def on_other_custom_event(self, data): global request_event_data request_event_data = request.event emit('my custom response', data) socketio.on_namespace(MyNamespace('/ns')) class TestSocketIO(unittest.TestCase): @classmethod def setUpClass(cls): pass @classmethod def tearDownClass(cls): cov.stop() cov.report(include='flask_socketio/*', show_missing=True) def setUp(self): pass
from flask import Flask from flask_socketio import SocketIO from .finance_news import * app = Flask(__name__) if not app.debug: import os base_dir = os.path.split(os.path.realpath(__file__))[0] import logging from logging.handlers import RotatingFileHandler file_handler = RotatingFileHandler(base_dir + '/finance-news.log', maxBytes=10 * 1024 * 1024, backupCount=5) file_handler.setLevel(logging.WARNING) app.logger.addHandler(file_handler) socketio = SocketIO(app) socketio.on_namespace(FinanceNews('/finance_news'))
path = '/fanout.%s' % (os.getpid()) def on_connect(self): logger.info('path = {}, on connect sid = {}, ({}:{})'.format( self.path, request.sid, request.environ['REMOTE_ADDR'], request.environ['REMOTE_PORT'])) socketio.send('message: connect OK to all', namespace='/fanout') socketio.emit('my event', 'my event: connect OK', namespace='/fanout') session['data'] = request.sid def on_disconnect(self): logger.info('path = {}, on disconnect. session data = {}'.format(self.path, session['data'])) def on_message(self, message): logger.info('path = {}, on message. msg = {}'.format(self.path, message)) def on_my_event(self, message): logger.info('path = {}, on my event. msg = {}'.format(self.path, message)) socketio.on_namespace(FanoutNamespace('/fanout')) if __name__ == '__main__': import sys port = 8080 if len(sys.argv) >= 2: port = int(sys.argv[1]) socketio.run(app, debug=True, port=port)
self.processors[channel].process(self.running[channel], self.channels[channel], data['frame']) # import logging # log = logging.getLogger('werkzeug') # log.setLevel(logging.ERROR) app = Flask(__name__) app.config['SECRET_KEY'] = 'secret!' socketio = SocketIO(app) brain = Brain() brain.namespace = '/brain' socketio.on_namespace(brain) @app.route('/') def index(): return render_template('index.html') print("OKss") def gen(channel): while True: if channel not in brain.channels: # print("OK") continue
def on_my_room_event(self, message): session['receive_count'] = session.get('receive_count', 0) + 1 emit('my_response', {'data': message['data'], 'count': session['receive_count']}, room=message['room']) def on_disconnect_request(self): session['receive_count'] = session.get('receive_count', 0) + 1 emit('my_response', {'data': 'Disconnected!', 'count': session['receive_count']}) disconnect() def on_my_ping(self): emit('my_pong') def on_connect(self): global thread if thread is None: thread = socketio.start_background_task(target=background_thread) emit('my_response', {'data': 'Connected', 'count': 0}) def on_disconnect(self): print('Client disconnected', request.sid) socketio.on_namespace(MyNamespace('/test')) if __name__ == '__main__': socketio.run(app, debug=True)