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())
def insert_in_db(streams, date_fetch):
connect(
'streams',
host=
'mongodb+srv://anderson:[email protected]/test?retryWrites=true&w=majority'
)
for data in streams:
data['channel'].pop('created_at')
data['channel'].pop('updated_at')
data.pop('created_at')
data['date_fetch'] = datetime.strptime(date_fetch, '%d%m%Y%H%M%S')
new_stream = models.Stream(**data)
new_stream.save()
pipeline = [{"$sort": {'date_fetch': -1}}, {"$limit": 1}]
last_result = list(models.Stream.objects.aggregate(*pipeline))[0]
socketio = SocketIO(message_queue='redis://localhost:6379')
socketio.emit(
'most viwed',
models.Stream.objects.filter(date_fetch=last_result['date_fetch']).
order_by('-viewers').limit(50).to_json())
disconnect()
def upload_screenshot():
"""Upload screenshot"""
token = request.args['token']
image = request.files['screenshot']
title = request.form['title']
if not re.match(r'^[\w-]+$', token):
raise Exception("Invalid token format")
screenshot = Screenshot(
id=str(uuid.uuid4()),
image=image.stream.read(),
created_at=datetime.utcnow(),
)
db.session.add(screenshot)
db.session.commit()
socket = SocketIO(message_queue=app.config['REDIS_URL'])
socket.emit('receive screenshot', {
'path': url_for('get_screenshot', id=screenshot.id),
'title': title,
},
room=token,
namespace='/screenshot')
return 'OK', 200
def mutate(self, info, **kwargs):
myGroup = Group.query.get(kwargs.get('id'))
if not myGroup:
raise Exception(_('Group not found'))
currentMenus = []
for menu in myGroup.menus:
currentMenus.append(menu.id)
# add new menu
for menuId in kwargs.get('menus'):
if menuId not in currentMenus:
myMenu = Menu.query.get(menuId)
myGroup.menus.append(myMenu)
# remove old menu which are not include in new menu
for menuId in currentMenus:
if menuId not in kwargs.get('menus'):
myMenu = Menu.query.get(menuId)
if myMenu.name != 'Root':
myGroup.menus.remove(myMenu)
db.session.commit()
# emit event "assign_menu_change"
accessMenus = []
[accessMenus.append({"id": item.id}) for item in myGroup.menus]
socketio = SocketIO(message_queue=current_app.config['REDIS_URI'])
socketio.emit('assign_menu_change', data=(
myGroup.id, accessMenus))
return AssignMenu(assigned=True)
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)
class PServer():
__metaclass__ = Singleton
def __init__(self):
# Flask Elements
self.IO_SPACE = "/io"
# self.test = "[TEST1]"
self.app = Flask(__name__)
self.app.config['DEBUG'] = False
self.app.config['SECRET_KEY'] = "supersecret"
# self.socketio = SocketIO(self.app)
self.socketio = SocketIO(self.app, async_mode='threading')
# LIttle spleeper
def sleep_state(voice):
time.sleep(SLEEP_TIME)
self.send("sleep")
logger.debug("WORKS")
voice.stop_all()
self.is_sleeping = True
def send(self, event, data=""):
lock.acquire(True)
self.socketio.emit(event, data, namespace="/io")
lock.release()
def start(self):
print "[STARTING SERVERS]"
def create_stream(phrase, queue):
"""
Celery task that connects to the twitter stream and runs a loop, periodically
emitting tweet information to all connected clients.
"""
local = SocketIO(message_queue=queue)
stream = Twitter().stream(phrase, timeout=30)
for i in range(60):
stream.update()
for tweet in reversed(stream):
sentiment = classify_tweet(tweet)
x, y = vectorize_tweet(tweet)
local.emit(
'tweet', {
'id': str(i),
'text': str(tweet.text.encode('ascii', 'ignore')),
'sentiment': sentiment,
'x': x,
'y': y
})
stream.clear()
time.sleep(1)
return queue
class FlaskSocketIOUserMessagebus(AbstractUserMessagebus):
def __init__(self, message_queue):
self.socketio = SocketIO(message_queue=message_queue)
def emit(self, event: user_events.UserEvent):
if isinstance(event, user_events.BattleReady):
event_name = 'battle_ready'
data = {'battle_ref': event.battle_ref}
if isinstance(event, user_events.BattleFinished):
event_name = 'battle_finished'
data = {'winner': event.winner}
if isinstance(event, user_events.PokemonUsedMove):
event_name = 'move'
data = {'pokemon': event.pokemon, 'move': event.move}
if isinstance(event, user_events.PokemonChanged):
event_name = 'pokemon_changed'
data = {
'player': event.player,
'pokemon_nickname': event.pokemon_nickname
}
if isinstance(event, user_events.TurnReady):
event_name = 'turn_ready'
data = {'battle_ref': event.battle_ref}
if isinstance(event, user_events.PokemonFainted):
event_name = 'pokemon_fainted'
data = {'pokemon': event.pokemon}
self.socketio.emit(event_name, data, room=event.battle_ref)
def mutate(self, info, **kwargs):
myGroup = Group.query.get(kwargs.get('id'))
if not myGroup:
raise Exception(_('Group not found'))
currentPermissions = []
for perm in myGroup.permissions:
currentPermissions.append(perm.id)
# add new permission
for permId in kwargs.get('permissions'):
if permId not in currentPermissions:
myPerm = Permission.query.get(permId)
myGroup.permissions.append(myPerm)
# remove old permission which are not include in new permission
for permId in currentPermissions:
if permId not in kwargs.get('permissions'):
myPerm = Permission.query.get(permId)
myGroup.permissions.remove(myPerm)
db.session.commit()
# emit event "grant_permission_change"
accessPermissions = []
[accessPermissions.append({"name": item.name})
for item in myGroup.permissions]
socketio = SocketIO(message_queue=current_app.config['REDIS_URI'])
socketio.emit('grant_permission_change', data=(
myGroup.id, accessPermissions))
return GrantPermission(granted=True)
def test_wait(self):
socketIO = SocketIO('localhost', 5000)
socketIO.emit('wait_with_disconnect')
timeout_in_seconds = 5
start_time = time.time()
socketIO.wait(timeout_in_seconds)
self.assertTrue(time.time() - start_time - 1 < timeout_in_seconds)
class Web(Net):
def __init__(self):
super().__init__(MODULE)
self.app = flask.Flask(self.value)
self.route()
self.sio = SocketIO(self.app)
self.socket()
self.inotify()
def route(self):
@self.app.route('/')
def index():
return flask.render_template('index.html', glob=glob, env=glob)
def socket(self):
@self.sio.on('connect')
def connect():
self.sio.emit('localtime', Time().json(), broadcast=True)
def eval(self, env):
self.sio.run(self.app, host=config.HOST, port=config.PORT, debug=True)
## file change watcher/notifier
def inotify(self):
watch = Observer()
sio = self.sio
class event_handler(FileSystemEventHandler):
def on_closed(self, event):
if not event.is_directory:
sio.emit('reload', f'{event}')
watch.schedule(event_handler(), 'static', recursive=True)
watch.schedule(event_handler(), 'templates', recursive=True)
watch.start()
def handle_out_of_roi(data, room):
socketio = SocketIO(app,
cors_allowed_origins="*",
message_queue='redis://')
print('Saving image and send log ...')
t = datetime.now().strftime("%Y/%m/%d %H:%M:%S")
with app.app_context():
# Log to UI
message = '[{}] Object is out of ROI. Saving image...'.format(t)
socketio.emit('log', {'log': message}, room=room)
log = LogText(message=message, time=t, camera_id=room)
db.session.add(log)
# Notification
camera = Camera.query.filter(Camera.id == room).first()
socketio.emit('noti', {
'title': camera.name,
'message': message
},
broadcast=True)
# Save image to DB
send_image = io.BytesIO(
base64.b64decode(re.sub("data:image/jpeg;base64", '', data)))
image_name = random_name_generator() + '.jpg'
firebase_storage.child("images/{}".format(image_name)).put(send_image)
url = firebase_storage.child(
"images/{}".format(image_name)).get_url(None)
image = LogImage(url=url, time=t, camera_id=room)
db.session.add(image)
db.session.commit()
def test_send_msg(self):
socketIO = SocketIO('localhost', 5000)
socketIO.emit('my event', {'message': 'test', "user_name": 'test'})
pkt = packet.Packet()
self.assertEqual(pkt.packet_type, packet.EVENT)
self.assertTrue(socketIO.connected)
def celery_bg_task():
with app.app_context():
socketio = SocketIO(current_app, message_queue='redis://')
print('Background Task Starting ...')
socketio.sleep(10)
socketio.emit('celery_bg_task', {'msg': 'Celery Background Task Done'}, namespace='/test')
print('Background Task Done with Celery')
def background_task(url):
local_socketio = SocketIO(message_queue=url)
local_socketio.emit('my_response', {'data': 'Background test starting...'},
namespace="\test")
time.sleep(10)
local_socketio.emit('my_response', {'data': 'Background test complete...'},
namespace="\test")
def catch_send_notification(socketio: SocketIO):
try:
posix_ipc.unlink_message_queue(config.QUEUE_NAME_UI_NOTIFICATION)
except:
pass
notificationQueue = posix_ipc.MessageQueue(
config.QUEUE_NAME_UI_NOTIFICATION, posix_ipc.O_CREX)
ui_language = config.UI_LANGUAGE
while True:
try:
notification = notificationQueue.receive(timeout=1)
message_name = json.loads(notification[0])["message_name"]
message = ui_languages[message_name][ui_language]
socketio.emit('notification', {
"message_name": message_name,
"message": message
},
namespace='/broadcast',
broadcast=True)
except:
continue
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 PServer():
__metaclass__ = Singleton
def __init__(self):
# Flask Elements
self.IO_SPACE = "/io"
# self.test = "[TEST1]"
self.app = Flask(__name__)
self.app.config['DEBUG'] = False
self.app.config['SECRET_KEY'] = "supersecret";
# self.socketio = SocketIO(self.app)
self.socketio = SocketIO(self.app, async_mode='threading')
# LIttle spleeper
def sleep_state(voice):
time.sleep(SLEEP_TIME)
self.send("sleep")
logger.debug("WORKS")
voice.stop_all()
self.is_sleeping = True
def send(self, event, data=""):
lock.acquire(True)
self.socketio.emit(event, data, namespace="/io")
lock.release()
def start(self):
print "[STARTING SERVERS]"
def test_domains():
"""
Tests domains and emits messages to all clients trough SocketIO
"""
socket_io = SocketIO(message_queue=os.environ.get('CELERY_BROKER'))
socket_io.emit('sites_event', {'results': [v for k, v in test_sites()]},
broadcast=True)
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 socket_emit(meta=None, event='others'):
try:
socketio = SocketIO(message_queue=current_app.config['SOCKETIO_REDIS_URL'])
socketio.emit(event, meta, namespace='/deyunio')
except Exception as e:
logger.warning('error in loading sitestatus ' + str(e))
return {'failed': e}
return {("sent " + str(event)) : meta}
def background_task(url):
local_socketio = SocketIO(message_queue=url)
local_socketio.emit('my response',
{'data': 'background task starting ...'},
namespace='/test')
time.sleep(10)
local_socketio.emit('my response', {'data': 'background task complete!'},
namespace='/test')
def process_download(download):
# Don't actually care about doing any real work here, but look like we are...
time.sleep(random.randint(5, 10))
socketio = SocketIO(message_queue=current_app.config['REDIS_URL'])
socketio.emit('download ready', {'id': download.id, 'url': download.url})
return True
def basicbot2(review_id=None, sess_id=None):
"""
use document similarity to recommend trials for a review based on similarity to current included trials
@param review_id: PMID of review
@param sess_id: session ID if transitting progress via websocket
"""
if sess_id:
socketio = SocketIO(message_queue='amqp://localhost')
conn = dblib.create_con(VERBOSE=True)
cur = conn.cursor()
cur.execute(
"SELECT nct_id FROM review_rtrial WHERE relationship = 'included' AND review_id = %s;",
(review_id, ))
trials = cur.fetchall()
if len(trials) < 1:
print('no trials for basicbot2')
conn.close()
return False
if trials:
cur.execute(
"delete from votes where link_id in (select id from review_rtrial where review_id = %s) and user_id = %s;",
(review_id, 10))
conn.commit()
cur.execute(
"delete from review_rtrial where upvotes = 0 and downvotes = 0 and user_id = 10;"
)
conn.commit()
conn.close()
if sess_id:
socketio.emit('basicbot2_update', {'msg': 'triggering basicbot2'},
room=sess_id)
tfidf_matrix = utils.most_recent_tfidf()
ids = np.load(utils.most_recent_tfidf_labels())
trials = list(list(zip(*trials))[0])
ix = np.isin(ids, trials)
trial_indices = np.where(ix)[0]
if sess_id:
socketio.emit('basicbot2_update', {'msg': 'vectorizing stuff'},
room=sess_id)
trial_vecs = tfidf_matrix[trial_indices, :]
cos_sim = linear_kernel(trial_vecs, tfidf_matrix)
if sess_id:
socketio.emit('basicbot2_update',
{'msg': 'calculating cosine similarity'},
room=sess_id)
final = cos_sim.sum(axis=0)
top = np.argpartition(final, -100)[-100:]
top_ranked = set(ids[np.array(top)]) - set(ids[trial_indices])
if sess_id:
socketio.emit('basicbot2_update',
{'msg': 'inserting basicbot 2 predictions'},
room=sess_id)
for nct_id in top_ranked:
crud.review_trial(review_id, nct_id, False, 'relevant',
'basicbot2', 10)
if sess_id:
socketio.emit('basicbot2_update', {'msg': 'basicbot2 complete!'},
room=sess_id)
def message_to_client(name, room):
socketio = SocketIO(message_queue='amqp://')
count = 5
while count > 1:
count -= 1
socketio.emit('response', {'count': count},
namespace='/test',
room=room)
time.sleep(1)
socketio.emit('response', {'name': name}, namespace='/test', room=room)
class RestaurantDayQueue(Queue):
def __init__(self,room):
self.room = room
self.socketio = SocketIO(message_queue=REDIS_URL)
super().__init__()
def put(self, report, block=True, timeout=None):
self.socketio.emit('day_report', report.get_report(),room=self.room)
#print(report.get_report())
super().put(report, block, timeout)
self.socketio.sleep(0)
def update_plot():
socketio = SocketIO(message_queue='redis://localhost:6379/')
while True:
datetime_now = datetime.now().strftime(DATE_FMT)
cpu_percent_second = cpu_percent(interval=1)
socketio.emit('update', {
'x': [datetime_now],
'y': [cpu_percent_second]
})
time.sleep(1)
def simulate(restaurant,sid):
simsocket = SocketIO(message_queue=REDIS_URL)
layout = json.loads(restaurant)
print("making rdq here")
rdq = RestaurantDayQueue(sid)
print("rdq has been made")
r = Restaurant("Sophie's Kitchen", layout["equipment"], layout["tables"], layout["staff"], day_log=rdq, verbose=False)
r.simulate(days=int(layout["days"]))
report = r.ledger.generate_final_report()
simsocket.emit("sim_report", report, room=sid)
def web_socket_publisher(web_socket: SocketIO) -> None:
"""Send messages from queue via web-socket to GUI."""
queue = MessageQueue()
while True:
message = queue.get()
web_socket.emit(
message.subject,
{"status": message.status, "data": message.data},
broadcast=True,
)
class Webserver:
def __init__(self):
self.state = {}
self.somethingtoemit = True
self.lastemit = 0
app = Flask(__name__, static_folder='../build', static_url_path='')
app.config['PROPAGATE_EXCEPTIONS'] = True
self.socketio = SocketIO(app, cors_allowed_origins="*")
app.add_url_rule('/', 'root', self.root)
app.add_url_rule('/state', 'get_state', self.get_state, methods=['GET'])
app.add_url_rule('/state', 'post_state', self.post_state, methods=['POST'])
thread = threading.Thread(target=self.emit_state_thread)
thread.daemon = True
thread.start()
logging.info("Starting server on port 1097")
self.socketio.run(app, host="0.0.0.0", port=1097)
def root(self):
return current_app.send_static_file('index.html')
def post_state(self):
update(self.state, request.json)
self.somethingtoemit = True
return Response(status=200)
def get_state(self):
return Response(response=self.to_json(), status=200, mimetype='application/json')
def to_json(self):
return jsonpickle.encode(self.state, unpicklable=False, warn=True)
def emit_state_thread(self):
while 1:
time.sleep(0.1)
if self.socketio is None:
continue
timesincelastemit = time.time() - self.lastemit
if timesincelastemit < 0.3:
# Never emit state if last emitted state was less then 0.3 s ago
continue
if timesincelastemit > 1 or self.somethingtoemit:
# Always emit if last emit was more then 1 second ago
self.emit_state()
def emit_state(self):
self.socketio.emit('state', self.to_json(), broadcast=True)
self.lastemit = time.time()
self.somethingtoemit = False
class SocketsHandler(logging.Handler):
def emit(self, record):
if not hasattr(self, 'socketio'):
self.socketio = SocketIO(message_queue='redis://localhost:6379')
try:
# format: 'CHAN:DATA'
chan, datastr = record.getMessage().split(':', 1)
self.socketio.emit(chan, json.loads(datastr), namespace='/simulation')
except (KeyboardInterrupt, SystemExit):
raise
except:
self.handleError(record)
def when_will_result(l_text, l_min_length, l_max_length, l_temperature,
l_top_p, l_top_k, l_repetition_penalty):
socketio = SocketIO(message_queue='amqp://')
condition = True
while condition:
for val in range(101):
time.sleep(0.05)
socketio.emit('progress_update', {'ratio': val})
condition = False
socketio.emit('progress_update', {'data_text': exampleresult()})
return ('when_will_result() -> ok; update_complete;')
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 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 self_test(x=16, y=16,url=None):
x = int(x)
y = int(y)
res = x + y
context = {"id": "test", "x": x, "y": y}
result = "add((x){}, (y){})".format(context['x'], context['y'])
goto = "{}".format(context['id'])
time.sleep(10)
meta = json.dumps({'result':result, 'goto':goto})
#post(url, json=meta)
socketio = SocketIO(message_queue='redis://localhost:6379/0')
socketio.emit('connect', meta, namespace='/deyunio')
return meta
def test_tally_celery(self):
print('IN CELERY BACKGROUND TASK')
sio = SocketIO(logger=True, engineio_logger=True, message_queue='redis://:TCPYkerxvKQu@redis:6379/0', async_mode='threading')
#from app.app import socketio as sio
message = None
self.update_state(state='PROGRESS',
meta={'current': 'working'})
#sio.emit('local_request',{'data': message }, namespace='/test_local', broadcast=True)
#sio.sleep(1)
sio.emit('web_response2', {'data': 'SENT MESSAGE FROM CELERY TASK - BPTEST2'}, broadcast=True, namespace='/test_web2')
sio.sleep(1)
print('TRIED EMIT FROM CELERY BPTEST2')
return('tried to print')
def start_scan(ScanParameter,sid):#scan should be forked by self,emit be handed over to celery
print('ws start_scan')
print(ScanParameter)
print(sid)
print(request.sid)#should be same
socketio = SocketIO(message_queue='amqp://')
socketio.emit('array', [1,2,'hello',3], room=request.sid)
# multiprocessing.Process #first use thread test ,easy for debug
scan_async = multiprocessing.Process(
target=StockModal.Scanner.Scaner_main,
kwargs={'ScanParameter': ScanParameter,
'sid': request.sid
}
)
# scan_async.setDaemon(True)
scan_async.daemon=True
scan_async.start()
class CombatLogs:
def __init__(self):
with open("config/config.yml", 'r') as ymlfile:
cfg = yaml.load(ymlfile, Loader=yaml.Loader)
self.enabledScroll = True
self.verboseEvent = True
self.scrollSpeed = 0.4
self.print_newline = True
self.logLevel = 1
self.logger = Logger()
redis_str = 'redis://' + cfg['redis']['host'] + ':' + str(cfg['redis']['port']) + '/0'
self.socketio = SocketIO(message_queue=redis_str)
def set_logger(self, logger: Logger):
self.logger = logger
def scroll(self, winner, loser, damage, gain, room=None):
if not self.enabledScroll:
return
event = {'winner': {'name': winner.name, 'hit_points': winner.hitPoints, 'skill_points': winner.fightSkill,
'skill': winner.skill},
'loser': {'name': loser.name, 'hit_points': loser.hitPoints, 'skill_points': loser.fightSkill,
'skill': loser.skill},
'damage': damage, 'gain': gain}
self.publish_event(json.dumps(event), 0, 'fight scroll', '/fight', room)
time.sleep(self.scrollSpeed)
def log_event(self, key, text, level):
if level < self.logLevel:
self.logger.write(key, text)
def print_event(self, text, level):
if level < self.logLevel:
print(text, end="", flush=True)
if self.print_newline:
print("\n", end="")
def publish_event(self, text, level, stream='stream', namespace='', room=None):
if level < self.logLevel:
if not room:
self.socketio.emit(stream, {'data': text}, namespace=namespace, broadcast=True)
else:
if type(room) is dict:
for key, value in room.items():
if value is not None:
self.socketio.emit(stream, {'data': text}, namespace=namespace, room=value)
else:
self.socketio.emit(stream, {'data': text}, namespace=namespace, room=room)
def run():
socketio = SocketIO(message_queue='redis://')
testnet = BitShares(node="wss://node.testnet.bitshares.eu")
chain = Blockchain(mode="head", bitshares_instance=testnet)
print(chain.bitshares.rpc.url, flush=True)
for block in chain.blocks():
timestamp = int(datetime.strptime(block["timestamp"], '%Y-%m-%dT%H:%M:%S').timestamp())
num_ops = sum([len(tx["operations"]) for tx in block["transactions"]])
num_txs = len(block["transactions"])
TestBlock(timestamp, block.get("block_num", None), num_txs, num_ops)
notice = {
"block": block.get("block_num", 0),
"timestamp": timestamp,
"num_transactions": num_txs,
"num_operations": num_ops,
}
print(notice, flush=True)
socketio.emit(
'notice',
notice,
namespace=namespace,
room=room,
broadcast=True)
class AlarmPiServer(object):
"""Initialize the AlarmPI Server by defying the files to use,
the RESTful Services and calling the class (Worker)"""
def __init__(self):
""" Initialize the global variables for AlarmPIServer """
self.wd = os.path.dirname(os.path.realpath(__file__))
self.certkeyfile = os.path.join(self.wd, 'my.cert.key')
self.certcrtfile = os.path.join(self.wd, 'my.cert.crt')
self.webDirectory = os.path.join(self.wd, 'web')
self.sipcallfile = os.path.join(
os.path.join(self.wd, "voip"), "sipcall")
def setServerConfig(self, jsonfile):
""" Set the server file to use and initialize the users """
self.serverfile = os.path.join(self.wd, jsonfile)
with open(self.serverfile) as data_file:
self.serverJson = json.load(data_file)
self.users = deepcopy(self.serverJson['users'])
def create_app(self):
""" Define the RESTfull Services and call the
accordingly method in the Worker class """
# some_queue = None
self.app = Flask(__name__, static_url_path='')
self.app.secret_key = 'super secret string'
self.login_manager = flask_login.LoginManager()
self.login_manager.init_app(self.app)
self.socketio = SocketIO(self.app)
@self.login_manager.user_loader
def user_loader(email):
if email not in self.users:
return
user = User()
user.id = email
return user
@self.login_manager.request_loader
def request_loader(request):
username = None
password = None
if len(request.form) > 0:
username = request.form.get('email')
password = request.form.get('pw')
elif request.authorization:
username = request.authorization['username']
password = request.authorization['password']
if username not in self.users:
return
user = User()
user.id = username
if password == self.users[username]['pw']:
flask_login.login_user(user)
return user
@self.app.route('/login', methods=['GET', 'POST'])
def login():
if flask_login.current_user.is_authenticated:
return redirect('/')
if request.method == 'GET':
return send_from_directory(self.webDirectory, 'login.html')
request_loader(request)
return redirect('/')
@self.app.route('/logout')
def logout():
flask_login.logout_user()
return redirect('/login')
@self.login_manager.unauthorized_handler
def unauthorized_handler():
return redirect('/login')
return Response(
'Could not verify your access level for that URL.', 401,
{'WWWAuthenticate': 'Basic realm="Login Required"'}
)
# **********************************
# # Start/Stop Application
# def shutdownServer():
# func = request.environ.get('werkzeug.server.shutdown')
# if func is None:
# raise RuntimeError('Not running with the Werkzeug Server')
# func()
# @self.app.route('/restart')
# @flask_login.login_required
# def restart():
# try:
# some_queue.put("something")
# print("Restarted successfully")
# return "Quit"
# except Exception:
# print("Failed in restart")
# return "Failed"
# Get the required files for the UI
@self.app.route('/')
@flask_login.login_required
def index():
return send_from_directory(self.webDirectory, 'index.html')
@self.app.route('/main.css')
@flask_login.login_required
def main():
return send_from_directory(self.webDirectory, 'main.css')
@self.app.route('/icon.png')
@flask_login.login_required
def icon():
return send_from_directory(self.webDirectory, 'icon.png')
@self.app.route('/mycss.css')
@flask_login.login_required
def mycss():
return send_from_directory(self.webDirectory, 'mycss.css')
@self.app.route('/mycssMobile.css')
@flask_login.login_required
def mycssMobile():
return send_from_directory(self.webDirectory, 'mycssMobile.css')
@self.app.route('/myjs.js')
@flask_login.login_required
def myjs():
return send_from_directory(self.webDirectory, 'myjs.js')
@self.app.route('/jquery.js')
@flask_login.login_required
def jqueryfile():
return send_from_directory(self.webDirectory, 'jquery.js')
@self.app.route('/socket.io.js')
@flask_login.login_required
def socketiofile():
return send_from_directory(self.webDirectory, 'socket.io.js')
@self.app.route('/play_alert.mp3')
@flask_login.login_required
def play_alert():
return send_from_directory(self.webDirectory, 'play_alert.mp3')
@self.app.route('/getSensors.json')
@flask_login.login_required
def getSensors():
user = flask_login.current_user.id
sensorClass = self.users[user]['obj']
return json.dumps(sensorClass.getSensorsArmed())
@self.app.route('/getAlarmStatus.json')
@flask_login.login_required
def getAlarmStatus():
user = flask_login.current_user.id
sensorClass = self.users[user]['obj']
return json.dumps(sensorClass.getTriggeredStatus())
@self.app.route('/getSensorsLog.json', methods=['Get', 'POST'])
@flask_login.login_required
def getSensorsLog():
user = flask_login.current_user.id
sensorClass = self.users[user]['obj']
if request.args.get('saveLimit') == 'True':
sensorClass.setLogFilters(
request.args.get('limit'),
request.args.get('type'))
returnedLogs = sensorClass.getSensorsLog(
limit=request.args.get('limit'),
fromText=request.args.get('fromText'),
selectTypes=request.args.get('type'),
filterText=request.args.get('filterText'),
getFormat=request.args.get('format'),
combineSensors=request.args.get('combineSensors')
)
return json.dumps(returnedLogs)
@self.app.route('/getSereneSettings.json')
@flask_login.login_required
def getSereneSettings():
user = flask_login.current_user.id
sensorClass = self.users[user]['obj']
return json.dumps(sensorClass.getSereneSettings())
@self.app.route('/getAllSettings.json')
@flask_login.login_required
def getAllSettings():
user = flask_login.current_user.id
sensorClass = self.users[user]['obj']
uisettings = {
'username': user,
'password': self.serverJson['users'][user]['pw'],
'timezone': sensorClass.getTimezoneSettings(),
'https': self.serverJson['ui']['https'],
'port': self.serverJson['ui']['port']
}
return json.dumps({
"mail": sensorClass.getMailSettings(),
"voip": sensorClass.getVoipSettings(),
"ui": uisettings,
"mqtt": sensorClass.getMQTTSettings()
})
@self.app.route('/activateAlarmOnline')
@flask_login.login_required
def activateAlarmOnline():
user = flask_login.current_user.id
sensorClass = self.users[user]['obj']
sensorClass.activateAlarm()
self.socketio.emit('settingsChanged',
sensorClass.getSensorsArmed(), room=user)
return json.dumps("done")
@self.app.route('/activateAlarmZone', methods=['GET', 'POST'])
@flask_login.login_required
def activateAlarmZone():
zones = request.args.get('zones').lower().split(',')
user = flask_login.current_user.id
sensorClass = self.users[user]['obj']
sensorClass.setSensorsZone(zones)
sensorClass.activateAlarm()
self.socketio.emit('settingsChanged',
sensorClass.getSensorsArmed(), room=user)
return json.dumps("done")
@self.app.route('/deactivateAlarmOnline')
@flask_login.login_required
def deactivateAlarmOnline():
user = flask_login.current_user.id
sensorClass = self.users[user]['obj']
sensorClass.deactivateAlarm()
self.socketio.emit('settingsChanged',
sensorClass.getSensorsArmed(), room=user)
return json.dumps("done")
@self.app.route('/setSensorStateOnline', methods=['GET', 'POST'])
@flask_login.login_required
def setSensorStateOnline():
message = {
"sensor": request.args.get('sensor'),
"enabled": strtobool(request.args.get('enabled').lower())
}
message['enabled'] = True if message['enabled'] else False
# print(message)
user = flask_login.current_user.id
sensorClass = self.users[user]['obj']
sensorClass.setSensorState(message['sensor'], message['enabled'])
self.socketio.emit('settingsChanged',
sensorClass.getSensorsArmed(), room=user)
return json.dumps("done")
@self.socketio.on('setSensorState')
@flask_login.login_required
def setSensorState(message):
user = flask_login.current_user.id
sensorClass = self.users[user]['obj']
sensorClass.setSensorState(message['sensor'], message['enabled'])
self.socketio.emit('settingsChanged',
sensorClass.getSensorsArmed(), room=user)
@self.socketio.on('activateAlarm')
@flask_login.login_required
def activateAlarm():
user = flask_login.current_user.id
sensorClass = self.users[user]['obj']
sensorClass.activateAlarm()
self.socketio.emit('settingsChanged',
sensorClass.getSensorsArmed(), room=user)
@self.socketio.on('deactivateAlarm')
@flask_login.login_required
def deactivateAlarm():
user = flask_login.current_user.id
sensorClass = self.users[user]['obj']
self.users[user]['obj'].deactivateAlarm()
self.socketio.emit('settingsChanged',
sensorClass.getSensorsArmed(), room=user)
# @self.socketio.on('addSensor')
# @flask_login.login_required
# def addSensor(message):
# user = flask_login.current_user.id
# sensorClass = self.users[user]['obj']
# sensorClass.addSensor(message)
# self.socketio.emit('sensorsChanged', room=user)
@self.app.route('/addSensor', methods=['GET', 'POST'])
@flask_login.login_required
def addSensor():
message = request.get_json()
user = flask_login.current_user.id
sensorClass = self.users[user]['obj']
sensorClass.addSensor(message)
self.socketio.emit('sensorsChanged', room=user)
return json.dumps("done")
@self.socketio.on('delSensor')
@flask_login.login_required
def delSensor(message):
user = flask_login.current_user.id
sensorClass = self.users[user]['obj']
sensorClass.delSensor(str(message['sensor']))
self.socketio.emit('sensorsChanged', room=user)
@self.socketio.on('setSereneSettings')
@flask_login.login_required
def setSereneSettings(message):
user = flask_login.current_user.id
sensorClass = self.users[user]['obj']
sensorClass.setSereneSettings(message)
self.socketio.emit('settingsChanged',
sensorClass.getSensorsArmed(), room=user)
@self.socketio.on('setMailSettings')
@flask_login.login_required
def setMailSettings(message):
user = flask_login.current_user.id
sensorClass = self.users[user]['obj']
sensorClass.setMailSettings(message)
self.socketio.emit('settingsChanged',
sensorClass.getSensorsArmed(), room=user)
@self.socketio.on('setVoipSettings')
@flask_login.login_required
def setVoipSettings(message):
user = flask_login.current_user.id
sensorClass = self.users[user]['obj']
sensorClass.setVoipSettings(message)
self.socketio.emit('settingsChanged',
sensorClass.getSensorsArmed(), room=user)
@self.socketio.on('setUISettings')
@flask_login.login_required
def setUISettings(message):
user = flask_login.current_user.id
sensorClass = self.users[user]['obj']
sensorClass.setTimezoneSettings(message['timezone'])
self.serverJson['users'][user]['pw'] = message['password']
self.serverJson['ui']['port'] = message['port']
self.serverJson['ui']['https'] = message['https']
with open(self.serverfile, 'w') as outfile:
json.dump(self.serverJson, outfile, sort_keys=True,
indent=4, separators=(',', ': '))
print("You might want to restart...")
self.socketio.emit('settingsChanged',
sensorClass.getSensorsArmed(), room=user)
@self.socketio.on('setMQTTSettings')
@flask_login.login_required
def setMQTTSettings(message):
user = flask_login.current_user.id
sensorClass = self.users[user]['obj']
sensorClass.setMQTTSettings(message)
self.socketio.emit('settingsChanged',
sensorClass.getSensorsArmed(), room=user)
@self.socketio.on('join')
@flask_login.login_required
def on_join(data):
# print('joining room:', flask_login.current_user.id)
join_room(flask_login.current_user.id)
return self.app
def startMyApp(self):
""" Call the Worker class for each user """
mysocket = self.socketio
for user, properties in self.users.items():
jsonfile = os.path.join(self.wd, properties['settings'])
logfile = os.path.join(self.wd, properties['logfile'])
optsUpdateUI = {'obj': mysocket.emit, 'room': user}
self.users[user]['obj'] = Worker(
jsonfile,
logfile,
self.sipcallfile,
optsUpdateUI
)
def startServer(self):
""" Start the Flask App """
if self.serverJson['ui']['https'] is True:
try:
self.socketio.run(self.app, host="0.0.0.0",
port=self.serverJson['ui']['port'],
certfile=self.certcrtfile,
keyfile=self.certkeyfile)
except Exception:
context = (self.certcrtfile, self.certkeyfile)
self.socketio.run(self.app, host="0.0.0.0",
port=self.serverJson['ui']['port'],
ssl_context=context)
else:
self.socketio.run(self.app, host="0.0.0.0",
port=self.serverJson['ui']['port'])
class WebApp:
def __init__(self):
print("Started webledbut")
self.thread = None
#to disable RuntimeWarning: This channel is already in use
GPIO.setwarnings(False)
GPIO.setmode(GPIO.BCM)
GPIO.setup(23, GPIO.OUT)
GPIO.output(23, GPIO.LOW)
GPIO.setup(18, GPIO.IN, pull_up_down=GPIO.PUD_UP)
app = Flask(__name__)
Bootstrap(app)
app.config['DEBUG'] = False
self.socketio = SocketIO(app, async_mode='eventlet')
self.counter = 0
print('Begin thread')
if self.thread is None:
print('create thread')
thread = Thread(target=self.background_thread)
thread.daemon = True
thread.start()
@app.before_first_request
def initialize():
print('Called only once, when the first request comes in')
@app.route('/')
def index():
print("render index.html")
return render_template("index.html", board="Raspberry Pi")
@self.socketio.on('connect', namespace='/test')
def test_connect():
self.counter += 1
print("Counter= {0}".format(self.counter))
print('Client connected')
@self.socketio.on('disconnect', namespace='/test')
def test_disconnect():
self.counter -= 1
print("Counter= {0}".format(self.counter))
print('Client disconnected')
@self.socketio.on('getVersion', namespace='/test')
def getversion():
print('version')
@self.socketio.on('ledRCtrl', namespace='/test')
def ledrctrl(message):
print(message['led'])
GPIO.output(23, GPIO.HIGH if message['led'] else GPIO.LOW)
self.socketio.run(app, host='0.0.0.0', port=5001)
def background_thread(self):
state = True
while True:
newstate = False if GPIO.input(18) else True
if state != newstate:
state = newstate
print('Button', state)
self.socketio.emit('but', {'state': state}, namespace='/test')
time.sleep(.1)
class WebApp():
def __init__(self):
print("Started WebApp")
#to disable RuntimeWarning: This channel is already in use
GPIO.setwarnings(False)
GPIO.setmode(GPIO.BCM)
# para usar o LED da placa (GPIO 47), fazer:
# sudo sh -c "echo gpio >/sys/class/leds/led0/trigger"
# para repor o comportamento habitual, fazer
# sudo sh -c "echo mmc0 >/sys/class/leds/led0/trigger"
GPIO.setup(23, GPIO.OUT)
GPIO.output(23, GPIO.LOW)
GPIO.setup(18, GPIO.IN, pull_up_down=GPIO.PUD_UP)
GPIO.add_event_detect(18, GPIO.BOTH, callback=self.onButton)
app = Flask(__name__)
Bootstrap(app)
app.config['DEBUG'] = False
self.socketio = SocketIO(app)
self.counter = -1
@app.before_first_request
def initialize():
print('Called only once, when the first request comes in')
@app.route('/')
def index():
print("render index.html")
return render_template("index2.html", board = "Raspberry Pi")
@self.socketio.on('connect', namespace='/test')
def test_connect():
self.counter += 1
print("Counter= {0}".format(self.counter))
print('Client connected')
@self.socketio.on('disconnect', namespace='/test')
def test_disconnect():
self.counter -= 1
print("Counter= {0}".format(self.counter))
print('Client disconnected')
@self.socketio.on('getVersion', namespace='/test')
def getVersion():
print('version')
@self.socketio.on('ledRCtrl', namespace='/test')
def ledRCtrl(message):
print(message['led'])
GPIO.output(23, GPIO.HIGH if message['led'] else GPIO.LOW)
if GPIO.input(18):
print('Input was HIGH')
else:
print('Input was LOW')
self.socketio.run(app, host = '0.0.0.0', port = 5001)
def onButton(self, channel):
state = False if GPIO.input(18) else True
print(state)
self.socketio.emit('but', {'state': state}, namespace='/test')
from flask_socketio import SocketIO
#sio = SocketIO(message_queue="redis://")
sio = SocketIO(message_queue="amqp://")
from socketIO_client import SocketIO
def on_chat_response(*args):
print 'on_chat_response', args
print "Getting sio"
socketIO = SocketIO('localhost', 80)
print "Got sio", socketIO
socketIO.on('chat', on_chat_response)
socketIO.emit('chat', "hello")
socketIO.wait(seconds=3)
def send_random(msg):
print "sending random for %s" % msg
io.send(msg + " " + str(random.random()))
if __name__ == "__main__":
spam_socket = threading.Timer(10, send_random)
# spam_socket.start()
bridge = BridgeNode(lc)
io.run(bridge_app, debug=True)
print "hello"
bridge = BridgeNode(lc)
thread.sleep(5)
print "random stuff"
io.emit("message", str(random.random()))
# class WSHandler(tornado.websocket.WebSocketHandler):
# def open(self):
# """
# Called when a client opens the websocket
# """
# self.lc = lcm.LCM(LCM_URI)
# self.thread = threading.Thread(target=self.lcm_loop)
# self.thread.daemon = True
# self.thread.start()
# self.subscriptions = {}
# def close(self):
# """
#!/usr/bin/env python
# coding:utf-8
# Copyright (C) dirlt
import logging
import time
from flask_socketio import SocketIO
DEFAULT_LOGGING_FORMAT = '[%(asctime)s][%(levelname)s]%(pathname)s@%(lineno)d: %(msg)s'
logging.basicConfig(level=logging.INFO, format=DEFAULT_LOGGING_FORMAT)
logger = logging.getLogger('trigger')
socketio = SocketIO(message_queue='redis://localhost/0', channel='socketio-test')
ns_name = '/fanout'
ts = int(time.time() * 1000)
socketio.emit('my event', ts, namespace=ns_name)
socketio.emit('my event', ts, namespace=ns_name)
socketio.emit('my event', ts, namespace=ns_name)
socketio.emit('my event', 'quit', namespace=ns_name)
class WebLog():
def __init__(self):
print("Started Logger WebGUI")
signal.signal(signal.SIGINT, self.signal_handler)
app = Flask(__name__)
Bootstrap(app)
app.config['DEBUG'] = False
self.socketio = SocketIO(app)
self.counter = -1
self.nSamples = 0
self.bLogging = False
self.filename = ""
self.board = boards.Duino()
self.board.connect('/dev/ttyS0')
#=======================================================================
# @app.before_first_request
# def initialize():
# print('Called only once, when the first request comes in')
#=======================================================================
@app.route('/')
def index():
print("render index.html")
return render_template("index.html")
@self.socketio.on('connect', namespace='/test')
def test_connect():
print('Client connected')
self.socketio.emit('msg', {'filename': self.filename, 'samples': self.nSamples}, namespace='/test')
@app.route('/', defaults={'req_path': ''})
@app.route('/<path:req_path>')
def dir_listing(req_path):
BASE_DIR = '/home/pi/logger/static'
# Joining the base and the requested path
abs_path = os.path.join(BASE_DIR, req_path)
# Return 404 if path doesn't exist
if not os.path.exists(abs_path):
return abort(404)
# Check if path is a file and serve
if os.path.isfile(abs_path):
return send_file(abs_path)
# Show directory contents
files = os.listdir(abs_path)
files.sort()
filex = []
for file in files:
(mode, ino, dev, nlink, uid, gid, size, atime, mtime, ctime) = os.stat(abs_path + "/" + file)
dat = datetime.datetime.fromtimestamp(ctime)
if file <> "num.dat":
filex.append([file, "{}".format(dat)])
return render_template('files.html', files=filex)
@self.socketio.on('Shutdown', namespace='/test')
def shutdown(message):
print("Shutting down...")
os.system("sudo shutdown -h now")
self.exit()
@self.socketio.on('Logging', namespace='/test')
def logging(message):
if message['state']:
self.startLog()
else:
self.stopLog()
@self.socketio.on('Time', namespace='/test')
def setTime(message):
ms = message['millis']
dat = datetime.datetime.fromtimestamp(ms/1000.0)
os.system("sudo date --set '{}'".format(dat))
self.socketio.run(app, host = '0.0.0.0', port = 5001)
def signal_handler(self, signal, frame):
print("\rYou pressed Ctrl+C!")
self.exit()
def exit(self):
sys.exit(0)
def onMsg(self, msg):
if self.bLogging:
try:
self.file.write(msg + '\r')
self.nSamples = self.nSamples + 1
if self.nSamples % 1000 == 0:
print(self.nSamples)
self.file.flush()
self.socketio.emit('msg', {'samples': self.nSamples}, namespace='/test')
except Exception, e:
print("Error: {}".format(e))
Compress(flaskApplication)
login_manager.init_app(flaskApplication)
login_manager.session_protection = "strong"
# login_manager.anonymous_user = Anonymous
# formatter = logging.Formatter("[%(asctime)s] {%(pathname)s:%(lineno)d} %(levelname)s - %(message)s")
# handler = logging.handlers.RotatingFileHandler('access.log', maxBytes = 100000, backupCount = 3)
# handler.setLevel(logging.INFO)
# handler.setFormatter(formatter)
# flaskApplication.logger.addHandler(handler)
# flaskApplication.logger.warning('A warning occurred (%d apples)', 42)
# flaskApplication.logger.error('An error occurred')
# flaskApplication.logger.info('Info')
print(colorama.Fore.GREEN + "----------- Start Flask -----------" + colorama.Style.RESET_ALL)
socketio.run(flaskApplication, host = os.getenv('IP', "0.0.0.0"), port = int(os.getenv('PORT', flaskApplication.config['PORT'])), debug = flaskApplication.debug)
# flaskApplication.run(host = os.getenv('IP', "0.0.0.0"), port = int(os.getenv('PORT', flaskApplication.config['PORT'])), threaded = True) #processes=1~9999
socketio.emit("bye", broadcast = True)
print(colorama.Fore.RED + "----------- Stop Flask -----------" + colorama.Style.RESET_ALL)
if not os.environ.get('WERKZEUG_RUN_MAIN'):
if (os.name == "nt"):
os.system("taskkill /f /im nginx.exe")
nginxRunning = b'nginx' in subprocess.Popen(
'tasklist',
stdout = subprocess.PIPE
).communicate()[0]
if (not nginxRunning):
print(colorama.Fore.RED + "Stop nginx service!!" + colorama.Style.RESET_ALL)
else:
print(colorama.Fore.YELLOW + "Nginx is still running!!" + colorama.Style.RESET_ALL)
elif (os.name == "posix"):
os.system("sudo /etc/init.d/nginx stop")
nginxRunning = b'Active: active' in subprocess.Popen(
from flask_socketio import SocketIO
import time
socketio = SocketIO(message_queue='redis://')
if __name__ == '__main__':
for i in range(15):
socketio.emit('telem', {'data': i})
print(i)
time.sleep(2)
def UpdateScanerProgress(percent,sid):
print('UpdateScanerProgress')
socketio = SocketIO(message_queue='amqp://')
socketio.emit('ScanerProgress', percent, room=sid)
def UpdatedScanMatch(data_array,sid):
print('UpdatedScanMatch')
socketio = SocketIO(message_queue='amqp://')
print(data_array) # in console ,chcp 65001 then set PYTHONIOENCODING=utf-8, then run websocket.py again,or else ...
socketio.emit('ScanMatch', data_array,room=sid)
