class Server(Flask):
def __init__(self):
super().__init__(__name__)
self.config["SECRET_KEY"] = "secret"
self.socketio = SocketIO(self)
self.configure_routes()
def send_data(self):
while True:
self.socketio.sleep(0.1)
output = read(self.file_descriptor, 1024).decode()
self.socketio.emit("output", output, namespace="/terminal")
def configure_routes(self):
@self.route("/")
def index():
return render_template("index.html")
@self.socketio.on("input", namespace="/terminal")
def input(data):
write(self.file_descriptor, data.encode())
@self.socketio.on("connect", namespace="/terminal")
def connect():
self.process_id, self.file_descriptor = fork()
if self.process_id:
self.socketio.start_background_task(target=self.send_data)
else:
command = (
"sshpass -p admin ssh -o StrictHostKeyChecking=no "
"-o UserKnownHostsFile=/dev/null [email protected]")
run(command.split())
class Server(Flask):
def __init__(self):
super().__init__(__name__)
self.config["SECRET_KEY"] = getenv("TERMINAL_SECRET_KEY", "secret_key")
self.socketio = SocketIO(
self, cors_allowed_origins=getenv("CORS_ALLOWED_ORIGINS")
)
self.configure_routes()
def send_data(self):
while True:
self.socketio.sleep(0.1)
output = read(self.file_descriptor, 1024).decode()
self.socketio.emit("output", output, namespace="/terminal")
def configure_routes(self):
@self.route(f"/{getenv('ENDPOINT')}")
def index():
redirection = getenv("REDIRECTION") == "True"
return render_template("index.html", redirection=redirection)
@self.route("/shutdown", methods=["POST"])
def shutdown():
request.environ.get("werkzeug.server.shutdown")()
post(
f"{getenv('APP_ADDRESS')}/rest/instance/session",
json={
"content": request.json,
"device_id": getenv("DEVICE"),
"name": str(uuid4()),
"timestamp": str(datetime.now()),
"user": getenv("USER"),
},
auth=HTTPBasicAuth(getenv("ENMS_USER"), getenv("ENMS_PASSWORD")),
verify=False if getenv("VERIFY_CERTIFICATE", True) == "False" else True,
)
return jsonify(True)
@self.socketio.on("input", namespace="/terminal")
def input(data):
write(self.file_descriptor, data.encode())
@self.socketio.on("connect", namespace="/terminal")
def connect():
self.process_id, self.file_descriptor = fork()
if self.process_id:
self.socketio.start_background_task(target=self.send_data)
else:
port = f"-p {getenv('PORT')}"
if getenv("PROTOCOL") == "telnet":
command = f"telnet {getenv('IP_ADDRESS')}"
elif getenv("PASSWORD"):
command = (
f"sshpass -p {getenv('PASSWORD')} ssh {getenv('OPTIONS')} "
f"{getenv('USERNAME')}@{getenv('IP_ADDRESS')} {port}"
)
else:
command = f"ssh {getenv('OPTIONS')} {getenv('IP_ADDRESS')} {port}"
run(command.split())
def create_app():
app = Flask(__name__)
app.url_map.strict_slashes = False
CORS(app)
@app.before_request
def before_request():
db.connect(reuse_if_open=True)
#pass
@app.after_request
def after_request(res):
db.close()
return res
# Register blueprints
app.register_blueprint(auth_bp)
app.register_blueprint(errors_bp)
app.register_blueprint(game_bp)
app.register_blueprint(notification_bp)
app.register_blueprint(alert_bp)
app.register_blueprint(tickers_bp)
app.register_blueprint(play_bp)
app.register_blueprint(join_bp)
app.register_blueprint(users_bp)
app.register_blueprint(reports_bp)
app.register_blueprint(friends_bp)
app.register_blueprint(achievement_bp)
app.register_blueprint(goal_bp)
@app.route('/')
def hello():
return 'hello world'
socketio = SocketIO(app, async_mode='eventlet', cors_allowed_origins='*')
#socketio = SocketIO(app, async_mode='threading', cors_allowed_origins='*')
@socketio.on('connect')
def on_connect():
tok = get_auth_token(request.args.get('token'))
if tok:
tok.profile.socket_id = request.sid
tok.profile.save()
tok.save()
def cb(tickers):
from scripts.serializers import TickersResponse
socketio.emit('message', TickersResponse.serialize(tickers, many=True))
register_socketio(socketio)
socketio.start_background_task(begin, cb=cb)
return app, socketio
def observer(session):
app = Flask(__name__)
app.config['SECRET_KEY'] = 'rahasia_banget!'
socket = SocketIO(app, async_mode=None, cors_allowed_origins="*")
thread = None
def backgroud_observer():
cond = ray.get(session.get_state.remote())
print(cond)
@socket.on("connect")
def connected_handler(data):
socket.emit("GAME_DATA", data=json.dumps(temp, cls=NpEncoder))
@socket.on("GAME_ACTION")
def handle_action(data):
key, action = data.split(".")
if key != SESSION_KEY:
return "Wrong Key"
if (action in cond["legal_move"]):
ray.get(session.set_action.remote(str(action)))
else:
return "Wrong Move"
return "Ok"
@socket.on("NEW_CHAT")
def handle_chat(data):
print(data)
socket.emit("GAME_CHAT", data, broadcast=True)
while (not cond["done"]):
temp = ray.get(session.get_state.remote())
if temp["user_turn"] != cond["user_turn"]:
print(temp)
socket.emit("GAME_DATA", data=json.dumps(temp, cls=NpEncoder))
cond = temp
socket.sleep(3)
continue
if thread == None:
thread = socket.start_background_task(backgroud_observer)
socket.run(app)
class MySocketIO(object):
''' SocketIO Route '''
def __init__(self, app):
self.__async_mode = None
self.__thread = None
self.__socketio = SocketIO(app, async_mode=self.__async_mode)
# example
def background_thread():
"""Example of how to send server generated events to clients."""
count = 0
while True:
self.__socketio.sleep(1)
count += 1
self.__socketio.emit('my_realtime_data', {
'data': 'Server generated event',
'count': count,
'random_number': random.randint(1, 10)
},
namespace='/test')
# socket routes
@self.__socketio.on('connect', namespace='/test')
def test_connect():
print('client connected')
# example of background task for front-end real-time chart
if self.__thread is None:
self.__thread = self.__socketio.start_background_task(
target=background_thread)
emit('my_response', {'data': 'Connected'})
@self.__socketio.on('disconnect', namespace='/test')
def test_disconnect():
print('client disconnected')
@self.__socketio.on('my_event', namespace='/test')
def test_message(message):
print('<--- my_event of socketio --->')
print str(message)
emit('my_response', {'data': message['data']})
def get_socketio(self):
return self.__socketio
class WebSocket(Module):
"""The WebSocket class is responsible for handling the websocket connection between frontend and backend.
In addition, it also serves the web frontend and provides the web client with all the static files."""
# 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.
SOCKETIO_ASYNC_MODE = None # "gevent"
NS = '/situationboard' # namespace
FF = 'frontend/' # frontend folder
MIME_JS = 'application/javascript'
def __init__(self, appInfo: AppInfo, settings: Settings,
database: Database):
super().__init__("websocket", settings)
self.appInfo = appInfo
self.settings = settings
self.database = database
self.pluginManager: Optional[PluginManager] = None
self.clientCount = 0
self.app = Flask(self.appInfo.name,
static_url_path='',
static_folder=WebSocket.FF,
template_folder=WebSocket.FF)
self.app.config['SECRET_KEY'] = 'secret!'
self.socketio = SocketIO(self.app,
async_mode=WebSocket.SOCKETIO_ASYNC_MODE)
self.btask: Any = None
def init(self, pluginManager: PluginManager) -> None:
self.pluginManager = pluginManager
# register flask handlers
self.app.after_request(self.__app_add_header)
self.app.add_url_rule('/<path:path>', 'send_static',
self.__app_send_static)
self.app.add_url_rule('/', 'index', self.__app_index)
self.app.add_url_rule('/js/situationboard.js', 'javascript_frontend',
self.__app_javascript_frontend)
self.app.add_url_rule('/js/frontend/util/settings.js',
'javascript_settings',
self.__app_javascript_settings)
# register web api (if configured)
if self.settings.getBackendWebAPI():
self.app.add_url_rule('/api/v1/stats', 'api_stats',
self.__api_stats)
self.app.add_url_rule('/api/v1/state', 'api_state',
self.__api_state)
# register socket io handlers
self.socketio.on_event("connect", self.__socket_connect, WebSocket.NS)
self.socketio.on_event("disconnect", self.__socket_disconnect,
WebSocket.NS)
self.socketio.on_event("get_last_alarm_events",
self.__socket_get_last_alarm_events,
WebSocket.NS)
self.socketio.on_event("get_stats", self.__socket_get_stats,
WebSocket.NS)
self.socketio.on_event("get_header", self.__socket_get_header,
WebSocket.NS)
self.socketio.on_event("get_news", self.__socket_get_news,
WebSocket.NS)
self.socketio.on_event("get_state", self.__socket_get_state,
WebSocket.NS)
def sleep(self, duration: int) -> None:
self.socketio.sleep(duration)
def start_background_task(self, target: Callable[[], None]) -> None:
self.btask = self.socketio.start_background_task(target=target)
def __broadcast(self, event: str, data: Dict[str, Any]) -> None:
self.socketio.emit(event, data, namespace=WebSocket.NS, broadcast=True)
def run(self) -> None:
port = self.settings.getBackendServerPort()
self.print(f"Listening on port {port}")
try:
self.socketio.run(self.app,
host=self.settings.getBackendServerHost(),
port=self.settings.getBackendServerPort(),
debug=self.settings.getBackendDebug(),
use_reloader=self.settings.getBackendReloader())
except OSError as ose:
if ose.errno == errno.EADDRINUSE:
self.fatal(f"Port {port} is already in use")
else:
self.fatal("Unhandled OS exception", ose)
except Exception as e:
self.fatal("Unhandled exception", e)
def app_test_client(self) -> Any:
return self.app.test_client()
def socket_test_client(self, appTestClient: Any = None) -> Any:
return self.socketio.test_client(self.app,
WebSocket.NS,
flask_test_client=appTestClient)
def __app_add_header(self, response: Any) -> Any:
response.headers['Cache-Control'] = 'public, max-age=0'
return response
def __app_send_static(self, path: Any) -> Any:
self.dbgPrint(f"Sending static file ({path})")
return send_from_directory('.', path)
def __app_javascript_frontend(self) -> Response:
template = "js/situationboard.js"
self.dbgPrint(f"Rendering template ({template})")
data = render_template(template,
tVersion=str(self.appInfo.version),
tStartTimestamp=str(self.appInfo.start))
return Response(data, mimetype=WebSocket.MIME_JS)
def __app_javascript_settings(self) -> Response:
template = "js/frontend/util/settings.js"
self.dbgPrint(f"Rendering template ({template})")
data = render_template(
template,
tDebug=str(self.settings.getFrontendDebug()).lower(),
tLanguage=str(self.settings.getFrontendLanguage()),
tAlarmDuration=str(self.settings.getFrontendAlarmDuration()),
tAlarmShowMaps=str(self.settings.getFrontendAlarmShowMaps()),
tCalendarURL=self.settings.getFrontendCalendarURL(),
tCalendarUpdateDuration=str(
self.settings.getFrontendCalendarUpdateDuration()),
tStandbyShowStatistics=str(
self.settings.getFrontendStandbyShowStatistics()).lower(),
tStandbyShowClock=str(
self.settings.getFrontendStandbyShowClock()).lower(),
tPageReloadDuration=str(
self.settings.getFrontendPageReloadDuration()),
tMapService=str(self.settings.getFrontendMapService()),
tMapAPIKey=str(self.settings.getFrontendMapAPIKey()),
tMapZoom=str(self.settings.getFrontendMapZoom()),
tMapType=str(self.settings.getFrontendMapType()),
tMapEmergencyLayer=str(
self.settings.getFrontendMapEmergencyLayer()),
tMapHomeLatitude=str(self.settings.getFrontendMapHomeLatitude()),
tMapHomeLongitude=str(self.settings.getFrontendMapHomeLongitude()),
tShowSplashScreen=str(
self.settings.getFrontendShowSplashScreen()).lower())
return Response(data, mimetype=WebSocket.MIME_JS)
def __app_index(self) -> Response:
template = "index.html"
self.dbgPrint(f"Rendering template ({template})")
data = render_template(template)
return Response(data)
def __api_stats(self) -> Dict[str, Any]:
self.dbgPrint("Answering stats Web API request")
return {'result': 'ok', 'stats': self.__get_stats_dict()}
def __api_state(self) -> Dict[str, Any]:
self.dbgPrint("Answering state Web API request")
return {'result': 'ok', 'state': self.__get_state_dict()}
def __socket_connect(self) -> None:
session["ClientID"] = self.clientCount
self.clientCount += 1
self.print(
f"Client {session['ClientID']} connected ({request.remote_addr}, {request.sid})"
) # type: ignore
def __socket_disconnect(self) -> None:
self.print(
f"Client {session['ClientID']} disconnected ({request.remote_addr}, {request.sid})"
) # type: ignore
def __socket_get_last_alarm_events(self, message: Any) -> None:
self.dbgPrint(
f"Answering get_last_alarm_events (Client {session['ClientID']})")
count = -1
if isinstance(message, dict) and 'count' in message:
if isinstance(message['count'], int):
count = message['count']
totalEvents = self.database.getEventCount(textOnly=True)
count = count if count > 0 else totalEvents
alarmEvents = self.database.getLastEvents(count, textOnly=True)
emit(
'last_alarm_events', {
'total_events':
totalEvents,
'alarm_events':
json.dumps([alarmEvent.toJSON() for alarmEvent in alarmEvents])
})
def __socket_get_stats(self) -> None:
self.dbgPrint(f"Answering get_stats (Client {session['ClientID']})")
emit('stats', self.__get_stats_dict())
def __socket_get_state(self) -> None:
# self.dbgPrint(f"Answering get_state (Client {session['ClientID']})")
emit('state', self.__get_state_dict())
def __socket_get_header(self) -> None:
self.dbgPrint(f"Answering get_header (Client {session['ClientID']})")
emit('header', {'header': self.settings.getFrontendHeader()})
def __socket_get_news(self) -> None:
self.dbgPrint(f"Answering get_news (Client {session['ClientID']})")
emit('news', {'news': self.settings.getFrontendNews()})
def broadcastHeader(self, header: str) -> None:
self.__broadcast('header', {'header': header})
def broadcastNews(self, news: str) -> None:
self.__broadcast('news', {'news': news})
def broadcastAlarmEvent(self, alarmEvent: AlarmEvent) -> None:
self.__broadcast('alarm_event', alarmEvent.toJSON())
def broadcastDatabaseChanged(self) -> None:
self.__broadcast('database_changed', {})
def broadcastCalendarChanged(self) -> None:
self.__broadcast('calendar_changed', {})
def __get_stats_dict(self) -> Dict[str, Any]:
statsDict = {
'total':
self.database.getEventStats(DatabaseTimespan.TOTAL, textOnly=True),
'year':
self.database.getEventStats(DatabaseTimespan.YEAR, textOnly=True),
'month':
self.database.getEventStats(DatabaseTimespan.MONTH, textOnly=True),
'today':
self.database.getEventStats(DatabaseTimespan.TODAY, textOnly=True)
}
return statsDict
def __get_state_dict(self) -> Dict[str, Any]:
if self.pluginManager is None:
self.fatal("PluginManager not available")
state: SourceState = self.pluginManager.getSourceState()
stateDict = {
'version': self.appInfo.version,
'start_timestamp': self.appInfo.start,
'source_state': int(state)
}
return stateDict
@socketio.on('data')
def handle_data(data):
"""Stores the received audio data in a local buffer."""
encoded = base64.b64encode(data)
buff.put(encoded, block=False)
def _enqueue_audio(redis_queue):
"""Blocking-reads data from the buffer and adds to Redis queue."""
while True:
try:
chunk = buff.get(block=True)
val = rdb.lpush(redis_queue, chunk)
# debugging; under normal circumstances audio should not be accumulating
if val > 5:
print('Ingested audio queue length: %d' % val)
except redis.exceptions.RedisError as err:
print('Error pushing into Redis queue: %s' % err)
@app.route('/')
def hello_world():
return 'Hello from ' + args.id
if __name__ == '__main__':
socketio.init_app(app)
socketio.start_background_task(_enqueue_audio, args.redisQueue)
socketio.run(app, host=args.host, port=args.port)
if sanity_check_counter == int(sanity_interval / interval):
content = previous_content
sanity_check_counter = 0
if len(content) != 0:
socketio.emit('newdata', content, namespace='/api')
socketio.sleep(interval)
@app.route('/')
def hello_world():
return render_template('index.html')
@socketio.on('slider', namespace='/api')
def slider(data):
print('slider value updated: %s' % data.get('value'))
@socketio.on('connect', namespace='/api')
def connect():
socketio.emit('newdata', aggregator.get_content(), namespace='/api')
if __name__ == '__main__':
aggregator = Aggregator.Aggregator()
command = sys.argv[1] if len(sys.argv) > 1 else "python3 ./test.py"
aggregator.register_component(command)
aggregator.start_gathering()
socketio.start_background_task(target=update)
socketio.run(app, host='0.0.0.0', port=8080)
## Start Background Jobs
def job(key, interval, method):
app.logger.info("Start Job: " + method.__name__ + " Interval:" + str(interval) + " Key:" + key)
while app.brewapp_jobstate[key]:
try:
method()
except Exception as e:
print e
app.logger.error("Exception" + method.__name__ + ": " + str(e))
socketio.sleep(interval)
app.logger.info("## INITIALIZE JOBS")
for i in app.brewapp_jobs:
if(i.get("config_parameter") != None):
param = app.brewapp_config.get(i.get("config_parameter"), False)
if(param == 'False'):
continue
app.brewapp_jobstate[i.get("key")] = True
t = socketio.start_background_task(target=job, key=i.get("key"), interval=i.get("interval"), method=i.get("function"))
app.logger.info("--> Method:" + i.get("function").__name__ + "() File: "+ inspect.getfile(i.get("function")))
@socketio.on('ui-to-server-reset-match')
def ui_to_server_reset_match():
lcm_send(LCM_TARGETS.SHEPHERD, SHEPHERD_HEADER.RESET_MATCH)
def receiver():
events = gevent.queue.Queue()
lcm_start_read(str.encode(LCM_TARGETS.UI), events)
counter = 0
while True:
counter = (counter + 1) % 10
if not events.empty():
event = events.get_nowait()
print("RECEIVED:", event)
if event[0] == UI_HEADER.RFID_LIST:
socketio.emit('server-to-ui-rfidlist',
json.dumps(event[1], ensure_ascii=False))
elif event[0] == UI_HEADER.TEAMS_INFO:
socketio.emit('server-to-ui-teamsinfo',
json.dumps(event[1], ensure_ascii=False))
elif event[0] == UI_HEADER.SCORES:
socketio.emit('server-to-ui-scores',
json.dumps(event[1], ensure_ascii=False))
socketio.sleep(0.1)
socketio.start_background_task(receiver)
socketio.run(app, host=HOST_URL, port=PORT)
if action['kind'] in allowed_actions:
log.game_event(f'action: {action} by {request.sid}')
ticker.enqueue_action(action, request.sid)
@socketio.on('chat')
def handle_chat(incoming):
"""Respond to `chat` message from the frontend.
`incoming` is `{'body': 'the message content'}`.
"""
trimmed_message = incoming['body'].strip()
if trimmed_message:
outgoing = {
'id': client_names.get(request.sid),
'body': sanitize(trimmed_message),
}
log.game_event(f'chat_message: {outgoing}')
socketio.emit('chat', outgoing)
if __name__ == '__main__':
print(f"Starting server at {HOST}:{PORT}")
socketio.start_background_task(ticker.run_ticker, socketio, client_names)
socketio.run(app,
use_reloader=True,
debug=True,
log_output=True,
host=HOST,
port=PORT)
sampled_message = sample(messages, 1)[0]
msg = {**sampled_message, '_id': id_ticker}
id_ticker += 1
print(">>>> emitting >>>> ", id_ticker)
sio.emit('message', msg)
sio.sleep(0.15)
##
## Entry point
##
if __name__ == '__main__':
print("+ starting bg tasks")
q = Queue()
args = parser.parse_args()
if args.test:
print("+ TEST MODE: sending fake messages down the tube")
sio.start_background_task(test_serial_listener, sio)
else:
filename, baud = get_config(args)
serial_thread = Thread(target=serial_thread, args=(q, filename, baud))
serial_thread.daemon = True
serial_thread.start()
sio.start_background_task(serial_listener, sio, q)
print("+ starting app on 0.0.0.0:5000")
sio.run(app, host='0.0.0.0', port=5000)
## Start Background Jobs
def job(key, interval, method):
app.logger.info("Start Job: " + method.__name__ + " Interval:" +
str(interval) + " Key:" + key)
while app.brewapp_jobstate[key]:
try:
method()
except Exception as e:
print e
app.logger.error("Exception" + method.__name__ + ": " + str(e))
socketio.sleep(interval)
app.logger.info("## INITIALIZE JOBS")
for i in app.brewapp_jobs:
if (i.get("config_parameter") != None):
param = app.brewapp_config.get(i.get("config_parameter"), False)
if (param == 'False'):
continue
app.brewapp_jobstate[i.get("key")] = True
t = socketio.start_background_task(target=job,
key=i.get("key"),
interval=i.get("interval"),
method=i.get("function"))
app.logger.info("--> Method:" + i.get("function").__name__ + "() File: " +
inspect.getfile(i.get("function")))
global thread1, thread2
with thread_lock:
if thread2 is None:
thread2 = socketio.start_background_task(conn_info, socketio)
if __name__ == '__main__':
from demo_text.utils.utils import loop_task
scheduler.add_job(func=loop_task,
id='loop_task',
jobstore='redis',
replace_existing=True,
trigger='cron',
day_of_week='0-6',
hour=0,
minute=0,
second=0)
# 配置socket服务
socketio = SocketIO(app, cors_allowed_origins="*")
async_mode = 'eventlet'
socketio.init_app(app, async_mode=async_mode)
socketio.start_background_task(get_data_list, socketio)
# 启动api server
socketio.run(app,
host=Config.HTTP_HOST,
port=Config.HTTP_PORT,
log_output=True)
@socketio.on('disconnect')
def disconnect():
print('Client disconnected from %s' % args.id)
buff.get_nowait()
def _qread():
while True:
while not buff.empty():
try:
fragment = rdb.brpop(args.redisQueue, timeout=2)
if fragment is not None:
socketio.emit('transcript', fragment[1].decode('utf-8'))
except redis.exceptions.ReadOnlyError as re:
print('Redis ReadOnlyError (failover?): %s' % re)
socketio.emit('transcript', '[REDIS-FAILOVER]')
# sleep for long enough for health checks to kick in
socketio.sleep(health_check_interval)
except redis.exceptions.RedisError as err:
print('RedisError: %s' % err)
socketio.sleep(0.2)
if __name__ == '__main__':
print('Starting %s...' % args.id)
socketio.init_app(app)
socketio.start_background_task(_qread)
socketio.run(app, host=args.host, port=args.port)
# Start server
log = logging.getLogger('werkzeug')
log.setLevel(logging.ERROR)
socketio.run(app, host='127.0.0.1', port=5001)
except KeyboardInterrupt:
print("\nExit requested by user")
robot = None
app = Flask(__name__)
app.config['SECRET_KEY'] = 'somesecretphrase'
app.register_blueprint(viewer)
app.register_blueprint(remote_control)
socketio = SocketIO(app, async_mode='threading')
eventQueue = queue.Queue()
thread = socketio.start_background_task(notify_events, eventQueue)
# Instruct Cozmo not to drive off charger
cozmo.robot.Robot.drive_off_charger_on_connect = False
cozmo.run_program(cozmo_program)
@socketio.on('connect')
def on_socket_connect():
global robot
global socketio
socketio.emit(
'initialization', {
battery_voltage: robot.battery_voltage,
is_on_charger: robot.is_on_charger,
})
class BackendServer:
"""Create small class for storing variables and state of the backend."""
# pylint: disable=too-many-instance-attributes
def __init__(self, graphml_dir, frontend_url):
"""Create and setup the state variables."""
self.app = flask.Flask(__name__)
self.socketio = SocketIO(self.app, cors_allowed_origins=frontend_url)
self.app.config['CORS_HEADERS'] = 'Content-Type'
CORS(self.app, resources={r"/*": {"origins": frontend_url}})
self.app.add_url_rule("/graph_files", "return_graph_files",
self.return_graph_files)
self.socketio.on_event('git_hash_selected', self.git_hash_selected)
self.socketio.on_event('row_selected', self.row_selected)
self.loaded_graphs = {}
self.current_selected_rows = {}
self.graphml_dir = Path(graphml_dir)
self.frontend_url = frontend_url
self.graph_file_tuple = namedtuple(
'GraphFile', ['version', 'git_hash', 'graph_file'])
self.graph_files = self.get_graphml_files()
try:
default_selected_graph = list(
self.graph_files.items())[0][1].graph_file
self.load_graph_from_file(default_selected_graph)
self._dependents_graph = networkx.reverse_view(
self._dependency_graph)
except (IndexError, AttributeError) as ex:
print(ex)
print(
f"Failed to load read a graph file from {list(self.graph_files.items())} for graphml_dir '{self.graphml_dir}'"
)
exit(1)
def load_graph_from_file(self, file_path):
"""Load a graph file from disk and handle version."""
graph = libdeps.graph.LibdepsGraph(networkx.read_graphml(file_path))
if graph.graph['graph_schema_version'] == 1:
self._dependents_graph = graph
self._dependency_graph = networkx.reverse_view(
self._dependents_graph)
else:
self._dependency_graph = graph
self._dependents_graph = networkx.reverse_view(
self._dependency_graph)
def get_app(self):
"""Return the app and socketio instances."""
return self.app, self.socketio
def get_graph_build_data(self, graph_file):
"""Fast method for extracting basic build data from the graph file."""
version = ''
git_hash = ''
# pylint: disable=c-extension-no-member
for _, element in etree.iterparse(
str(graph_file),
tag="{http://graphml.graphdrawing.org/xmlns}data"):
if element.get('key') == 'graph_schema_version':
version = element.text
if element.get('key') == 'git_hash':
git_hash = element.text
element.clear()
if version and git_hash:
break
return self.graph_file_tuple(version, git_hash, graph_file)
def get_graphml_files(self):
"""Find all graphml files in the target graphml dir."""
graph_files = OrderedDict()
for graph_file in self.graphml_dir.glob("**/*.graphml"):
graph_file_tuple = self.get_graph_build_data(graph_file)
graph_files[graph_file_tuple.git_hash[:7]] = graph_file_tuple
return graph_files
def return_graph_files(self):
"""Prepare the list of graph files for the frontend."""
data = {'graph_files': []}
for i, (_, graph_file_data) in enumerate(self.graph_files.items(),
start=1):
data['graph_files'].append({
'id': i,
'version': graph_file_data.version,
'git': graph_file_data.git_hash[:7],
'selected': False
})
return data
def send_node_infos(self):
"""Search through the selected rows and find information about the selected rows."""
with self.app.test_request_context():
nodeinfo_data = {'nodeInfos': []}
for node, _ in self.current_selected_rows.items():
nodeinfo_data['nodeInfos'].append({
'id':
len(nodeinfo_data['nodeInfos']),
'node':
str(node),
'name':
node.name,
'attribs': [{
'name': key,
'value': value
} for key, value in self._dependents_graph.nodes(
data=True)[str(node)].items()],
'dependers': [{
'node':
depender,
'symbols':
self._dependents_graph[str(node)][depender].get(
'symbols', '').split(' ')
} for depender in self._dependents_graph[str(node)]],
'dependencies': [{
'node':
dependency,
'symbols':
self._dependents_graph[dependency][str(node)].get(
'symbols', '').split(' ')
} for dependency in self._dependency_graph[str(node)]],
})
self.socketio.emit("node_infos", nodeinfo_data)
def send_graph_data(self):
"""Convert the current selected rows into a format for D3."""
with self.app.test_request_context():
nodes = set()
links = set()
for node, _ in self.current_selected_rows.items():
nodes.add(
tuple({
'id':
str(node),
'name':
node.name,
'type':
self._dependents_graph.nodes()[str(node)]['bin_type']
}.items()))
for depender in self._dependency_graph[str(node)]:
depender_path = Path(depender)
if self._dependents_graph[depender][str(node)].get(
'direct'):
nodes.add(
tuple({
'id':
str(depender_path),
'name':
depender_path.name,
'type':
self._dependents_graph.nodes()[str(
depender_path)]['bin_type']
}.items()))
links.add(
tuple({
'source': str(node),
'target': str(depender_path)
}.items()))
node_data = {
'graphData': {
'nodes': [dict(node) for node in nodes],
'links': [dict(link) for link in links],
},
'selectedNodes': [
str(node)
for node in list(self.current_selected_rows.keys())
]
}
self.socketio.emit("graph_data", node_data)
def row_selected(self, message):
"""Construct the new graphData nodeInfo when a cell is selected."""
print(f"Got row {message}!")
if message['isSelected'] == 'flip':
if message['data']['node'] in self.current_selected_rows:
self.current_selected_rows.pop(message['data']['node'])
else:
self.current_selected_rows[Path(
message['data']['node'])] = message['data']
else:
if message['isSelected'] and message:
self.current_selected_rows[Path(
message['data']['node'])] = message['data']
else:
self.current_selected_rows.pop(message['data']['node'])
self.socketio.start_background_task(self.send_graph_data)
self.socketio.start_background_task(self.send_node_infos)
def analyze_counts(self):
"""Perform count analysis and send the results back to frontend."""
with self.app.test_request_context():
analysis = libdeps.analyzer.counter_factory(
self._dependents_graph, [
name[0] for name in
libdeps.analyzer.CountTypes.__members__.items()
])
ga = libdeps.analyzer.LibdepsGraphAnalysis(
libdeps_graph=self._dependents_graph, analysis=analysis)
results = ga.get_results()
graph_data = []
for i, data in enumerate(results):
graph_data.append({
'id': i,
'type': data,
'value': results[data]
})
self.socketio.emit("graph_results", graph_data)
def send_node_list(self):
"""Gather all the nodes in the graph for the node list."""
with self.app.test_request_context():
node_data = {
'graphData': {
'nodes': [],
'links': []
},
"selectedNodes": [
str(node)
for node in list(self.current_selected_rows.keys())
]
}
for node in self._dependents_graph.nodes():
node_path = Path(node)
node_data['graphData']['nodes'].append({
'id': str(node_path),
'name': node_path.name
})
self.socketio.emit("graph_nodes", node_data)
def load_graph(self, message):
"""Load the graph into application memory and kick off threads for analysis on new graph."""
with self.app.test_request_context():
current_hash = self._dependents_graph.graph.get(
'git_hash', 'NO_HASH')[:7]
if current_hash != message['hash']:
self.current_selected_rows = {}
if message['hash'] in self.loaded_graphs:
self._dependents_graph = self.loaded_graphs[
message['hash']]
self._dependents_graph = networkx.reverse_view(
self._dependency_graph)
else:
print(
f'loading new graph {current_hash} because different than {message["hash"]}'
)
self.load_graph_from_file(
self.graph_files[message['hash']].graph_file)
self.loaded_graphs[
message['hash']] = self._dependents_graph
self.socketio.start_background_task(self.analyze_counts)
self.socketio.start_background_task(self.send_node_list)
self.socketio.emit("graph_data",
{'graphData': {
'nodes': [],
'links': []
}})
def git_hash_selected(self, message):
"""Load the new graph and perform queries on it."""
print(f"Got requests2 {message}!")
emit("other_hash_selected", message, broadcast=True)
self.socketio.start_background_task(self.load_graph, message)
periodicFetcher.register_callback(MeteoSchweiz.update,
frequency=1800,
single_shot=False)
periodicFetcher.register_callback(Transferwise.update,
frequency=600,
single_shot=False)
periodicFetcher.register_callback(nettime.Nettime.update,
frequency=14400,
single_shot=False)
periodicFetcher.register_callback(financestatus.FinanceStatus.update,
frequency=3600,
single_shot=False)
periodicFetcher.register_callback(carddav.sync,
frequency=3600,
single_shot=False)
socketio.start_background_task(periodicFetcher.run)
def pingSocket(socketio):
socketio.emit('pinging', '')
socketio.sleep(10)
socketio.start_background_task(pingSocket, socketio)
socketio.start_background_task(pingSocket, socketio)
@socketio.on('message')
def handle_message(message):
print('received message: ' + message)
socketio.send('received message: ' + message)
userClickButton(button) # 逻辑层
sendSettingsToUser()
@socketio.on('syncSettings')
def ws_syncSettings(settings):
userSyncSettings(settings)
sendSettingsToUser()
def sendSettingsToUser():
settings = nowSettings() # 逻辑层的事情
socketio.emit('settings', settings, broadcast=True)
socketio.start_background_task(maincall)
def timerSendUpdatedStateToUsers():
while True:
socketio.sleep(0.3)
if main.changed:
main.changed = False
sendSettingsToUser()
socketio.start_background_task(timerSendUpdatedStateToUsers)
if __name__ == '__main__':
parser = OptionParser()
parser.add_option("--host",
type="string",
# don't go crazy ... reset; ie if processor is lagging heavily, ignore the noise
distance = abs(desired_rate - self.update_rate);
if distance > MAX_SAFE_PID_DISTANCE:
# reset
_logger.debug("reset rate")
self.__init__.reset_update_rate_pid_params()
if len(payload) > 2:
socketio.emit('message', {'command': 'update', 'payload': payload})
self.last_transmitted_state = payload
socketio.start_background_task(target=self.device_loop)
if __name__ == '__main__':
# app.run(port=8888, debug=True)
# support for websockets via flask-socketio
app.network_state = NetworkState()
# from threading import Thread
# foo = Thread(target=app.network_state.device_loop, daemon=True)
# foo.start()
socketio.start_background_task(target=app.network_state.device_loop)
logging.getLogger('socketio').setLevel(logging.WARN)
logging.getLogger('engineio').setLevel(logging.WARN)
socketio.run(app, host='0.0.0.0', port=8888)
'id': job_id,
}
# Reject any more applications when the job is full
if job.get().get('total_workers') == job.get().get(
'needed_workers'):
job.update({'is_full': True})
payload['is_full'] = True
name = job.get().get('name')
salary = job.get().get('salary')
socketio.emit('registered', {'name': name, 'salary': salary})
# send a live update to every clients
payload['needed_workers'] = needed_workers
socketio.send(payload, broadcast=True)
print("SENT AN UPDATE")
# Send an update to notify the client that the registration
# is completed
except Exception as e:
return f"An Error occured: {e}"
finally:
return {}, 200
if __name__ == "__main__":
# Establish a watcher for Firestore changes
# jobs_ref.on_snapshot(on_snapshot)
socketio.start_background_task(jobs_ref.on_snapshot, on_snapshot)
socketio.run(app, host='0.0.0.0', port=5000)
utils.save_config(config, file_name=config_name)
ivans[pair].update_config(config)
log_event('info', 'Setting {pair} saved.'.format(pair=pair))
@socketio.on('load_config_req', namespace='/test')
def load_settings(pair):
config_name = 'config-{pair}.json'.format(pair=pair)
config = utils.load_config(config_name)
emit('load_config_res', {'data': config, 'pair': pair}, namespace='/test')
@socketio.on('restart', namespace='/test')
def restart():
log_event('info', 'Restart... Not implemented.')
@socketio.on('start', namespace='/test')
def start(state):
global stopped
stopped = state
log_event('action',
'Bot is activated.' if not state else 'Bot is deactivated.')
if thread is None:
thread = socketio.start_background_task(target=background_thread)
if __name__ == '__main__':
socketio.run(app, host='0.0.0.0', port=5000, debug=True)
vx1 = v0 * math.cos(2 * math.pi / circle * play["cnt"])
vy1 = v0 * math.sin(2 * math.pi / circle * play["cnt"])
setspeed({"vx": vx1, "vy": vy1})
sendSpeedToUser()
else:
play["step"] = 0
play["cnt"] = 0
def bkgtask():
while True:
socketio.sleep(0.05)
timer50ms()
socketio.start_background_task(bkgtask)
if __name__ == '__main__':
parser = OptionParser()
parser.add_option("--host",
type="string",
dest="host",
help="Server Host IP",
default="0.0.0.0")
parser.add_option("--port",
type="int",
dest="port",
help="Server Host Port",
default=8080)
parser.add_option("--serial",
type="string",
},
namespace=name_space)
except:
print("Ooops! {}".format(data if data else "Nothing received!"))
socketio.emit("update", {'err': 1}, namespace=name_space)
app = Flask(__name__)
app.config['SECRET_KEY'] = 'ballbot1'
app.config['TEMPLATES_AUTO_RELOAD'] = True
app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER
socketio = SocketIO(app, async_mode=None)
with thread_lock:
if thread_ser is None:
thread_ser = socketio.start_background_task(serial_thread)
print("Started background serial thread")
@app.route('/', methods=['GET', 'POST'])
def index():
if request.method == 'GET':
return render_template('index.html')
elif request.method == 'POST':
if 'file' not in request.files:
flash("No file uploaded")
return redirect(request.url)
ffile = request.files['file']
if ffile.filename == '':
flash("No file selected")
return redirect(request.url)
"""On disconnect, print to stdout. Just FYI."""
print('Client disconnected')
# This script is intended to run from the command-line.
if __name__ == '__main__':
# Initialize the store with its Bluemix services for the web UI
watson = WatsonEnv.get_watson_online_store()
if watson:
# If env setup succeeded, get another instance to use for slack.
# Separate instances to keep the web UI identity separate from
# the slack user.
slack_wos = WatsonEnv.get_watson_online_store()
socketio.start_background_task(slack_wos.run)
else:
# Note: Failure during Slack setup does not cause a fail. The web UI
# is running and will report an error message.
print('Slack integration is not started because of missing environment'
' variables.')
# The Bluemix port is passed in with a PORT environment variable.
# This allows Bluemix health check to work. Otherwise the default
# port for a Flask server is 5000.
port = os.environ.get("PORT")
# Run the web app.
# Use 0.0.0.0 to allow remote connections.
# Use PORT environment variable (set above) to set the port.
socketio.run(app, host='0.0.0.0', port=port)
if world.travel(player, data["city"], data["mode"]):
sendj("city", None)
sendMarket(player, player["market"])
elif typ == "store":
world.store(player, data["item"], data["count"])
sendj("player", player)
elif typ == "unstore":
world.unstore(player, data["item"], data["count"])
sendj("player", player)
elif typ == "cancelOrder":
world.cancelOrder(player, player["location"], data["bos"], data["oid"])
sendMarket(player, player["market"])
elif typ == "logout":
session["player"]["online"] = False
session["player"] = None
def save_world():
world.save()
if __name__ == '__main__':
atexit.register(save_world)
socketio.start_background_task(world_tick)
socketio.run(app, host="0.0.0.0", port=9999)
# TODO backup world on server shutdown, reload from latest save
socketio.send(json.dumps({stream: line, "token": token}),
namespace="/minigui", json=True)
print(stream, "bg_thread died")
@socketio.on("gtpcmd", namespace="/minigui")
def stdin_cmd(message):
print("C -> E:", message)
global p
try:
p.stdin.write(bytes(message["data"] + "\r\n", encoding="utf-8"))
p.stdin.flush()
except BrokenPipeError:
p = _open_pipes()
p = _open_pipes()
stderr_thread = socketio.start_background_task(
target=functools.partial(std_bg_thread, "stderr"))
stdout_thread = socketio.start_background_task(
target=functools.partial(std_bg_thread, "stdout"))
@app.route("/")
def index():
return app.send_static_file("index.html")
if __name__ == "__main__":
socketio.run(app, port=args.port, host=args.host)
@app.route("/")
def index():
return render_template("index.html")
@app.route("/dash")
def dash():
return render_template("dash.html")
@socketio.on("client_connected")
def client_connected(data):
print("connected~")
print(str(data))
@socketio.on("connected")
def connected():
print("connected")
@socketio.on("disconnected")
def disconnected():
print("disconnected")
if __name__ == "__main__":
socketio.start_background_task(target=check_serial)
socketio.run(app)
try:
try:
ser = serial.Serial(sys.argv[1], 115200)
# subprocess.Popen(['python', 'buttonListener.py', sys.argv[1]])
def buttonListener():
while 42:
on_button_press({
'color': {
'R': 'red',
'G': 'green',
'B': 'blue'
}[ser.read(1).decode('utf-8')]
})
socketio.start_background_task(target=buttonListener)
except IndexError:
print(
'ERROR: Please provide an USB to i/o on (eg: python __init__.py /dev/ttyUSB0)'
)
print("Starting websocket server")
socketio.run(app, host=ADDR[0], port=ADDR[1])
# socketio.run(app, host=ADDR[0], port=ADDR[1], debug=True)
finally:
try:
ser.close()
except AttributeError:
pass
label = classify_tweet(twt['text'])
print(twt['text'] + ' -> ' + str(label))
lat = twt["coordinates"]["coordinates"][0]
lon = twt["coordinates"]["coordinates"][1]
txt = twt['text']
socketio.emit('tweet', {
'lat': str(lat),
'long': str(lon),
'score': str(label),
'tweetid': txt
},
namespace='/test')
except TwitterRequestError as e:
if e.status_code < 500:
# something needs to be fixed before re-connecting
raise
else:
# temporary interruption, re-try request
pass
except TwitterConnectionError:
# temporary interruption, re-try request
pass
@app.route('/')
def index():
return render_template('index.html', async_mode=socketio.async_mode)
if __name__ == '__main__':
socketio.start_background_task(background_thread)
socketio.run(app, debug=True, use_reloader=False)
if msg_header == "PEER" and msg_dict not in peer_list:
with open(PEER_LIST_FILE, "w+") as f:
peer_list.append(msg_dict)
json.dump(peer_list, f)
# XXX: Tendría ahora que haber uno para VOTE
# que es ya el otro importante
if msg_header == "VOTE":
pass
pub_socket.send(msg)
else:
eventlet.sleep(2)
except Exception as e:
logger.warning(e)
socketio.start_background_task(target=handle_nodes)
def run_proof_of_work():
"""
Corre proof-of-work sobre las *blockchains* conocidas.
Esta función corre en un hilo propio.
"""
logger.debug("STARTED BACKGROUND TASK: PROOF OF WORK")
while True:
for chain in chain_ring.values():
idx = chain.create_new_block(chain.proof_of_work()).get("index")
if idx:
logger.info("BLOQUE (N {}) CREADO EN ELECCIÓN {}".format(
idx, chain.name))