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):
