예제 #1
0
def message_from_topic(topic: PubSub, is_json=False, limit: int = 10):
    while limit >= 0:
        msg = topic.get_message()
        if msg is None:
            break
        if msg["type"] != "message":
            # 可能是刚刚连上
            continue
        if is_json:
            yield json.loads(msg["data"])
        else:
            yield msg["data"]
예제 #2
0
파일: main.py 프로젝트: qingwei5732/logs
class SubWebSocket(tornado.websocket.WebSocketHandler):
    def open(self, *args, **kwargs):
        self.pubsub = PubSub(REDIS_CONNECTION_POOL,
                             ignore_subscribe_messages=True)
        self.client = self.request.connection.context.address
        print("opened")

    def assemble_cmd(self, log_path, cmd):
        kill_cmd = "kill `ps aux|grep logtail.py|grep %s|grep -v grep|awk '{print $2}'`" % (
            log_path, )
        return "{kill};{tail}".format(kill=kill_cmd, tail=cmd)

    @gen.coroutine
    def on_message(self, message):
        local = get_local_client(io_loop=tornado.ioloop.IOLoop.instance())
        hostname, log_path, cmd = message.split("||")
        cmd = self.assemble_cmd(log_path, cmd)
        self.channel = settings.LOG_KEY.format(server=hostname.strip(),
                                               log_path=log_path.strip())
        self.pubsub.subscribe(**{self.channel: self.channel_callback})
        local.cmd_async(hostname, "cmd.run", [cmd])
        while self.pubsub.subscribed:
            if not self.pubsub.connection.can_read(timeout=0):
                yield gen.sleep(0.05)
            else:
                self.pubsub.get_message()
        self.pubsub.close()
        print 'pubsub closed'

    def channel_callback(self, message):
        line = format_line(message["data"])
        try:
            self.write_message(line)
        except tornado.websocket.WebSocketClosedError:
            self.pubsub.unsubscribe(self.channel)

    def on_close(self):
        self.pubsub.unsubscribe(self.channel)
        print("closed")
예제 #3
0
def get_distance(pubsub: PubSub) -> float:
    pubsub.subscribe("subsystem.sonar.measurement", ignore_subscribe_messages=True)
    timeout = 0.5
    start = time.time()
    while cycle([True]):
        if time.time() - start > timeout:
            logger.error("Unable to get sonar measurement!!")
            raise NoSonarException("Unable to get sonar measurement")
        redis_message = pubsub.get_message()
        if redis_message is not None:
            pubsub.unsubscribe("subsystem.sonar.measurement")
            message = json.loads(redis_message['data'])
            return float(message)
        sleep(0.01)
예제 #4
0
def get_phrase(redis_client: Redis, pubsub: PubSub, timeout: int = 0) -> str:
    start = time()
    request_id = str(uuid1())
    redis_client.publish("subsystem.listener.command",
                         dumps({
                             "mode": "phrase",
                             "request_id": request_id
                         }))
    logger.debug(f"Listening for phrase (request_id={request_id})")
    while cycle([True]):
        waited_so_far = time() - start
        if timeout and waited_so_far > timeout:
            raise ListeningTimeoutException(
                f"Timed out waiting for phrase after {waited_so_far} seconds")
        if redis_message := pubsub.get_message():
            message = loads(redis_message['data'])
            if message['request_id'] != request_id:
                logger.debug(f"ignoring request id #{message['request_id']}")
                continue
            logger.debug(
                f"Received a response to request_id #{message['request_id']}")
            logger.debug(f"Received phrase was {message['transcription']}")
            return message['transcription']
        sleep(0.01)
예제 #5
0
    def wait(self, pubsub: SyncPubsSub, timeout: int = 30, **kwargs) -> Any:
        """Wait for pub/sub messages & return posted message."""
        now = time.time()
        timeout = now + timeout

        while now < timeout:

            message = pubsub.get_message(ignore_subscribe_messages=True,
                                         **kwargs)

            if message is not None and message["type"] == "message":
                data = message["data"]
                return self.parse_types(data)

            time.sleep(0.01)
            now = time.time()

        return None