Python SocketIO.emit方法代码示例

# 需要导入模块: from flask_socketio import SocketIO [as 别名]
# 或者: from flask_socketio.SocketIO import emit [as 别名]
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]"

# 需要导入模块: from flask_socketio import SocketIO [as 别名]
# 或者: from flask_socketio.SocketIO import emit [as 别名]
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}

# 需要导入模块: from flask_socketio import SocketIO [as 别名]
# 或者: from flask_socketio.SocketIO import emit [as 别名]
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)

# 需要导入模块: from flask_socketio import SocketIO [as 别名]
# 或者: from flask_socketio.SocketIO import emit [as 别名]
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)

# 需要导入模块: from flask_socketio import SocketIO [as 别名]
# 或者: from flask_socketio.SocketIO import emit [as 别名]
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)

# 需要导入模块: from flask_socketio import SocketIO [as 别名]
# 或者: from flask_socketio.SocketIO import emit [as 别名]
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

# 需要导入模块: from flask_socketio import SocketIO [as 别名]
# 或者: from flask_socketio.SocketIO import emit [as 别名]
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()

# 需要导入模块: from flask_socketio import SocketIO [as 别名]
# 或者: from flask_socketio.SocketIO import emit [as 别名]
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)

# 需要导入模块: from flask_socketio import SocketIO [as 别名]
# 或者: from flask_socketio.SocketIO import emit [as 别名]
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)

# 需要导入模块: from flask_socketio import SocketIO [as 别名]
# 或者: from flask_socketio.SocketIO import emit [as 别名]
 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 [as 别名]
# 或者: from flask_socketio.SocketIO import emit [as 别名]
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)

# 需要导入模块: from flask_socketio import SocketIO [as 别名]
# 或者: from flask_socketio.SocketIO import emit [as 别名]
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 [as 别名]
# 或者: from flask_socketio.SocketIO import emit [as 别名]
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)

# 需要导入模块: from flask_socketio import SocketIO [as 别名]
# 或者: from flask_socketio.SocketIO import emit [as 别名]
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)

# 需要导入模块: from flask_socketio import SocketIO [as 别名]
# 或者: from flask_socketio.SocketIO import emit [as 别名]
def UpdateScanerProgress(percent,sid):
    print('UpdateScanerProgress')
    socketio = SocketIO(message_queue='amqp://')
    socketio.emit('ScanerProgress', percent, room=sid)