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)
