def create_app():
app = Flask(__name__)
app.config['SECRET_KEY'] = '9OLWxND4o83j4K4iuopO'
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///db.sqlite'
socketio = SocketIO(app)
def random_handle():
interval = random.randint(0, 10)
time.sleep(interval)
nrandom = random.randint(0, 100)
socketio.emit('send_random', {'nrandom': nrandom})
socketio.on_event('get_random', random_handle)
db.init_app(app)
login_manager = LoginManager()
login_manager.login_view = 'auth.login'
login_manager.init_app(app)
from .models import User
@login_manager.user_loader
def load_user(user_id):
return User.query.get(int(user_id))
from .auth import auth as auth_blueprint
app.register_blueprint(auth_blueprint)
from .main import main as main_blueprint
app.register_blueprint(main_blueprint)
return app
def create_app(config="rooaa.settings.ProdConfig"):
""" Creates configured Flask app """
app = Flask(__name__)
# Load given settings
app.config.from_object(obj=config)
from rooaa.api.predict import predict, detect_objects
from rooaa.api.upload import upload
from rooaa.api.camera import camera
#! Temporary fix for XMLHttpRequest not working
CORS(upload)
CORS(predict)
# Register prediction routes
app.register_blueprint(blueprint=predict)
# Register image upload routes
app.register_blueprint(blueprint=upload)
# Register CameraApp routes
app.register_blueprint(blueprint=camera)
# Register error handlers
app.register_error_handler(code_or_exception=400, f=bad_request)
socketio = SocketIO(app)
socketio.on_event('prediction', detect_objects, namespace='/predict')
return socketio, app
class WebAppController(Thread):
def __init__(self, robot):
super(WebAppController, self).__init__()
self.robot = robot
self.servo = ServoSG90(self.robot.board, [7], reverse=True)
self.app = Flask(__name__, static_folder='/build')
self.socketio = SocketIO(self.app)
self.app.add_url_rule('/', view_func=self.index_page)
self.socketio.on_event("subscribeToData", self.handle_subscription)
self.start()
def run(self):
self.app.run(host='0.0.0.0', port=3001)
def index_page(self):
return self.app.send_static_file('index.html')
def handle_subscription(self, message):
t = set_interval(self.handle_subscription_1, 1.85)
# t.cancel()
def handle_subscription_1(self):
data = {}
for angle in range(0, 181, 5):
self.servo.set_degrees(angle)
data[angle] = statistics.median(
[self.robot.sensors[0].get_distance() for _ in range(10)])
data[angle] = self.robot.sensors[0].get_distance()
time.sleep(0.05)
self.socketio.emit("subscribeToData", data=data)
class WsServer:
"""
Simple websocket server.
"""
def __init__(self):
self.app = Flask(__name__)
self.app.config['SECRET_KEY'] = 'secret!'
self.socketIO = SocketIO(self.app)
self.mongoClient = MongoClient()
self.socketIO.on_event('broadcast', self.handleBroadcast)
self.socketIO.on_event('getUsers', self.getUsers)
def run(self):
"""
Starts the websocket server.
"""
self.socketIO.run(self.app)
def handleBroadcast(self, msg):
"""
Sends the given message to all connected clients.
"""
print('broadcast: {}'.format(msg))
emit('broadcast', msg, broadcast=True)
def getUsers(self):
"""
Returns all users.
"""
users = self.mongoClient.getUsers()
data = json.dumps(users)
print(data)
emit('getUsers', data)
def create_app(register_blueprint=True):
app = Flask(__name__)
app.secret_key = os.urandom(42)
if register_blueprint:
app.register_blueprint(plotting_blueprint)
socketio = SocketIO(app, message_queue='redis://localhost:6379/')
socketio.on_event('connect', bootstrap_on_connect)
return socketio, app
class StreamWebsocketServer(Thread, Observer):
'''Sends stream changes to web UI.'''
def __init__(self, config, store):
Thread.__init__(self)
self.app = Flask(__name__)
self.configure_flask()
self.socketio = SocketIO(
self.app, logger=logger, engineio_logger=False)
self.configure_socketio()
self.store = store
def on_next(self, stream_change):
'''Responds to updates to the stream_changes observable.'''
logger.debug('Broadcasting stream change to clients...')
logger.debug(str(stream_change))
streams = list(map(lambda stream: stream.data,
self.store.read_streams()))
streams = sorted(
streams, key=lambda stream: stream['viewers'], reverse=True)
self.socketio.emit('streams', streams, broadcast=True)
def configure_flask(self):
self.app.config['SECRET_KEY'] = 'secret!'
def handler():
return render_template('eternal-twitch.html')
self.app.add_url_rule('/', 'eternal_twitch', handler)
def configure_socketio(self):
def handle_connection():
self.on_next({ 'type': 'connection' })
self.socketio.on_event('connected', handle_connection)
def run(self):
'''Subscribes websocket server to changes to the store.'''
self.disposer = self.store.stream_changes.pipe(
debounce(1)
).subscribe(self)
self.socketio.run(self.app, host='0.0.0.0',
debug=False, use_reloader=False)
def stop_socketio(self):
def handler():
self.socketio.stop()
self.socketio.on('stop', handler)
def stop(self):
'''Stops sending store updates to websocket server.'''
logger.info('Stopping stream websocket server...')
if hasattr(self, 'disposer'):
self.disposer.dispose()
self.stop_socketio()
class Deployment:
def __init__(self):
""" Create a deployment object and define
possible commands to be executed """
self.socketio = SocketIO(message_queue='redis://')
def update_position(self, data):
print("updating position")
def testing(self):
self.socketio.emit("testing deployment socket", namespace='/test')
self.socketio.on_event('update table', self.update_position)
def create_app(config_name):
f_config = config_dict[config_name]
app = Flask(__name__,
template_folder=f_config.STATIC_FOLDER,
static_url_path='',
static_folder=f_config.STATIC_FOLDER)
CORS(app,
resources={
r"/dataset/*": {
"origin": "*"
},
r"/devices/*": {
"origin": "*"
},
r"/slack/*": {
"origin": "*"
},
})
app.config.from_object(f_config)
app.config['MONGODB_SETTINGS'] = config_database
socket = SocketIO(app)
socket.init_app(app, cors_allowed_origins="*")
print('Attempt to connect to MongoDB...')
global is_connected
client = MongoClient()
try:
# The ismaster command is cheap and does not require auth.
client.admin.command('ismaster')
is_connected = True
print('Connected to MongoDB!')
except ConnectionFailure:
print(
'Failed to connect to MongoDB. You should restart server to reconnect!'
)
is_connected = False
api = Api(app)
api.add_resource(Main, '/', '/<path:path>')
api.add_resource(Dataset, '/dataset')
api.add_resource(Devices, '/devices')
api.add_resource(Slack, '/slack/')
socket.on_event('get_data', getData)
socket.on_event('get_dashboard_data', get_dashboard_data)
socket.on_event('get_data_by_command', get_data_by_command)
socket.on_event('stop_command_run', stop_command_run)
socket.on_event('health_check', health_check)
return app, socket
class PhraseSocket:
def __init__(self, app):
self.socketio = SocketIO(app, cors_allowed_origins="*")
self.connections = list()
self.socketio.on_event("join", self.on_join)
self.db = Database()
self.db.connect()
def ping(self, username, phrases, stage):
if username in self.connections:
print("gang {}".format(phrases))
phraseResults = list()
for item in phrases:
ts = item["timestamp"]
if ts > 16048547531: #if timestamp is in milliseconds, turn into seconds
ts = ts / 1000
item["prettyTime"] = datetime.fromtimestamp(ts).strftime(
"%a, %b %-d %-I:%M %p")
phraseResults.append(item)
self.socketio.emit("my_response", {
"phrases": phraseResults,
"stage": stage
},
room=username)
@jwt_required
def on_join(self, data):
username = get_jwt_identity()
userId = str(self.db.nameToId(username))
self.connections.append(username)
print("user {} has joined".format(userId))
join_room(username)
self.send_ini(userId, username)
def send_ini(self, userId, username):
phrases = self.db.getPhrases(username)
stage = self.db.getL1Stage(userId)
phraseResults = list()
if phrases is None:
return None
for item in phrases:
item["prettyTime"] = datetime.fromtimestamp(
item["timestamp"]).strftime("%a, %b %-d %-I:%-M %p")
phraseResults.append(item)
self.socketio.emit("my_response", {
"phrases": phraseResults,
"stage": stage
},
room=username)
def env():
# start server
os.environ["KFCHESS_CONFIG"] = os.path.join(os.path.dirname(__file__), "../config.py")
app = create_app()
socketio = SocketIO(app)
def on_join(room):
join_room(room, namespace="/game")
socketio.on_event('join', on_join)
# start polling thread
game_resps_q = "resps:{}".format(uuid.uuid4())
redis_db = redis.StrictRedis() #Todo: take redis from some configs
t = Thread(target=poll_game_cnfs, args=(redis_db, "test_store", game_resps_q, socketio))
t.daemon = True
t.start()
yield Env(app=app, socketio=socketio, q=game_resps_q, db=redis_db)
class NetCore(threading.Thread):
def __init__(self, engine):
super().__init__()
self.__engine = engine
self.__app = Flask(__name__)
self.__sio = SocketIO(self.__app)
def run(self):
self.__app.add_url_rule('/', 'core', self.core)
self.__app.add_url_rule('/<path:path>', 'res', self.res)
self.__sio.on_event('connect', self.on_connect)
self.__sio.on_event('data', self.on_data)
self.__sio.run(self.__app, port=80)
def core(self):
resp = make_response(send_file('../ui/index.html'))
return resp
def res(self, path):
""""""
if os.path.exists('ui/' + path):
resp = make_response(send_file('../ui/' + path))
return resp
print('FILE NOT FOUND: {}'.format('ui/' + path))
return 'PAGE NOT FOUND: {}'.format(path)
def send(self, data):
print('SEND: {}'.format(data))
print(self.__sio.__hash__())
print(threading.current_thread().__hash__())
self.__sio.emit('data', data)
self.__sio.sleep()
def on_connect(self):
""""""
self.__engine.info('Connected from ID: {}'.format(request.sid))
self.__engine.on_connect(request.sid)
resp = make_response()
return resp
def on_data(self, data):
print('RECV: {}'.format(data))
print(self.__sio.__hash__())
print(threading.current_thread().__hash__())
self.send(data)
self.__engine.recv(data)
class Uplink(object):
def __init__(self, app=None, secret="top_secret_1!"):
self.app = app
self.app.config['SECRET_KEY'] = secret
self.sio = SocketIO(self.app)
self.initialized = False
self.sio.on_event('connect', self.update_render, namespace='/')
self.func = None
self.funcs = {}
def update_render(self):
if not self.func:
return
emit('update_content', self.func())
def render(self):
def dec(f):
@wraps(f)
def wrapper(*msg):
self.func = f
if not self.initialized:
self.initialized = True
return html_wrapper
return emit('update_content', f())
return wrapper
return dec
def event(self, channel_id):
def test(burp):
if channel_id not in self.funcs:
print("No func found")
return
self.funcs[channel_id]()
emit('update_content', self.func())
self.sio.on_event(channel_id, test, namespace='/')
def dec(f):
self.funcs[channel_id] = f
return dec
def run(self):
self.sio.run(self.app)
def create_app(name):
app = Flask(
name,
template_folder=settings["TEMPLATE_FOLDER"],
static_folder=settings["STATIC_FOLDER"],
static_url_path=settings["STATIC_URL_PATH"],
)
app.config["DEBUG"] = settings["FLASK_DEBUG"]
app.config["ENV"] = settings["FLASK_ENV"]
app.config["SECRET_KEY"] = settings["SECRET_KEY"]
socketio = SocketIO()
socketio.init_app(app)
socketio.on_event("chat", handle_message)
app = add_routes(app)
socketio = add_socketio_handlers(socketio)
return app, socketio
def create_app(config_name):
f_config = config_dict[config_name]
app = Flask(__name__,
template_folder=f_config.STATIC_FOLDER,
static_url_path='',
static_folder=f_config.STATIC_FOLDER)
app.config.from_object(f_config)
CORS(app, resources={r"*": {"origins": "*"}})
socket = SocketIO(app)
socket.init_app(app, cors_allowed_origins="*")
api = Api(app)
api.add_resource(Main, '/')
socket.on_event('request_start', communicate_with_guider)
socket.on_event('request_stop', disconnect_with_guider)
return app, socket
class MessagingServer(Messager):
def __init__(self):
super().__init__()
self.host, self.port = get_server_host_and_port()
self.app = get_flask_instance()
self.sio = SocketIO(self.app)
self.sio.on_event(EVENT_PUBLIC_KEYS, self.return_pubkeys)
self.sio.on_event(EVENT_AES_KEY, self.unencrypt_and_set_aes_key)
self.sio.on_event(EVENT_MESSAGE, self.print_message)
def unencrypt_and_set_aes_key(self, data):
key = decrypt_message(data, self.a, self.p)
self.aes_secret_key = key
self.set_aes_cipher()
self.set_keys_exchanged()
self.sio.emit(EVENT_KEYS_EXCHANGED)
def return_pubkeys(self, data):
self.set_pubkeys(data)
self.sio.emit(EVENT_PUBLIC_KEYS,
data={
"p": self.p,
"g": self.g,
"b": self.b
})
def start_server(self):
self.sio.run(self.app, host="0.0.0.0", port=self.port)
def start(self):
threading.Thread(target=self.start_server).start()
self.message_loop(self.sio)
def create_app(config_name):
f_config = config_dict[config_name]
app = Flask(__name__,
template_folder=f_config.STATIC_FOLDER,
static_url_path='',
static_folder=f_config.STATIC_FOLDER)
app.config.from_object(f_config)
app.config['MONGODB_SETTINGS'] = config_database
socket = SocketIO(app)
socket.init_app(app, cors_allowed_origins="*")
# TODO: exception handling for mongo-engine
db.init_app(app)
api = Api(app)
api.add_resource(Main, '/', '/<path:path>')
api.add_resource(Slack, '/slack/')
socket.on_event('request_start', communicate_with_guider)
socket.on_event('request_stop', disconnect_with_guider)
return app, socket
def __init__(self, conn_list_instance, deauth_fn, port=8080):
self._conn_list_instance = conn_list_instance
self._deauth_fn = deauth_fn
app = Flask(__name__, static_folder='static', static_url_path=None)
app.config['SECRET_KEY'] = 'secret!'
@app.route("/")
def root():
return app.send_static_file('index.html')
socketio = SocketIO(app)
socketio.on_event("send_connections_list", self._send_connections_list)
socketio.on_event("start_deauth", self._start_deauth)
t = threading.Thread(target=lambda: socketio.run(app, port=port))
t.daemon = True
def start():
t.start()
print "Started server on localhost:%i" % (port)
self.start = start
def generate_socketio(hardware={}):
"""
Sets up a Flask server for DSSServer
start a central server
the additional keyword arguments for DSSServer are
import_path - (str) a path whose corresponding module has a
'station_configuration' function (default None)
config_args - (tuple/list) passed to 'station_configuration'
(default None)
config_kwargs - (dict) passed to 'station_configuration'
(default None)
**kwargs - (dict) keyword arguments for Pyro4Server
"""
logger.debug("generate_socketio: hardware: %s", hardware)
server = DSSServer('WBDC2_K2',
parent=FlaskServer(),
logger=logging.getLogger(__name__ + ".DSSServer"),
config_args={"hardware": hardware},
boresight_manager_file_paths=[],
boresight_manager_kwargs=dict(reload=True,
dump_cache=False))
# initialize a Flask app
app = Flask(server.name)
logger.debug("generate_socketio: Flask initialized")
app.config['SECRET_KEY'] = "radio_astronomy_is_cool"
socketio = SocketIO(app, json=JSONWrapper(), cors_allowed_origins="*")
logger.debug("generate_socketio: SocketIO initialized")
# flaskify the server
app, socketio, server = DSSServer.flaskify_io(server,
app=app,
socketio=socketio)
logger.debug("generate_socketio: server IO flaskified")
def init(data):
logger.debug("generate_socketio.init: got {}".format(data))
def hostname():
logger.debug("generate_socketio.hostname: called")
host = socket.gethostname()
with app.app_context():
socketio.emit("hostname", host)
logger.debug("generate_socketio.hostname: host: {}".format(host))
def teardown():
logger.debug("generate_socketio.teardown: disconnect at %s",
datetime.datetime.now().ctime())
server.save_info()
socketio.on_event("init", init)
socketio.on_event("hostname", hostname)
socketio.on_event("disconnect", teardown)
return app, socketio, server
class NetCore:
def __init__(self):
self.app = Flask(__name__)
self.sio = SocketIO(self.app)
self.address = None
def create_server(self, address=None):
self.address = address
self.app.add_url_rule('/', 'core', self.core)
self.app.add_url_rule('/<path:path>', 'res', self.res)
self.sio.on_event('connect', self.on_connect)
self.sio.on_event('msg', self.on_msg)
self.sio.on_event('test', self.test)
t = threading.Thread(target=self.server_core)
t.run()
def server_core(self):
if self.address:
config = {
'host': self.address[0],
'port': self.address[1],
'debug': False
}
self.sio.run(self.app, **config)
else:
self.sio.run(self.app)
def on_connect(self):
print('Connected!')
print('ID: {}'.format(request.sid))
print('Cookie ID: {}'.format(request.cookies.get('sid')))
self.sio.emit('msg', 'msg')
res = make_response()
res.set_cookie('sid', request.sid)
return res
def on_msg(self, msg):
print(msg)
def core(self):
with open('front/index.html', encoding='utf-8') as f:
return f.read()
def res(self, path):
if os.path.exists('front/' + path):
with open('front/' + path, 'r', encoding='utf-8') as f:
return f.read()
print('FILE NOT FOUND: {}'.format('front/' + path))
return 'PAGE NOT FOUND: {}'.format(path)
def test(self, msg):
print(msg)
def create_app(config_name):
f_config = config_dict[config_name]
app = Flask(__name__,
template_folder=f_config.STATIC_FOLDER,
static_url_path='',
static_folder=f_config.STATIC_FOLDER)
CORS(app,
resources={
r"/dataset/*": {
"origin": "*"
},
r"/devices/*": {
"origin": "*"
},
r"/slack/*": {
"origin": "*"
},
})
app.config.from_object(f_config)
app.config['MONGODB_SETTINGS'] = config_database
socket = SocketIO(app)
socket.init_app(app, cors_allowed_origins="*")
try:
db.init_app(app)
except Exception as e:
print('Failed to connect MongoDB', e)
api = Api(app)
api.add_resource(Main, '/', '/<path:path>')
api.add_resource(Dataset, '/dataset')
api.add_resource(Devices, '/devices')
api.add_resource(Slack, '/slack/')
socket.on_event('get_dashboard_data', get_dashboard_data)
socket.on_event('get_data_by_command', get_data_by_command)
socket.on_event('stop_command_run', stop_command_run)
socket.on_event('health_check', health_check)
return app, socket
def get_io(
*, check_user_creds_usecase: CheckUserCredentialsUseCase,
add_online_user_usecase: AddOnlineUserUseCase,
remove_online_user_usecase: RemoveOnlineUserUseCase,
publish_online_user_usecase: PublishOnlineUserUseCase
) -> Tuple[Flask, SocketIO]:
api = Flask(__name__)
io = SocketIO(api)
# dependencies
flask_base_sockets = FlaskBaseSockets(
check_user_creds_usecase=check_user_creds_usecase,
add_online_user_usecase=add_online_user_usecase,
remove_online_user_usecase=remove_online_user_usecase,
publish_online_user_usecase=publish_online_user_usecase)
# register (maybe we will do it better later so it doesn't be messy right? :D
io.on_event('connect', flask_base_sockets.on_connect)
io.on_event('disconnect', flask_base_sockets.on_disconnect)
io.on_event('message', FlaskMessageSockets().on_message)
return api, io
class Executer:
def __init__(self, threads):
self.pool = ThreadPoolExecutor(threads)
self.queue = queue.Queue()
self.warehouse = Warehouse(19999)
self.robots = []
self.tasks = []
self.app = Flask("Warehouse")
self.socketio = SocketIO(self.app, pingTimeout=60, pingInterval=60)
self.socketio.on_event("addTask", self.handleAddTask)
self.socketio.on_event("addRobot", self.handleAddRobot)
self.loop = threading.Thread(target=self._dispatcher)
self.freeRobots = threading.Semaphore(value=0)
self.mutex = threading.Lock()
self.app.add_url_rule("/<path:path>",
"sendFile",
self.sendFile,
methods=["GET"])
self.app.add_url_rule("/",
"sendHomePage",
self.sendHomePage,
methods=["GET"])
self.app.add_url_rule("/getTasks", "sendTasksHTTP", self.sendTasksHTTP)
self.app.add_url_rule("/getRobotsPos", "sendRobotsPos",
self.sendRobotsPos)
def handle_message(self, data):
print("received message: " + data)
def handleGetTask(self):
self.socketio.emit("get")
def sendFile(self, path):
return flask.send_from_directory("./", path)
def sendHomePage(self):
return flask.send_file("./html/index.html")
def sendRobotsPos(self):
pos = []
for robot in self.robots:
curPos = robot.getPos()
mappedPos = self.warehouse.warehouse_to_img(curPos[0], curPos[1])
pos.append({
"id": robot.id,
"angle": robot.getAngle(),
"x": mappedPos[0],
"y": mappedPos[1],
})
return jsonify(pos)
def sendTasksHTTP(self):
return jsonify(self.tasks)
def startHTTPServer(self):
self.socketio.run(self.app, host="0.0.0.0")
def stopHTTP(self):
self.finishAll()
status_code = flask.Response(status=201)
return status_code
def handleAddTask(self, data):
data = json.loads(data)
self.addTask(data)
self.socketio.emit("newTask", data)
self.tasks.append(data)
def handleAddRobot(self):
if not request.json or not "robot" in request.json:
abort(400)
self.addRobot(request.json["robot"]["suffix"])
status_code = flask.Response(status=201)
print(request.json)
return status_code
def startListening(self):
self.loop.start()
def _dispatcher(self):
while True:
print("waiting")
points = self.queue.get()
if points == None:
break
print("Preparing to dispatch", points)
self.mutex.acquire()
self.freeRobots.acquire()
print("Dispatching", points)
self.pool.submit(self._assignTask, points)
def addRobot(self, name):
self.robots.append(Robot(self.warehouse.client, name))
self.freeRobots.release()
def addTask(self, stop):
self.queue.put(stop)
def release(self, num):
print("Releasing")
self.robots[num].makeFree()
self.freeRobots.release()
def _assignTask(self, task):
print(type(task))
pickup, drop = (task["pickup"]["x"], task["pickup"]["y"]), (
task["drop"]["x"],
task["drop"]["y"],
)
print(pickup, drop)
for i in range(len(self.robots)):
if not self.robots[i].busy:
print("Angle = ", self.robots[i].getAngle())
self.robots[i].makeBusy(task)
self.mutex.release()
task["robot"] = self.robots[i].id
self.socketio.emit("assignTo", {
"uuid": task["uuid"],
"robot": self.robots[i].id
})
task["status"] = "Computing Path"
self.socketio.emit("updateStatus", {
"uuid": task["uuid"],
"status": "Computing Path"
})
finder = PathFinder(self.warehouse)
_, pos = sim.simxGetObjectPosition(
self.warehouse.client,
self.robots[i].base,
-1,
sim.simx_opmode_blocking,
)
start = self.warehouse.warehouse_to_img(pos[0], pos[1])
pickupPathImg, pickupPath = finder.find(
start, pickup, self.robots[i].getAngle())
print("pick found")
if len(pickupPath) == 0:
print("No")
task["status"] = "No route"
self.socketio.emit("updateStatus", {
"uuid": task["uuid"],
"status": task["status"]
})
self.release(i)
return
dropPathImg, dropPath = finder.find(pickup, drop)
print("drop found")
if len(dropPath) == 0:
print("No")
task["status"] = "No route"
self.socketio.emit("updateStatus", {
"uuid": task["uuid"],
"status": task["status"]
})
self.release(i)
return
task["pickupPath"] = pickupPathImg
task["dropPath"] = dropPathImg
self.socketio.emit(
"path",
{
"uuid": task["uuid"],
"pickup": pickupPathImg,
"drop": dropPathImg,
},
)
task["status"] = "In Transit"
self.socketio.emit("updateStatus", {
"uuid": task["uuid"],
"status": "In Transit"
})
print(task["package"]["id"])
tracker = PathTracker(
pickupPath,
dropPath,
2.8,
5,
self.robots[i],
self.warehouse,
self.socketio,
task["package"]["id"],
)
tracker.track()
curPos = self.robots[i].getPos()
mappedPos = self.warehouse.warehouse_to_img(
curPos[0], curPos[1])
self.robots[i].task["status"] = "Finished"
self.socketio.emit(
"updateStatus",
{
"uuid": self.robots[i].task["uuid"],
"status": "Finished"
},
)
self.socketio.emit(
"updateRobotPos",
{
"id": self.robots[i].id,
"x": mappedPos[0],
"y": mappedPos[1]
},
)
self.release(i)
return
def finishAll(self):
self.queue.put(None)
self.loop.join()
self.mutex.acquire()
self.pool.shutdown()
def create_app() -> Tuple[Flask, SocketIO]:
app = Flask(__name__)
app.register_blueprint(bp)
CORS(app)
socketio = SocketIO(app, cors_allowed_origins="*")
socketio.on_event('join', join_agreement, namespace='/')
socketio.on_event('leave', leave_agreement, namespace='/')
socketio.on_event('change', agreement_change, namespace='/')
socketio.on_event('join_chat', join_chat, namespace='/')
socketio.on_event('leave_chat', leave_chat, namespace='/')
socketio.on_event('send', message_sent, namespace='/')
return app, socketio
def register_handlers(sio: SocketIO):
sio.on_event('self_introduction', on_self_introduction)
sio.on_event('message', on_message)
@socketio.on('other custom event')
def get_request_event(data):
global request_event_data
request_event_data = request.event
emit('my custom response', data)
def get_request_event2(data):
global request_event_data
request_event_data = request.event
emit('my custom response', data)
socketio.on_event('yet another custom event', get_request_event2)
@socketio.on('my custom namespace event', namespace='/test')
def on_custom_event_test(data):
emit('my custom namespace response', data, namespace='/test')
def on_custom_event_test2(data):
emit('my custom namespace response', data, namespace='/test')
socketio.on_event('yet another custom namespace event',
on_custom_event_test2,
namespace='/test')
def register_events(events: List, socketio: SocketIO) -> None:
for event in events:
socketio.on_event(event.get("event"), event.get("func"), event.get("namespace"))
return data
@socketio.on('other custom event')
def get_request_event(data):
global request_event_data
request_event_data = request.event
emit('my custom response', data)
def get_request_event2(data):
global request_event_data
request_event_data = request.event
emit('my custom response', data)
socketio.on_event('yet another custom event', get_request_event2)
@socketio.on('my custom namespace event', namespace='/test')
def on_custom_event_test(data):
emit('my custom namespace response', data, namespace='/test')
def on_custom_event_test2(data):
emit('my custom namespace response', data, namespace='/test')
socketio.on_event('yet another custom namespace event', on_custom_event_test2,
namespace='/test')
@socketio.on('my custom broadcast event')
def handle_my_custom_namespace_event(json):
print("received json: " + str(json))
emit('my response', json)
# Sending multiple arguments
emit('my response', 'foo', namespace='/test')
# Without decorator
def my_function_handler(data):
print("received my function handler: " + str(data))
socketio.on_event(
"my function handler event",
my_function_handler,
namespace='/'
)
# Sending Message
# ===============
# With callback
def ack():
print 'callback message was received'
@socketio.on('my event ack')
def handle_my_event_ack(json):
emit('my response', json, callback=ack)
from flask_mongoengine import MongoEngine
from delhivery.models import DelhiveryUser
from api.utils import get_notifications_for_dashboard
from app.settings import MONGODB_SETTINGS
import app.main_sockets as main_sockets
app = Flask(__name__)
app.secret_key = 'delhiverySECRET'
app.config['TEMPLATES_AUTO_RELOAD'] = True
app.config['MONGODB_SETTINGS'] = MONGODB_SETTINGS
app.config['WTF_CSRF_SECRET_KEY']="SECRETCSRFKEY"
CORS(app)
socketio = SocketIO(manage_session=False)
socketio.init_app(app,message_queue='redis://')
login_manager = LoginManager(app)
db = MongoEngine(app)
socketio.on_event('connect',main_sockets.connect)
socketio.on_event('create_room',main_sockets.create_room)
socketio.on_event('disconnect',main_sockets.disconnect)
socketio.on_event('send_message',main_sockets.send_message)
socketio.on_event('typing',main_sockets.typing_message)
socketio.on_event('no_longer_typing',main_sockets.no_longer_typing)
def notify_user(person_id):
notifications = get_notifications_for_dashboard(person_id)
socketio.emit('received_friend_request',notifications,room=person_id)
def refresh_online_friends(user_id):
socketio.emit('refresh_online_friends',room = user_id)
def refresh_tasks_delivery_agent(room):
socketio.emit('refresh_tasks', room=room)
from flask_mongoengine import MongoEngine
from fakebook.models import FakeBookUser
from api.utils import get_notifications_for_dashboard
from settings import MONGODB_SETTINGS
import main_sockets
app = Flask(__name__)
app.secret_key = 'FAKEBOOKSECRET'
app.config['TEMPLATES_AUTO_RELOAD'] = True
app.config['MONGODB_SETTINGS'] = MONGODB_SETTINGS
app.config['WTF_CSRF_SECRET_KEY']="SECRETCSRFKEY"
CORS(app)
socketio = SocketIO(manage_session=False)
socketio.init_app(app,message_queue='redis://')
login_manager = LoginManager(app)
db = MongoEngine(app)
socketio.on_event('connect',main_sockets.connect)
socketio.on_event('create_room',main_sockets.create_room)
socketio.on_event('disconnect',main_sockets.disconnect)
socketio.on_event('send_message',main_sockets.send_message)
socketio.on_event('typing',main_sockets.typing_message)
socketio.on_event('no_longer_typing',main_sockets.no_longer_typing)
def notify_user(person_id):
notifications = get_notifications_for_dashboard(person_id)
socketio.emit('received_friend_request',notifications,room=person_id)
def update_friends_list_for_receiver(user_id):
socketio.emit('update_people_list',room=user_id)
def refresh_online_friends(user_id):
socketio.emit('refresh_online_friends',room = user_id)
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("other custom event")
@socketio.on("and another custom event")
def get_request_event(data):
global request_event_data
request_event_data = request.event
emit("my custom response", data)
def get_request_event2(data):
global request_event_data
request_event_data = request.event
emit("my custom response", data)
socketio.on_event("yet another custom event", get_request_event2)
@socketio.on("my custom namespace event", namespace="/test")
def on_custom_event_test(data):
emit("my custom namespace response", data, namespace="/test")
def on_custom_event_test2(data):
emit("my custom namespace response", data, namespace="/test")
socketio.on_event("yet another custom namespace event",
on_custom_event_test2,
namespace="/test")
