def test(): sock = mosq_test.do_client_connect(connect_packet, connack_packet, port=port) mosq_test.do_send_receive(sock, subscribe1_packet, suback1_packet, "suback 1") mosq_test.do_send_receive(sock, subscribe2_packet, suback2_packet, "suback 2") mosq_test.do_send_receive(sock, unsubscribe1_packet, unsuback1_packet, "unsuback") sock.send(disconnect_packet) sock.close()
def pattern_test(sub_topic, pub_topic): rc = 1 keepalive = 60 connect_packet = mosq_test.gen_connect("pattern-sub-test", keepalive=keepalive) connack_packet = mosq_test.gen_connack(rc=0) publish_packet = mosq_test.gen_publish(pub_topic, qos=0, payload="message") publish_retained_packet = mosq_test.gen_publish(pub_topic, qos=0, retain=True, payload="message") mid = 312 subscribe_packet = mosq_test.gen_subscribe(mid, sub_topic, 0) suback_packet = mosq_test.gen_suback(mid, 0) mid = 234; unsubscribe_packet = mosq_test.gen_unsubscribe(mid, sub_topic) unsuback_packet = mosq_test.gen_unsuback(mid) port = mosq_test.get_port() broker = subprocess.Popen(['../../src/mosquitto', '-p', str(port)], stdout=subprocess.PIPE, stderr=subprocess.PIPE) try: time.sleep(0.5) sock = mosq_test.do_client_connect(connect_packet, connack_packet, timeout=20, port=port) mosq_test.do_send_receive(sock, subscribe_packet, suback_packet, "suback") pub = subprocess.Popen(['./03-pattern-matching-helper.py', pub_topic, str(port)], stdout=subprocess.PIPE, stderr=subprocess.PIPE) pub.wait() (stdo, stde) = pub.communicate() if mosq_test.expect_packet(sock, "publish", publish_packet): mosq_test.do_send_receive(sock, unsubscribe_packet, unsuback_packet, "unsuback") mosq_test.do_send_receive(sock, subscribe_packet, suback_packet, "suback") if mosq_test.expect_packet(sock, "publish retained", publish_retained_packet): rc = 0 sock.close() finally: broker.terminate() broker.wait() (stdo, stde) = broker.communicate() if rc: print(stde) print(stdo) raise return rc
cmd_subfolder = os.path.realpath(os.path.abspath(os.path.join(os.path.split(inspect.getfile( inspect.currentframe() ))[0],".."))) if cmd_subfolder not in sys.path: sys.path.insert(0, cmd_subfolder) import mosq_test port = mosq_test.get_port() rc = 1 keepalive = 60 connect_packet = mosq_test.gen_connect("test-helper", keepalive=keepalive) connack_packet = mosq_test.gen_connack(rc=0) mid = 312 publish_packet = mosq_test.gen_publish("qos2/disconnect/test", qos=2, mid=mid, payload="disconnect-message") pubrec_packet = mosq_test.gen_pubrec(mid) pubrel_packet = mosq_test.gen_pubrel(mid) pubcomp_packet = mosq_test.gen_pubcomp(mid) sock = mosq_test.do_client_connect(connect_packet, connack_packet, connack_error="helper connack", port=port) mosq_test.do_send_receive(sock, publish_packet, pubrec_packet, "helper pubrec") mosq_test.do_send_receive(sock, pubrel_packet, pubcomp_packet, "helper pubcomp") rc = 0 sock.close() exit(rc)
if cmd_subfolder not in sys.path: sys.path.insert(0, cmd_subfolder) import mosq_test port = mosq_test.get_port() rc = 1 keepalive = 60 connect_packet = mosq_test.gen_connect("test-helper", keepalive=keepalive) connack_packet = mosq_test.gen_connack(rc=0) mid = 128 publish_packet = mosq_test.gen_publish("bridge/disconnect/test", qos=1, mid=mid, payload="disconnect-message") puback_packet = mosq_test.gen_puback(mid) sock = mosq_test.do_client_connect(connect_packet, connack_packet, port=port, connack_error="helper connack") mosq_test.do_send_receive(sock, publish_packet, puback_packet, "helper puback") rc = 0 sock.close() exit(rc)
mid = 1 publish_packet = mosq_test.gen_publish("flipflop/test", qos=1, mid=mid, payload="message") puback_packet = mosq_test.gen_puback(mid) port = mosq_test.get_port() broker = mosq_test.start_broker(filename=os.path.basename(__file__), port=port) try: # mosquitto_sub -i sub -t 'topic' -q 1 -d -c sub_sock = mosq_test.do_client_connect(connect_packet_sub_persistent, connack_packet_sub, port=port) mosq_test.do_send_receive(sub_sock, subscribe_packet, suback_packet, "subscribe persistent 1") # And disconnect sub_sock.close() # mosquitto_sub -i sub -t 'topic' -q 1 -d sub_sock = mosq_test.do_client_connect(connect_packet_sub_clean, connack_packet_sub, port=port) mosq_test.do_send_receive(sub_sock, subscribe_packet, suback_packet, "subscribe clean") # And disconnect sub_sock.close() # mosquitto_sub -i sub -t 'topic' -v -q 1 -d -c sub_sock = mosq_test.do_client_connect(connect_packet_sub_persistent, connack_packet_sub,
connack_packet = mosq_test.gen_connack(rc=0) subscribe_packet = mosq_test.gen_subscribe(mid, "invalid/utf8", 0) b = list(struct.unpack("B"*len(subscribe_packet), subscribe_packet)) b[13] = 0 # Topic should never have a 0x0000 subscribe_packet = struct.pack("B"*len(b), *b) suback_packet = mosq_test.gen_suback(mid, 0) port = mosq_test.get_port() broker = mosq_test.start_broker(filename=os.path.basename(__file__), port=port) try: time.sleep(0.5) sock = mosq_test.do_client_connect(connect_packet, connack_packet, port=port) mosq_test.do_send_receive(sock, subscribe_packet, "", "suback") rc = 0 sock.close() finally: broker.terminate() broker.wait() (stdo, stde) = broker.communicate() if rc: print(stde) exit(rc)
pubcomp_packet = mosq_test.gen_pubcomp(mid) mid = 1 publish_packet2 = mosq_test.gen_publish("subpub/qos2", qos=2, mid=mid, payload="message") pubrec_packet2 = mosq_test.gen_pubrec(mid) pubrel_packet2 = mosq_test.gen_pubrel(mid) pubcomp_packet2 = mosq_test.gen_pubcomp(mid) port = mosq_test.get_port() broker = mosq_test.start_broker(filename=os.path.basename(__file__), port=port) try: sock = mosq_test.do_client_connect(connect_packet, connack_packet, timeout=20, port=port) mosq_test.do_send_receive(sock, subscribe_packet, suback_packet, "suback") mosq_test.do_send_receive(sock, publish_packet, pubrec_packet, "pubrec") mosq_test.do_send_receive(sock, pubrel_packet, pubcomp_packet, "pubcomp") if mosq_test.expect_packet(sock, "publish2", publish_packet2): mosq_test.do_send_receive(sock, pubrec_packet2, pubrel_packet2, "pubrel2") # Broker side of flow complete so can quit here. rc = 0 sock.close() finally: broker.terminate() broker.wait() (stdo, stde) = broker.communicate() if rc: print(stde)
mid_unsub = 593 unsubscribe_packet = mosq_test.gen_unsubscribe(mid_unsub, "retain/clear/test") unsuback_packet = mosq_test.gen_unsuback(mid_unsub) port = mosq_test.get_port() broker = mosq_test.start_broker(filename=os.path.basename(__file__), port=port) try: sock = mosq_test.do_client_connect(connect_packet, connack_packet, timeout=4, port=port) # Send retained message sock.send(publish_packet) # Subscribe to topic, we should get the retained message back. mosq_test.do_send_receive(sock, subscribe_packet, suback_packet, "suback") if mosq_test.expect_packet(sock, "publish", publish_packet): # Now unsubscribe from the topic before we clear the retained # message. mosq_test.do_send_receive(sock, unsubscribe_packet, unsuback_packet, "unsuback") # Now clear the retained message. sock.send(retain_clear_packet) # Subscribe to topic, we shouldn't get anything back apart # from the SUBACK. mosq_test.do_send_receive(sock, subscribe_packet, suback_packet, "suback") try:
mid = 3266 publish2_packet = mosq_test.gen_publish("qos1/outgoing", qos=1, mid=mid, payload="outgoing-message") puback2_packet = mosq_test.gen_puback(mid) broker = mosq_test.start_broker(filename=os.path.basename(__file__), port=port) try: sock = mosq_test.do_client_connect(connect_packet, connack1_packet, port=port) mosq_test.do_send_receive(sock, subscribe_packet, suback_packet, "suback") pub = subprocess.Popen( ['./03-publish-b2c-disconnect-qos1-helper.py', str(port)], stdout=subprocess.PIPE, stderr=subprocess.PIPE) pub.wait() (stdo, stde) = pub.communicate() # Should have now received a publish command if mosq_test.expect_packet(sock, "publish", publish_packet): # Send our outgoing message. When we disconnect the broker # should get rid of it and assume we're going to retry. sock.send(publish2_packet) sock.close()
payload="retained message", retain=True) publish_fresh_packet = mosq_test.gen_publish("retain/qos0/test", qos=0, payload="retained message") subscribe_packet = mosq_test.gen_subscribe(mid, "retain/qos0/test", 0) suback_packet = mosq_test.gen_suback(mid, 0) port = mosq_test.get_port() broker = mosq_test.start_broker(filename=os.path.basename(__file__), port=port) try: sock = mosq_test.do_client_connect(connect_packet, connack_packet, port=port) mosq_test.do_send_receive(sock, subscribe_packet, suback_packet, "suback") mosq_test.do_send_receive(sock, publish_packet, publish_fresh_packet, "publish") rc = 0 sock.close() finally: broker.terminate() broker.wait() (stdo, stde) = broker.communicate() if rc: print(stde) exit(rc)
#!/usr/bin/env python # Test whether a PUBLISH to a topic with QoS 2 results in the correct packet flow. import inspect, os, sys # From http://stackoverflow.com/questions/279237/python-import-a-module-from-a-folder cmd_subfolder = os.path.realpath(os.path.abspath(os.path.join(os.path.split(inspect.getfile( inspect.currentframe() ))[0],".."))) if cmd_subfolder not in sys.path: sys.path.insert(0, cmd_subfolder) import mosq_test rc = 1 keepalive = 60 connect_packet = mosq_test.gen_connect("test-helper", keepalive=keepalive) connack_packet = mosq_test.gen_connack(rc=0) mid = 128 publish_packet = mosq_test.gen_publish("qos1/timeout/test", qos=1, mid=mid, payload="timeout-message") puback_packet = mosq_test.gen_puback(mid) sock = mosq_test.do_client_connect(connect_packet, connack_packet, connack_error="helper connack") mosq_test.do_send_receive(sock, publish_packet, puback_packet, "helper puback") rc = 0 sock.close() exit(rc)
mid=mid, payload="message") pubrec_packet2 = mosq_test.gen_pubrec(mid) pubrel_packet2 = mosq_test.gen_pubrel(mid) pubcomp_packet2 = mosq_test.gen_pubcomp(mid) port = mosq_test.get_port() broker = mosq_test.start_broker(filename=os.path.basename(__file__), port=port) try: sock = mosq_test.do_client_connect(connect_packet, connack_packet, timeout=20, port=port) mosq_test.do_send_receive(sock, subscribe_packet, suback_packet, "suback") mosq_test.do_send_receive(sock, publish_packet, pubrec_packet, "pubrec") mosq_test.do_send_receive(sock, pubrel_packet, pubcomp_packet, "pubcomp") if mosq_test.expect_packet(sock, "publish2", publish_packet2): mosq_test.do_send_receive(sock, pubrec_packet2, pubrel_packet2, "pubrel2") # Broker side of flow complete so can quit here. rc = 0 sock.close() finally: broker.terminate() broker.wait() (stdo, stde) = broker.communicate() if rc:
def do_test(per_listener, username): conf_file = os.path.basename(__file__).replace('.py', '.conf') write_config(conf_file, port, per_listener) persistence_file = os.path.basename(__file__).replace('.py', '.db') try: os.remove(persistence_file) except OSError: pass acl_file = os.path.basename(__file__).replace('.py', '.acl') write_acl_1(acl_file, username) rc = 1 keepalive = 60 connect_packet = mosq_test.gen_connect("retain-check", keepalive=keepalive, username=username) connack_packet = mosq_test.gen_connack(rc=0) mid = 1 publish_packet = mosq_test.gen_publish("test/topic", qos=0, payload="retained message", retain=True) subscribe_packet = mosq_test.gen_subscribe(mid, "test/topic", 0) suback_packet = mosq_test.gen_suback(mid, 0) pingreq_packet = mosq_test.gen_pingreq() pingresp_packet = mosq_test.gen_pingresp() broker = mosq_test.start_broker(filename=os.path.basename(__file__), use_conf=True, port=port) try: sock = mosq_test.do_client_connect(connect_packet, connack_packet, port=port) sock.send(publish_packet) sock.close() sock = mosq_test.do_client_connect(connect_packet, connack_packet, port=port) mosq_test.do_send_receive(sock, subscribe_packet, suback_packet, "suback 1") if mosq_test.expect_packet(sock, "publish", publish_packet): sock.close() # Remove "write" ability write_acl_2(acl_file, username) broker.terminate() broker.wait() broker = mosq_test.start_broker( filename=os.path.basename(__file__), use_conf=True, port=port) sock = mosq_test.do_client_connect(connect_packet, connack_packet, port=port) mosq_test.do_send_receive(sock, subscribe_packet, suback_packet, "suback 2") # If we receive the retained message here, it is a failure. mosq_test.do_send_receive(sock, pingreq_packet, pingresp_packet, "pingresp") rc = 0 sock.close() finally: broker.terminate() broker.wait() os.remove(conf_file) os.remove(acl_file) os.remove(persistence_file) (stdo, stde) = broker.communicate() if rc: print(stde) exit(rc)
suback_packet = mosq_test.gen_suback(mid, 0) mid_fail = 54 subscribe_packet_fail = mosq_test.gen_subscribe(mid_fail, "#", 0) suback_packet_fail = mosq_test.gen_suback(mid_fail, 0x80) broker = mosq_test.start_broker(filename=os.path.basename(__file__), use_conf=True, port=port) try: sock = mosq_test.do_client_connect(connect_packet, connack_packet, timeout=20, port=port) mosq_test.do_send_receive(sock, subscribe_packet, suback_packet, "suback") mosq_test.do_send_receive(sock, subscribe_packet_fail, suback_packet_fail, "suback") rc = 0 sock.close() finally: os.remove(conf_file) broker.terminate() broker.wait() (stdo, stde) = broker.communicate() if rc: print(stde)
conf_file = os.path.basename(__file__).replace('.py', '.conf') write_config(conf_file, port1, port2) rc = 1 keepalive = 10 connect_packet = mosq_test.gen_connect("connect-cert-test", keepalive=keepalive) connack_packet = mosq_test.gen_connack(rc=0) broker = mosq_test.start_broker(filename=os.path.basename(__file__), port=port2, use_conf=True) sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) ssock = ssl.wrap_socket(sock, ca_certs="../ssl/test-root-ca.crt", cert_reqs=ssl.CERT_REQUIRED) ssock.settimeout(20) try: ssock.connect(("localhost", port1)) mosq_test.do_send_receive(ssock, connect_packet, "", "connack") except ssl.SSLError as err: if err.errno == 1: rc = 0 except socket.error as err: if err.errno == errno.ECONNRESET: rc = 0 os.remove(conf_file) time.sleep(0.5) broker.terminate() broker.wait() (stdo, stde) = broker.communicate() if rc: print(stde)
mid=mid, payload="message") pubcomp1r_packet = mosq_test.gen_pubcomp(mid) pingreq_packet = mosq_test.gen_pingreq() pingresp_packet = mosq_test.gen_pingresp() port = mosq_test.get_port() broker = mosq_test.start_broker(filename=os.path.basename(__file__), port=port) try: sock = mosq_test.do_client_connect(connect_packet, connack_packet, timeout=20, port=port) mosq_test.do_send_receive(sock, subscribe_packet, suback_packet, "suback") helper = mosq_test.do_client_connect(helper_connect, helper_connack, timeout=20, port=port) mosq_test.do_send_receive(helper, publish1s_packet, puback1s_packet, "puback 1s") helper.close() if mosq_test.expect_packet(sock, "publish 1r", publish1r_packet): sock.send(pubcomp1r_packet) sock.send(pingreq_packet) p = sock.recv(len(pingresp_packet)) if len(p) == 0: rc = 0
import mosq_test rc = 1 mid = 3 keepalive = 60 connect_packet = mosq_test.gen_connect("unsubscribe-invalid-no-topic-test", keepalive=keepalive, proto_ver=4) connack_packet = mosq_test.gen_connack(rc=0) unsubscribe_packet = gen_unsubscribe_invalid_no_topic(mid) port = mosq_test.get_port() broker = mosq_test.start_broker(filename=os.path.basename(__file__), port=port) try: sock = mosq_test.do_client_connect(connect_packet, connack_packet, port=port) mosq_test.do_send_receive(sock, unsubscribe_packet, "", "disconnect") rc = 0 sock.close() finally: broker.terminate() broker.wait() (stdo, stde) = broker.communicate() if rc: print(stde) exit(rc)
import mosq_test rc = 1 mid = 79 keepalive = 60 connect_packet = mosq_test.gen_connect("unsubscribe-qos1-test", keepalive=keepalive) connack_packet = mosq_test.gen_connack(rc=0) unsubscribe_packet = mosq_test.gen_unsubscribe(mid, "qos1/test") unsuback_packet = mosq_test.gen_unsuback(mid) port = mosq_test.get_port() broker = mosq_test.start_broker(filename=os.path.basename(__file__), port=port) try: sock = mosq_test.do_client_connect(connect_packet, connack_packet, port=port) mosq_test.do_send_receive(sock, unsubscribe_packet, unsuback_packet, "unsuback") rc = 0 sock.close() finally: broker.terminate() broker.wait() (stdo, stde) = broker.communicate() if rc: print(stde) exit(rc)
mid=1 subscribe_packet = mosq_test.gen_subscribe(mid, "flipflop/test", 1) suback_packet = mosq_test.gen_suback(mid, 1) mid=1 publish_packet = mosq_test.gen_publish("flipflop/test", qos=1, mid=mid, payload="message") puback_packet = mosq_test.gen_puback(mid) port = mosq_test.get_port() broker = mosq_test.start_broker(filename=os.path.basename(__file__), port=port) try: # mosquitto_sub -i sub -t 'topic' -q 1 -d -c sub_sock = mosq_test.do_client_connect(connect_packet_sub_persistent, connack_packet_sub, port=port) mosq_test.do_send_receive(sub_sock, subscribe_packet, suback_packet, "subscribe persistent 1") # And disconnect sub_sock.close() # mosquitto_sub -i sub -t 'topic' -q 1 -d sub_sock = mosq_test.do_client_connect(connect_packet_sub_clean, connack_packet_sub, port=port) mosq_test.do_send_receive(sub_sock, subscribe_packet, suback_packet, "subscribe clean") # And disconnect sub_sock.close() # mosquitto_sub -i sub -t 'topic' -v -q 1 -d -c sub_sock = mosq_test.do_client_connect(connect_packet_sub_persistent, connack_packet_sub, port=port) mosq_test.do_send_receive(sub_sock, subscribe_packet, suback_packet, "subscribe persistent 2") # and in a separate shell #
mid = 3266 publish2_packet = mosq_test.gen_publish("qos1/outgoing", qos=1, mid=mid, payload="outgoing-message") puback2_packet = mosq_test.gen_puback(mid) port = mosq_test.get_port() broker = mosq_test.start_broker(filename=os.path.basename(__file__), port=port) try: sock = mosq_test.do_client_connect(connect_packet, connack1_packet, port=port) mosq_test.do_send_receive(sock, subscribe_packet, suback_packet, "suback") pub = subprocess.Popen( ['./03-publish-b2c-disconnect-qos2-helper.py', str(port)], stdout=subprocess.PIPE, stderr=subprocess.PIPE) hrc = pub.wait() (stdo, stde) = pub.communicate() if hrc: exit(hrc) # Should have now received a publish command if mosq_test.expect_packet(sock, "publish", publish_packet): # Send our outgoing message. When we disconnect the broker # should get rid of it and assume we're going to retry.
mid = 300 publish_packet = mosq_test.gen_publish("subpub/qos1", qos=1, mid=mid, payload="message") puback_packet = mosq_test.gen_puback(mid) mid = 1 publish_packet2 = mosq_test.gen_publish("subpub/qos1", qos=1, mid=mid, payload="message") port = mosq_test.get_port() broker = mosq_test.start_broker(filename=os.path.basename(__file__), port=port) try: sock = mosq_test.do_client_connect(connect_packet, connack_packet, timeout=20, port=port) mosq_test.do_send_receive(sock, subscribe_packet, suback_packet, "suback") mosq_test.do_send_receive(sock, publish_packet, puback_packet, "puback") if mosq_test.expect_packet(sock, "publish2", publish_packet2): rc = 0 sock.close() finally: broker.terminate() broker.wait() (stdo, stde) = broker.communicate() if rc: print(stde) exit(rc)
publish1s_packet = mosq_test.gen_publish("subpub/qos1", qos=1, mid=mid, payload="message") puback1s_packet = mosq_test.gen_puback(mid) mid = 1 publish1r_packet = mosq_test.gen_publish("subpub/qos1", qos=1, mid=mid, payload="message") pubrec1r_packet = mosq_test.gen_pubrec(mid) pingreq_packet = mosq_test.gen_pingreq() pingresp_packet = mosq_test.gen_pingresp() port = mosq_test.get_port() broker = mosq_test.start_broker(filename=os.path.basename(__file__), port=port) try: sock = mosq_test.do_client_connect(connect_packet, connack_packet, timeout=20, port=port) mosq_test.do_send_receive(sock, subscribe_packet, suback_packet, "suback") helper = mosq_test.do_client_connect(helper_connect, helper_connack, timeout=20, port=port) mosq_test.do_send_receive(helper, publish1s_packet, puback1s_packet, "puback 1s") helper.close() if mosq_test.expect_packet(sock, "publish 1r", publish1r_packet): sock.send(pubrec1r_packet) sock.send(pingreq_packet) p = sock.recv(len(pingresp_packet)) if len(p) == 0: rc = 0 sock.close() finally: broker.terminate()
def pattern_test(sub_topic, pub_topic): rc = 1 keepalive = 60 connect_packet = mosq_test.gen_connect("pattern-sub-test", keepalive=keepalive) connack_packet = mosq_test.gen_connack(rc=0) publish_packet = mosq_test.gen_publish(pub_topic, qos=0, payload="message") publish_retained_packet = mosq_test.gen_publish(pub_topic, qos=0, retain=True, payload="message") mid = 312 subscribe_packet = mosq_test.gen_subscribe(mid, sub_topic, 0) suback_packet = mosq_test.gen_suback(mid, 0) mid = 234 unsubscribe_packet = mosq_test.gen_unsubscribe(mid, sub_topic) unsuback_packet = mosq_test.gen_unsuback(mid) port = mosq_test.get_port() broker = subprocess.Popen( ['../../src/mosquitto', '-p', str(port)], stdout=subprocess.PIPE, stderr=subprocess.PIPE) try: time.sleep(0.5) sock = mosq_test.do_client_connect(connect_packet, connack_packet, timeout=20, port=port) mosq_test.do_send_receive(sock, subscribe_packet, suback_packet, "suback") pub = subprocess.Popen( ['./03-pattern-matching-helper.py', pub_topic, str(port)], stdout=subprocess.PIPE, stderr=subprocess.PIPE) pub.wait() (stdo, stde) = pub.communicate() if mosq_test.expect_packet(sock, "publish", publish_packet): mosq_test.do_send_receive(sock, unsubscribe_packet, unsuback_packet, "unsuback") mosq_test.do_send_receive(sock, subscribe_packet, suback_packet, "suback") if mosq_test.expect_packet(sock, "publish retained", publish_retained_packet): rc = 0 sock.close() finally: broker.terminate() broker.wait() (stdo, stde) = broker.communicate() if rc: print(stde) print(stdo) raise return rc
mid = 1 publish_packet = mosq_test.gen_publish("qos1/disconnect/test", qos=1, mid=mid, payload="disconnect-message") publish_dup_packet = mosq_test.gen_publish("qos1/disconnect/test", qos=1, mid=mid, payload="disconnect-message", dup=True) puback_packet = mosq_test.gen_puback(mid) mid = 3266 publish2_packet = mosq_test.gen_publish("qos1/outgoing", qos=1, mid=mid, payload="outgoing-message") puback2_packet = mosq_test.gen_puback(mid) broker = mosq_test.start_broker(filename=os.path.basename(__file__), port=port) try: sock = mosq_test.do_client_connect(connect_packet, connack1_packet, port=port) mosq_test.do_send_receive(sock, subscribe_packet, suback_packet, "suback") pub = subprocess.Popen(['./03-publish-b2c-disconnect-qos1-helper.py', str(port)], stdout=subprocess.PIPE, stderr=subprocess.PIPE) pub.wait() (stdo, stde) = pub.communicate() # Should have now received a publish command if mosq_test.expect_packet(sock, "publish", publish_packet): # Send our outgoing message. When we disconnect the broker # should get rid of it and assume we're going to retry. sock.send(publish2_packet) sock.close() sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) sock.settimeout(60) # 60 seconds timeout is much longer than 5 seconds message retry. sock.connect(("localhost", port))
ssock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) ssock.settimeout(40) ssock.bind(('', port1)) ssock.listen(5) write_config1(conf_file, persistence_file, port1, port2) broker = mosq_test.start_broker(filename=os.path.basename(__file__), port=port2, use_conf=True) try: client = mosq_test.do_client_connect(c_connect_packet, c_connack_packet, timeout=20, port=port2) mosq_test.do_send_receive(client, publish_packet, puback_packet, "puback") client.close() broker.terminate() broker.wait() # Restart, with retained message in place write_config2(conf_file, persistence_file, port1, port2) broker = mosq_test.start_broker(filename=os.path.basename(__file__), port=port2, use_conf=True) (bridge, address) = ssock.accept() bridge.settimeout(20) if mosq_test.expect_packet(bridge, "connect", connect_packet):