def main(): nc = NATS() # Establish connection to the server. yield nc.connect(servers=["nats://127.0.0.1:4222"]) def discover(msg=None): print("[Received]: %s" % msg.data) sid = yield nc.subscribe("discover", "", discover) # Only interested in 2 messages. yield nc.auto_unsubscribe(sid, 2) yield nc.publish("discover", "A") yield nc.publish("discover", "B") # Following two messages won't be received. yield nc.publish("discover", "C") yield nc.publish("discover", "D") # Request/Response def help_request_handler(msg): print("[Received]: %s" % msg.data) nc.publish(msg.reply, "OK, I can help!") # Susbcription using distributed queue yield nc.subscribe("help", "workers", help_request_handler) try: # Expect a single request and timeout after 500 ms response = yield nc.request("help", "Hi, need help!", timeout=0.500) print("[Response]: %s" % response.data) except tornado.gen.TimeoutError, e: print("Timeout! Need to retry...")
def main(): nc = NATS() # Establish connection to the server. options = { "verbose": True, "servers": ["nats://127.0.0.1:4222"] } yield nc.connect(**options) def discover(msg=None): print("[Received]: %s" % msg.data) sid = yield nc.subscribe("discover", "", discover) # Only interested in 2 messages. yield nc.auto_unsubscribe(sid, 2) yield nc.publish("discover", "A") yield nc.publish("discover", "B") # Following two messages won't be received. yield nc.publish("discover", "C") yield nc.publish("discover", "D") # Request/Response def help_request_handler(msg): print("[Received]: %s" % msg.data) nc.publish(msg.reply, "OK, I can help!") # Susbcription using distributed queue yield nc.subscribe("help", "workers", help_request_handler) try: # Expect a single request and timeout after 500 ms response = yield nc.timed_request("help", "Hi, need help!", 500) print("[Response]: %s" % response.data) except tornado.gen.TimeoutError, e: print("Timeout! Need to retry...")
def test_close_connection(self): nc = Client() options = { "dont_randomize": True, "servers": [ "nats://*****:*****@127.0.0.1:4223", "nats://*****:*****@127.0.0.1:4224" ], "io_loop": self.io_loop } yield nc.connect(**options) self.assertEqual(True, nc._server_info["auth_required"]) log = Log() sid_1 = yield nc.subscribe("foo", "", log.persist) self.assertEqual(sid_1, 1) sid_2 = yield nc.subscribe("bar", "", log.persist) self.assertEqual(sid_2, 2) sid_3 = yield nc.subscribe("quux", "", log.persist) self.assertEqual(sid_3, 3) yield nc.publish("foo", "hello") yield tornado.gen.sleep(1.0) # Done yield nc.close() orig_gnatsd = self.server_pool.pop(0) orig_gnatsd.finish() try: a = nc._current_server # Wait and assert that we don't reconnect. yield tornado.gen.sleep(3) finally: b = nc._current_server self.assertEqual(a.uri, b.uri) self.assertFalse(nc.is_connected()) self.assertFalse(nc.is_reconnecting()) self.assertTrue(nc.is_closed()) with(self.assertRaises(ErrConnectionClosed)): yield nc.publish("hello", "world") with(self.assertRaises(ErrConnectionClosed)): yield nc.flush() with(self.assertRaises(ErrConnectionClosed)): yield nc.subscribe("hello", "worker") with(self.assertRaises(ErrConnectionClosed)): yield nc.publish_request("hello", "inbox", "world") with(self.assertRaises(ErrConnectionClosed)): yield nc.request("hello", "world") with(self.assertRaises(ErrConnectionClosed)): yield nc.timed_request("hello", "world")
def main(): nc = NATS() # Establish connection to the server. options = { "verbose": True, "servers": ["nats://127.0.0.1:4222"] } yield nc.connect(**options) def discover(msg=None): print("[Received]: %s" % msg.data) sid = yield nc.subscribe("discover", "", discover) # Only interested in 2 messages. yield nc.auto_unsubscribe(sid, 2) yield nc.publish("discover", "A") yield nc.publish("discover", "B") # Following two messages won't be received. yield nc.publish("discover", "C") yield nc.publish("discover", "D") # Request/Response def help_request_handler(msg): print("[Received]: %s" % msg.data) nc.publish(msg.reply.decode(), "OK, I can help!") # Susbcription using distributed queue yield nc.subscribe("help", "workers", help_request_handler) try: # Expect a single request and timeout after 500 ms response = yield nc.timed_request("help", "Hi, need help!", 500) print("[Response]: %s" % response.data) except tornado.gen.TimeoutError as e: print("Timeout! Need to retry...") # Customize number of responses to receive def many_responses(msg=None): print("[Response]: %s" % msg.data) yield nc.request("help", "please", expected=2, cb=many_responses) # Publish inbox my_inbox = new_inbox() yield nc.subscribe(my_inbox) yield nc.publish_request("help", my_inbox, "I can help too!") loop = tornado.ioloop.IOLoop.instance() yield tornado.gen.Task(loop.add_timeout, time.time() + 1) try: start = datetime.now() # Make roundtrip to the server and timeout after 1000 ms yield nc.flush(1000) end = datetime.now() print("Latency: %d µs" % (end.microsecond - start.microsecond)) except tornado.gen.TimeoutError as e: print("Timeout! Roundtrip too slow...")
def go(loop): nc = NATS() try: yield from nc.connect(io_loop=loop) except: pass def message_handler(msg): print("[Received on '{}']: {}".format(msg.subject, msg.data.decode())) try: # Interested in receiving 2 messages from the 'discover' subject. sid = yield from nc.subscribe("discover", "", message_handler) yield from nc.auto_unsubscribe(sid, 2) yield from nc.publish("discover", b'hello') yield from nc.publish("discover", b'world') # Following 2 messages won't be received. yield from nc.publish("discover", b'again') yield from nc.publish("discover", b'!!!!!') except ErrConnectionClosed: print("Connection closed prematurely") def request_handler(msg): print("[Request on '{} {}']: {}".format(msg.subject, msg.reply, msg.data.decode())) if nc.is_connected: # Subscription using a 'workers' queue so that only a single subscriber # gets a request at a time. yield from nc.subscribe("help", "workers", request_handler) try: # Make a request expecting a single response within 500 ms, # otherwise raising a timeout error. response = yield from nc.timed_request("help", b'help please', 0.500) print("[Response]: {}".format(msg.data)) # Make a roundtrip to the server to ensure messages # that sent messages have been processed already. yield from nc.flush(0.500) except ErrTimeout: print("[Error] Timeout!") # Wait a bit for message to be dispatched... yield from asyncio.sleep(1, loop=loop) # Detach from the server. yield from nc.close() if nc.last_error is not None: print("Last Error: {}".format(nc.last_error)) if nc.is_closed: print("Disconnected.")
def main(): nc = NATS() options = { "servers": ["nats://192.168.0.114:4222"], "user": "******", "password": "******", "tcp_nodelay": True } # Establish connection to the server. yield nc.connect(**options) @tornado.gen.coroutine def message_handler(msg): subject = msg.subject data = msg.data cmd = msgpack.unpackb(data) print("[Received on '{}'] : {}".format(subject, cmd)) print(cmd["gear"]) # Simple async subscriber sid = yield nc.subscribe("cmd", cb=message_handler) yield nc.publish("cmd", "test")
def main(): # Parse the command line arguments parser = argparse.ArgumentParser() # e.g. nats-sub hello -s nats://127.0.0.1:4222 parser.add_argument('subject', default='hello', nargs='?') parser.add_argument('-s', '--servers', default=[], action='append') parser.add_argument('-q', '--queue', default="") # Parse! args = parser.parse_args() # Create client and connect to server nc = NATS() servers = args.servers if len(args.servers) < 1: servers = ["nats://127.0.0.1:4222"] opts = { "servers": servers } yield nc.connect(**opts) def handler(msg): print("[Received: {0}] {1}".format(msg.subject, msg.data)) print("Subscribed to '{0}'".format(args.subject)) future = nc.subscribe(args.subject, args.queue, handler) sid = future.result()
def test_publish(self): nc = Client() yield nc.connect(io_loop=self.io_loop) self.assertEqual(Client.CONNECTED, nc._status) info_keys = nc._server_info.keys() self.assertTrue(len(info_keys) > 0) log = Log() yield nc.subscribe(">", "", log.persist) yield nc.publish("one", "hello") yield nc.publish("two", "world") yield tornado.gen.sleep(1.0) http = tornado.httpclient.AsyncHTTPClient() response = yield http.fetch('http://127.0.0.1:%d/varz' % self.server_pool[0].http_port) varz = json.loads(response.body.decode("utf-8")) self.assertEqual(10, varz['in_bytes']) self.assertEqual(10, varz['out_bytes']) self.assertEqual(2, varz['in_msgs']) self.assertEqual(2, varz['out_msgs']) self.assertEqual(2, len(log.records.keys())) self.assertEqual("hello", log.records[b'one'][0].data.decode()) self.assertEqual("world", log.records[b'two'][0].data.decode()) self.assertEqual(10, nc.stats['in_bytes']) self.assertEqual(10, nc.stats['out_bytes']) self.assertEqual(2, nc.stats['in_msgs']) self.assertEqual(2, nc.stats['out_msgs'])
def main(): # Parse the command line arguments parser = argparse.ArgumentParser() # e.g. nats-sub hello -s nats://127.0.0.1:4222 parser.add_argument('subject', default='hello', nargs='?') parser.add_argument('-s', '--servers', default=[], action='append') parser.add_argument('-q', '--queue', default="") # Parse! args = parser.parse_args() # Create client and connect to server nc = NATS() servers = args.servers if len(args.servers) < 1: servers = ["nats://127.0.0.1:4222"] opts = { "servers": servers } yield nc.connect(**opts) def handler(msg): logger.debug("[Received: {%s}] {%s}", msg.subject, str(msg.data)) logger.debug("Subscribed to '{%s}'", args.subject) future = nc.subscribe(args.subject, args.queue, handler) sid = future.result()
def main(): nc = NATS() # Establish secure connection to the server, tls options parameterize # the wrap_socket available from ssl python package. options = { "verbose": True, "servers": ["nats://127.0.0.1:4444"], "tls": { "cert_reqs": ssl.CERT_REQUIRED, "ca_certs": "./tests/configs/certs/ca.pem", "keyfile": "./tests/configs/certs/client-key.pem", "certfile": "./tests/configs/certs/client-cert.pem" } } yield nc.connect(**options) def discover(msg=None): print("[Received]: %s" % msg.data) sid = yield nc.subscribe("discover", "", discover) # Only interested in 2 messages. yield nc.auto_unsubscribe(sid, 2) yield nc.publish("discover", "A") yield nc.publish("discover", "B") # Following two messages won't be received. yield nc.publish("discover", "C") yield nc.publish("discover", "D") # Request/Response def help_request_handler(msg): print("[Received]: %s" % msg.data) nc.publish(msg.reply, "OK, I can help!") # Susbcription using distributed queue yield nc.subscribe("help", "workers", help_request_handler) try: # Expect a single request and timeout after 500 ms response = yield nc.timed_request("help", "Hi, need help!", timeout=0.500) print("[Response]: %s" % response.data) except tornado.gen.TimeoutError, e: print("Timeout! Need to retry...")
def test_request(self): nc = Client() yield nc.connect(io_loop=self.io_loop) class Component: def __init__(self, nc): self.nc = nc self.replies = [] def receive_responses(self, msg=None): self.replies.append(msg) @tornado.gen.coroutine def respond(self, msg=None): yield self.nc.publish(msg.reply.decode(), "ok:1") yield self.nc.publish(msg.reply.decode(), "ok:2") yield self.nc.publish(msg.reply.decode(), "ok:3") log = Log() c = Component(nc) yield nc.subscribe(">", "", log.persist) yield nc.subscribe("help", "", c.respond) yield nc.request("help", "please", expected=2, cb=c.receive_responses) yield tornado.gen.sleep(0.5) http = tornado.httpclient.AsyncHTTPClient() response = yield http.fetch('http://127.0.0.1:%d/varz' % self.server_pool[0].http_port) varz = json.loads(response.body.decode("utf-8")) self.assertEqual(18, varz['in_bytes']) self.assertEqual(32, varz['out_bytes']) self.assertEqual(4, varz['in_msgs']) self.assertEqual(7, varz['out_msgs']) self.assertEqual(2, len(log.records.keys())) self.assertEqual("please", log.records[b'help'][0].data.decode()) self.assertEqual(2, len(c.replies)) self.assertEqual(32, nc.stats['in_bytes']) self.assertEqual(18, nc.stats['out_bytes']) self.assertEqual(7, nc.stats['in_msgs']) self.assertEqual(4, nc.stats['out_msgs']) full_msg = '' for msg in log.records[b'help']: full_msg += msg.data.decode("utf-8") self.assertEqual('please', full_msg) self.assertEqual("ok:1", c.replies[0].data.decode()) self.assertEqual("ok:2", c.replies[1].data.decode())
def main(): nc = NATS() # Establish secure connection to the server, tls options parameterize # the wrap_socket available from ssl python package. options = { "verbose": True, "servers": ["nats://127.0.0.1:4444"], "tls": { "cert_reqs": ssl.CERT_REQUIRED, "ca_certs": "./tests/configs/certs/ca.pem", "keyfile": "./tests/configs/certs/client-key.pem", "certfile": "./tests/configs/certs/client-cert.pem" } } yield nc.connect(**options) def discover(msg=None): print("[Received]: %s" % msg.data) sid = yield nc.subscribe("discover", "", discover) # Only interested in 2 messages. yield nc.auto_unsubscribe(sid, 2) yield nc.publish("discover", "A") yield nc.publish("discover", "B") # Following two messages won't be received. yield nc.publish("discover", "C") yield nc.publish("discover", "D") # Request/Response def help_request_handler(msg): print("[Received]: %s" % msg.data) nc.publish(msg.reply, "OK, I can help!") # Susbcription using distributed queue yield nc.subscribe("help", "workers", help_request_handler) try: # Expect a single request and timeout after 500 ms response = yield nc.timed_request( "help", "Hi, need help!", timeout=0.500) print("[Response]: %s" % response.data) except tornado.gen.TimeoutError, e: print("Timeout! Need to retry...")
def main(): nc = NATS() # Set pool servers in the cluster and give a name to the client # each with its own auth credentials. options = { "servers": [ "nats://*****:*****@127.0.0.1:4222", "nats://*****:*****@127.0.0.1:4223", "nats://*****:*****@127.0.0.1:4224" ] } # Error callback takes the error type as param. def error_cb(e): print("Error! ", e) def close_cb(): print("Connection was closed!") def disconnected_cb(): print("Disconnected!") def reconnected_cb(): print("Reconnected!") # Set callback to be dispatched whenever we get # protocol error message from the server. options["error_cb"] = error_cb # Called when we are not connected anymore to the NATS cluster. options["close_cb"] = close_cb # Called whenever we become disconnected from a NATS server. options["disconnected_cb"] = disconnected_cb # Called when we connect to a node in the NATS cluster again. options["reconnected_cb"] = reconnected_cb yield nc.connect(**options) @tornado.gen.coroutine def subscriber(msg): yield nc.publish("pong", "pong:{0}".format(msg.data)) yield nc.subscribe("ping", "", subscriber) for i in range(0, 100): yield nc.publish("ping", "ping:{0}".format(i)) yield tornado.gen.sleep(0.1) yield nc.close() try: yield nc.publish("ping", "ping") except ErrConnectionClosed: print("No longer connected to NATS cluster.")
class MyNATSClass: def __init__(self, t_name, queue, mqtt): self._queue = queue logger.debug("I am NATS") try: tmp = os.environ["NATSSERVERURI"] logger.debug("nats server uri = %s", tmp) self._servers_uri = [] self._servers_uri.append(tmp) except: logger.debug("Can not get enviro NATSSERVERURI") sys.exit(0) self._nats = NATS() self._mqtt = mqtt @tornado.gen.coroutine def _nats_main(self): opts = {"servers": self._servers_uri} yield self._nats.connect(**opts) logger.debug("subscribe ericssion.iot.nats.c3shadow") yield self._nats.subscribe("ericssion.iot.nats.c3shadow", "", self._subscribe) while gEnd == False: sent = self._nats.stats["out_msgs"] received = self._nats.stats["in_msgs"] yield tornado.gen.sleep(2) try: tmp = self._queue.get(False) except Queue.Empty: # logger.debug("send msg = %d, in_msgs = %d, queue is empty", sent, received) continue yield self._nats.publish("ericssion.iot.nats.c3engine", tmp) yield self._nats.flush() logger.debug("nats publish message = %s", tmp) logger.debug("I died") def _subscribe(self, msg): # logger.debug("get msg subject = %s, data = %s", msg.subject, str(msg.data)) try: tmp = str(msg.data).replace("'", '"') mydict = json.loads(tmp) except: logger.debug("message format is not correct, subject = %s, data = %s", msg.subject, str(msg.data)) return print "NATS:: received %s" % (str(mydict)) if mydict.has_key("data"): print "hello********************" # need MQTT publish self._mqtt.mqtt_publish(mydict) else: self._mqtt.mqtt_subscribe(mydict) def run(self): tornado.ioloop.IOLoop.instance().run_sync(self._nats_main)
def main(): nc = NATS() # Set pool servers in the cluster and give a name to the client # each with its own auth credentials. options = { "servers": [ "nats://*****:*****@127.0.0.1:4222", "nats://*****:*****@127.0.0.1:4223", "nats://*****:*****@127.0.0.1:4224" ] } # Error callback takes the error type as param. def error_cb(e): print("Error! ", e) def close_cb(): print("Connection was closed!") def disconnected_cb(): print("Disconnected!") def reconnected_cb(): print("Reconnected!") # Set callback to be dispatched whenever we get # protocol error message from the server. options["error_cb"] = error_cb # Called when we are not connected anymore to the NATS cluster. options["closed_cb"] = close_cb # Called whenever we become disconnected from a NATS server. options["disconnected_cb"] = disconnected_cb # Called when we connect to a node in the NATS cluster again. options["reconnected_cb"] = reconnected_cb yield nc.connect(**options) @tornado.gen.coroutine def subscriber(msg): yield nc.publish("pong", "pong:{0}".format(msg.data)) yield nc.subscribe("ping", "", subscriber) for i in range(0, 100): yield nc.publish("ping", "ping:{0}".format(i)) yield tornado.gen.sleep(0.1) yield nc.close() try: yield nc.publish("ping", "ping") except ErrConnectionClosed: print("No longer connected to NATS cluster.")
def main(): nc = NATS() # Establish connection to the server. yield nc.connect("nats://demo.nats.io:4222") @tornado.gen.coroutine def message_handler(msg): subject = msg.subject data = msg.data print("[Received on '{}'] : {}".format(subject, data.decode())) # Simple async subscriber sid = yield nc.subscribe("foo", cb=message_handler) # Stop receiving after 2 messages. yield nc.auto_unsubscribe(sid, 2) yield nc.publish("foo", b'Hello') yield nc.publish("foo", b'World') yield nc.publish("foo", b'!!!!!') # Request/Response @tornado.gen.coroutine def help_request_handler(msg): print("[Received on '{}']: {}".format(msg.subject, msg.data)) yield nc.publish(msg.reply, "OK, I can help!") # Susbcription using distributed queue named 'workers' sid = yield nc.subscribe("help", "workers", help_request_handler) try: # Send a request and expect a single response # and trigger timeout if not faster than 200 ms. msg = yield nc.request("help", b"Hi, need help!", timeout=0.2) print("[Response]: %s" % msg.data) except tornado.gen.TimeoutError: print("Response Timeout!") # Remove interest in subscription. yield nc.unsubscribe(sid) # Terminate connection to NATS. yield nc.close()
def subscribe(): received_message_list = [] # Parse the command line arguments parser = argparse.ArgumentParser() # e.g. nats-sub hello -s nats://127.0.0.1:4222 parser.add_argument("subject", default="hello", nargs="?") parser.add_argument("-o", "--original", default="hello", nargs="?") parser.add_argument("-m", "--maxmsg", default=10000, type=int) parser.add_argument("-d", "--dirname") # Parse! args = parser.parse_args() file_time = time.strftime("%d-%m-%Y-%H-%M-%S") filename = "nats-run_" +\ args.subject + "-" + args.original + "_" +\ file_time + ".txt" #Filename of message data for the user_id completed_user_list = [] # List of subscribed users who have finished publishing # Create client and connect to server nc = NATS() servers = ["nats://146.148.76.9:4222"] #servers = ["nats://127.0.0.1:4222"] opts = { "servers": servers } yield nc.connect(**opts) def handler(msg): #print("[Received: {0}] {1}".format(msg.subject, msg.data)) sub_time = get_time() received_message_str = str(msg.data) split_message = received_message_str.split(" ") message_number = int(split_message[2]) final_message = split_message[0] + " " +\ split_message[1] + " " +\ args.original + " " +\ sub_time received_message_list.append(final_message) if message_number == args.maxmsg: fd = open(args.dirname + "/" + filename, "a") for i in received_message_list: print >> fd, i fd.close del received_message_list[:] tornado.ioloop.IOLoop.instance().stop() print("Subscribed to '{0}'".format(args.subject)) future = nc.subscribe(args.subject, "", handler) sid = future.result()
class MyNATSClass(): def __init__(self, queue): logger.debug("I am NATS") self._queue = queue self._nats = NATS() try: tmp = os.environ["NATSSERVERURI"] logger.debug("nats server uri = %s", tmp) self._servers_uri = [] self._servers_uri.append(tmp) except: logger.debug("Can not get enviro NATSSERVERURI") sys.exit(0) @tornado.gen.coroutine def nats_main(self): # Create client and connect to server opts = { "servers": self._servers_uri } yield self._nats.connect(**opts) def handler(msg): logger.debug("NATS:: [Received: {%s}] {%s}",msg.subject, str(msg.data)) tmp = str(msg.data).replace("'","\"") try: my_dict = json.loads(tmp) except: logger.debug("can not translate data to JSON format, ignore this message, %s", str(msg.data)) return f_set = set(["topic", "clientid", "data", "account"]) n_set = set(my_dict.keys()) if f_set == n_set: self._queue.put(my_dict) else: logger.debug("topic payload is not correct format, ignore it %s", str(n_set)) logger.debug("Subscribed to '%s'", "ericssion.iot.nats.c3engine") future = self._nats.subscribe("ericssion.iot.nats.c3engine", "", handler) sid = future.result() def nats_publish(self, payload): logger.debug("NATS:: publish message payload = %s", payload) self._nats.publish("ericssion.iot.nats.c3shadow", payload) def run(self): tornado.ioloop.IOLoop.instance().start()
def main(): nc = NATS() yield nc.connect("nats://127.0.0.1:4222") exitCondition = None @tornado.gen.coroutine def help_request_handler(msg): subject = msg.subject data = msg.data print("[Received on '{}'] : {}".format(subject, data.decode())) yield nc.publish(msg.reply, b'OK, I will help!') try: yield nc.subscribe('agent_aws_1', "workers", help_request_handler) except Exception as e: print("!!! Exception : {}".format(e)) exitCondition = True while not exitCondition: yield tornado.gen.sleep(60)
def test_subscribe(self): nc = Client() options = { "io_loop": self.io_loop } yield nc.connect(**options) self.assertEqual(Client.CONNECTED, nc._status) info_keys = nc._server_info.keys() self.assertTrue(len(info_keys) > 0) inbox = new_inbox() yield nc.subscribe("help.1") yield nc.subscribe("help.2") yield tornado.gen.sleep(0.5) http = tornado.httpclient.AsyncHTTPClient() response = yield http.fetch('http://127.0.0.1:%d/connz' % self.server_pool[0].http_port) result = json.loads(response.body.decode("utf-8")) connz = result['connections'][0] self.assertEqual(2, connz['subscriptions'])
def test_auth_connect(self): nc = Client() options = { "dont_randomize": True, "servers": [ "nats://*****:*****@127.0.0.1:4223", "nats://*****:*****@127.0.0.1:4224" ], "io_loop": self.io_loop } yield nc.connect(**options) self.assertEqual(True, nc._server_info["auth_required"]) log = Log() sid_1 = yield nc.subscribe("foo", "", log.persist) self.assertEqual(sid_1, 1) sid_2 = yield nc.subscribe("bar", "", log.persist) self.assertEqual(sid_2, 2) sid_3 = yield nc.subscribe("quux", "", log.persist) self.assertEqual(sid_3, 3) yield nc.publish("foo", "hello") yield tornado.gen.sleep(1.0) http = tornado.httpclient.AsyncHTTPClient() response = yield http.fetch('http://127.0.0.1:8223/connz') result = json.loads(response.body.decode("utf-8")) connz = result['connections'][0] self.assertEqual(3, connz['subscriptions']) self.assertEqual(1, connz['in_msgs']) self.assertEqual(5, connz['in_bytes']) yield nc.publish("foo", "world") yield tornado.gen.sleep(0.5) response = yield http.fetch('http://127.0.0.1:8223/connz') result = json.loads(response.body.decode("utf-8")) connz = result['connections'][0] self.assertEqual(3, connz['subscriptions']) self.assertEqual(2, connz['in_msgs']) self.assertEqual(10, connz['in_bytes']) orig_gnatsd = self.server_pool.pop(0) orig_gnatsd.finish() try: a = nc._current_server # Wait for reconnect logic kick in... yield tornado.gen.sleep(5) finally: b = nc._current_server self.assertNotEqual(a.uri, b.uri) self.assertTrue(nc.is_connected()) self.assertFalse(nc.is_reconnecting()) http = tornado.httpclient.AsyncHTTPClient() response = yield http.fetch('http://127.0.0.1:8224/connz') result = json.loads(response.body.decode("utf-8")) connz = result['connections'][0] self.assertEqual(3, connz['subscriptions']) self.assertEqual(0, connz['in_msgs']) self.assertEqual(0, connz['in_bytes']) yield nc.publish("foo", "!!!") yield tornado.gen.sleep(0.5) response = yield http.fetch('http://127.0.0.1:8224/connz') result = json.loads(response.body.decode("utf-8")) connz = result['connections'][0] self.assertEqual(3, connz['subscriptions']) self.assertEqual(1, connz['in_msgs']) self.assertEqual(3, connz['in_bytes']) full_msg = '' for msg in log.records[b'foo']: full_msg += msg.data.decode("utf-8") self.assertEqual('helloworld!!!', full_msg)