def send_burst(mrc, fmt, mtype=1, num=13, counter=0):
"""
Internal function to support test_rcv_all.
Send a burst of messages optionally giving the type, payload
and number to send.
"""
sbuf_send = rmr.rmr_alloc_msg(MRC_SEND, SIZE) # seed message buffer
for i in range(num):
payload = bytes(fmt % counter, "UTF-8")
counter += 1
rmr.set_payload_and_length(payload, sbuf_send)
sbuf_send.contents.mtype = mtype
max_retries = 5
while max_retries > 0:
sbuf_send = rmr.rmr_send_msg(mrc, sbuf_send)
ms = rmr.message_summary(sbuf_send)
if ms[rmr.RMR_MS_MSG_STATE] != rmr.RMR_ERR_RETRY:
break
max_retries -= 1
time.sleep(0.75)
assert ms[rmr.RMR_MS_MSG_STATE] == rmr.RMR_OK
assert max_retries > 0
def test_rmr_set_get():
"""
test set functions
"""
sbuf = rmr.rmr_alloc_msg(MRC_SEND, SIZE)
_assert_new_sbuf(sbuf)
# test payload
pay = b"\x01\x00\x80"
rmr.set_payload_and_length(pay, sbuf)
summary = rmr.message_summary(sbuf)
assert summary[rmr.RMR_MS_PAYLOAD] == pay
assert summary[rmr.RMR_MS_PAYLOAD_LEN] == 3
# test transid (note we cant test payload because it's randomly gen)
assert summary[rmr.RMR_MS_TRN_ID] == b""
assert len(summary[rmr.RMR_MS_TRN_ID]) == 0
rmr.generate_and_set_transaction_id(sbuf)
summary = rmr.message_summary(sbuf)
assert summary[rmr.RMR_MS_TRN_ID] != b""
assert len(summary[rmr.RMR_MS_TRN_ID]) == 32
# test meid
assert rmr.rmr_get_meid(sbuf) == summary[rmr.RMR_MS_MEID] == b""
rmr.rmr_set_meid(sbuf, b"666\x01\x00\x01")
summary = rmr.message_summary(sbuf)
assert rmr.rmr_get_meid(sbuf) == summary[rmr.RMR_MS_MEID] == b"666\x01"
assert (len(summary[rmr.RMR_MS_MEID])) == 4
# exercise the logging setter; cannot test the result
rmr.rmr_set_vlevel(0)
def test_wh():
"""test the ability to send a message directly, without routing, via a wormhole"""
state = rmr.rmr_wh_state(MRC_SEND, 1)
assert state != rmr.RMR_OK
whid = rmr.rmr_wh_open(MRC_SEND, b"127.0.0.1:3563")
assert whid >= 0
state = rmr.rmr_wh_state(MRC_SEND, whid)
assert state == rmr.RMR_OK
sbuf_send = rmr.rmr_alloc_msg(MRC_SEND, SIZE)
_assert_new_sbuf(sbuf_send)
mtype = 1
sbuf_send.contents.mtype = mtype
payload = b"Birds like worms"
rmr.set_payload_and_length(payload, sbuf_send)
send_summary = rmr.message_summary(sbuf_send)
# send via call, but don't wait long for a response
rmr.rmr_wh_call(MRC_SEND, whid, sbuf_send, 1, 100)
# receive message in other context
time.sleep(0.5)
sbuf_rcv = rmr.rmr_alloc_msg(MRC_RCV, SIZE)
sbuf_rcv = rmr.rmr_torcv_msg(MRC_RCV, sbuf_rcv, 2000)
rcv_summary = rmr.message_summary(sbuf_rcv)
# asserts
assert send_summary[rmr.RMR_MS_MSG_STATE] == rcv_summary[
rmr.RMR_MS_MSG_STATE] == rmr.RMR_OK
assert send_summary[rmr.RMR_MS_MSG_TYPE] == rcv_summary[
rmr.RMR_MS_MSG_TYPE] == mtype
assert send_summary[rmr.RMR_MS_PAYLOAD] == rcv_summary[
rmr.RMR_MS_PAYLOAD] == payload
sbuf_send = rmr.rmr_alloc_msg(MRC_SEND, SIZE)
_assert_new_sbuf(sbuf_send)
mtype = 1
sbuf_send.contents.mtype = mtype
payload = b"Birds like worms"
rmr.set_payload_and_length(payload, sbuf_send)
# send without waiting for a response
rmr.rmr_wh_send_msg(MRC_SEND, whid, sbuf_send)
# receive message in other context
time.sleep(0.5)
sbuf_rcv = rmr.rmr_torcv_msg(MRC_RCV, sbuf_rcv, 2000)
rcv_summary = rmr.message_summary(sbuf_rcv)
# asserts
assert send_summary[rmr.RMR_MS_MSG_STATE] == rcv_summary[
rmr.RMR_MS_MSG_STATE] == rmr.RMR_OK
assert send_summary[rmr.RMR_MS_MSG_TYPE] == rcv_summary[
rmr.RMR_MS_MSG_TYPE] == mtype
assert send_summary[rmr.RMR_MS_PAYLOAD] == rcv_summary[
rmr.RMR_MS_PAYLOAD] == payload
rmr.rmr_wh_close(MRC_SEND, whid)
def test_send_rcv():
"""
test send and receive
"""
pay = b"\x01\x00\x80"
# send a message
sbuf_send = rmr.rmr_alloc_msg(MRC_SEND, SIZE)
_assert_new_sbuf(sbuf_send)
rmr.set_payload_and_length(pay, sbuf_send)
sbuf_send.contents.mtype = 0
sbuf_send = rmr.rmr_send_msg(MRC_SEND, sbuf_send)
send_summary = rmr.message_summary(sbuf_send)
assert send_summary[
rmr.
RMR_MS_MSG_STATE] == rmr.RMR_OK # if send fails don't attempt receive
assert send_summary[rmr.RMR_MS_MSG_STATUS] == "RMR_OK"
time.sleep(0.5)
# receive it in other context
sbuf_rcv = rmr.rmr_alloc_msg(MRC_RCV, SIZE)
sbuf_rcv = rmr.rmr_torcv_msg(MRC_RCV, sbuf_rcv, 2000)
rcv_summary = rmr.message_summary(sbuf_rcv)
assert rcv_summary[rmr.RMR_MS_MSG_STATE] == rmr.RMR_OK
assert rcv_summary[rmr.RMR_MS_MSG_STATUS] == "RMR_OK"
assert rcv_summary[rmr.RMR_MS_MSG_TYPE] == 0
assert rcv_summary[rmr.RMR_MS_PAYLOAD] == pay
# send an ACK back
ack_pay = b"message received"
sbuf_rcv = rmr.rmr_rts_msg(MRC_RCV, sbuf_rcv, payload=ack_pay, mtype=6666)
rcv_ack_summary = rmr.message_summary(sbuf_rcv)
# have the sender receive it
sbuf_send = rmr.rmr_torcv_msg(MRC_SEND, sbuf_send, 2000)
send_ack_summary = rmr.message_summary(sbuf_send)
assert send_ack_summary[rmr.RMR_MS_MSG_STATE] == rcv_ack_summary[
rmr.RMR_MS_MSG_STATE] == rmr.RMR_OK
assert send_ack_summary[rmr.RMR_MS_MSG_STATUS] == rcv_ack_summary[
rmr.RMR_MS_MSG_STATUS] == "RMR_OK"
assert send_ack_summary[rmr.RMR_MS_PAYLOAD] == ack_pay
assert send_ack_summary[rmr.RMR_MS_MSG_TYPE] == 6666
def test_send_mock(monkeypatch):
"""
tests the send mock
"""
monkeypatch.setattr("ricxappframe.rmr.rmr.rmr_send_msg",
rmr_mocks.send_mock_generator(12))
rmr_mocks.patch_rmr(monkeypatch)
sbuf = rmr.rmr_alloc_msg(MRC, SIZE)
rmr.set_payload_and_length("testttt".encode("utf8"), sbuf)
expected = {
rmr.RMR_MS_MEID: None,
rmr.RMR_MS_MSG_SOURCE: "localtest:80",
rmr.RMR_MS_MSG_STATE: rmr.RMR_OK,
rmr.RMR_MS_MSG_STATUS: "RMR_OK",
rmr.RMR_MS_MSG_TYPE: 0,
rmr.RMR_MS_PAYLOAD: b"testttt",
rmr.RMR_MS_PAYLOAD_LEN: 7,
rmr.RMR_MS_PAYLOAD_MAX: 4096,
rmr.RMR_MS_SUB_ID: 0,
}
_partial_dict_comparison(expected, rmr.message_summary(sbuf))
# set the mtype
sbuf.contents.mtype = 666
# send it (the fake send sets the state, and touches nothing else)
sbuf = rmr.rmr_send_msg(MRC, sbuf)
expected = {
rmr.RMR_MS_MEID: None,
rmr.RMR_MS_MSG_SOURCE: "localtest:80",
rmr.RMR_MS_MSG_STATE: rmr.RMR_ERR_TIMEOUT,
rmr.RMR_MS_MSG_STATUS: "RMR_ERR_TIMEOUT",
rmr.RMR_MS_MSG_TYPE: 666,
rmr.RMR_MS_PAYLOAD: None,
rmr.RMR_MS_PAYLOAD_LEN: 7,
rmr.RMR_MS_PAYLOAD_MAX: 4096,
rmr.RMR_MS_SUB_ID: 0,
}
_partial_dict_comparison(expected, rmr.message_summary(sbuf))
def test_resize_payload():
"""test the ability to insert a larger payload into an existing message"""
mtype = 99
subid = 100
mbuf = rmr.rmr_alloc_msg(MRC_SEND,
25) # allocate buffer with small payload
mbuf.contents.mtype = mtype # type and sub-id should not change
mbuf.contents.sub_id = subid
long_payload = b"This is a long payload that should force the message buffer to be reallocated"
rmr.set_payload_and_length(long_payload, mbuf)
summary = rmr.message_summary(mbuf)
assert summary[rmr.RMR_MS_PAYLOAD_MAX] >= len(
long_payload) # RMR may allocate a larger payload space
assert summary[rmr.RMR_MS_PAYLOAD_LEN] == len(
long_payload) # however, the length must be exactly the same
assert summary[
rmr.
RMR_MS_MSG_TYPE] == mtype # both mtype and sub-id should be preserved in new
assert summary[rmr.RMR_MS_SUB_ID] == subid
rmr.rmr_set_stimeout(mrc, 2)
sbuf = rmr.rmr_alloc_msg(mrc, 256)
# capture ctrl-c
signal.signal(signal.SIGINT, signal_handler)
while True:
# generate a random value between 1 and 256 bytes, then gen some random bytes with several nulls thrown in
for val in [
"".join([
random.choice(string.ascii_letters + string.digits)
for n in range(random.randint(1, 256))
]).encode("utf8"),
b"\x00" + os.urandom(4) + b"\x00" + os.urandom(4) + b"\x00",
]:
rmr.set_payload_and_length(val, sbuf)
rmr.generate_and_set_transaction_id(sbuf)
sbuf.contents.state = 0
sbuf.contents.mtype = 0
print("Pre send summary: {}".format(rmr.message_summary(sbuf)))
sbuf = rmr.rmr_send_msg(mrc, sbuf)
print("Post send summary: {}".format(rmr.message_summary(sbuf)))
print("Waiting for return, will timeout after 2000ms")
sbuf = rmr.rmr_torcv_msg(mrc, sbuf, 2000)
summary = rmr.message_summary(sbuf)
if summary[rmr.RMR_MS_MSG_STATE] == 12:
print("Nothing received yet")
else:
print("Ack Message received!: {}".format(summary))
time.sleep(1)
