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)