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_send_rcv_subid_good():
"""
test send and receive where subid is used for routing
"""
pay = b"\x01\x00\x80"
test_mtype = 46656
test_subid = 777
# send a message
sbuf_send = rmr.rmr_alloc_msg(MRC_SEND,
3,
pay,
mtype=test_mtype,
sub_id=test_subid)
pre_send_summary = rmr.message_summary(sbuf_send)
sbuf_send = rmr.rmr_send_msg(MRC_SEND, sbuf_send)
send_summary = rmr.message_summary(sbuf_send)
# receive it in other context
time.sleep(0.5)
sbuf_rcv = rmr.rmr_alloc_msg(MRC_RCV, 3)
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_STATUS] == rcv_summary[
rmr.RMR_MS_MSG_STATUS] == "RMR_OK"
assert pre_send_summary[rmr.RMR_MS_PAYLOAD] == rcv_summary[
rmr.RMR_MS_PAYLOAD] == pay
assert pre_send_summary[rmr.RMR_MS_MSG_TYPE] == rcv_summary[
rmr.RMR_MS_MSG_TYPE] == test_mtype
assert pre_send_summary[rmr.RMR_MS_SUB_ID] == rcv_summary[
rmr.RMR_MS_SUB_ID] == test_subid
def rmr_send(self, payload, mtype, retries=100):
"""
Allocates a buffer, sets payload and mtype, and sends
Parameters
----------
payload: bytes
payload to set
mtype: int
message type
retries: int (optional)
Number of times to retry at the application level before excepting RMRFailure
Returns
-------
bool
whether or not the send worked after retries attempts
"""
sbuf = rmr.rmr_alloc_msg(vctx=self._mrc,
size=len(payload),
payload=payload,
gen_transaction_id=True,
mtype=mtype)
for _ in range(retries):
sbuf = rmr.rmr_send_msg(self._mrc, sbuf)
if sbuf.contents.state == 0:
self.rmr_free(sbuf)
return True
self.rmr_free(sbuf)
return False
def test_send_rcv_subid_bad_mtype():
"""
test send and receive where subid is used for routing but nobody receives this mtype
"""
sbuf_send = rmr.rmr_alloc_msg(MRC_SEND,
3,
b"\x01\x00\x80",
mtype=46657,
sub_id=777)
sbuf_send = rmr.rmr_send_msg(MRC_SEND, sbuf_send)
assert rmr.message_summary(sbuf_send)[
rmr.RMR_MS_MSG_STATE] == rmr.RMR_ERR_NOENDPT
assert rmr.message_summary(sbuf_send)[
rmr.RMR_MS_MSG_STATUS] == "RMR_ERR_NOENDPT"
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 _send_msg(self, pay, mtype, subid):
"""
Creates and sends a message via RMR's send-message feature with the specified payload
using the specified message type and subscription ID.
"""
sbuf = rmr.rmr_alloc_msg(self.mrc, len(pay), payload=pay, gen_transaction_id=True, mtype=mtype, sub_id=subid)
sbuf.contents.sub_id = subid
pre_send_summary = rmr.message_summary(sbuf)
for _ in range(0, RETRY_TIMES):
mdc_logger.debug("_send_msg: sending: {}".format(pre_send_summary))
sbuf = rmr.rmr_send_msg(self.mrc, sbuf)
msg_state = self._assert_good_send(sbuf, pre_send_summary)
mdc_logger.debug("_send_msg: result message state: {}".format(msg_state))
if msg_state != rmr.RMR_ERR_RETRY:
break
rmr.rmr_free_msg(sbuf)
if msg_state != rmr.RMR_OK:
mdc_logger.warning("_send_msg: failed after {} retries".format(RETRY_TIMES))
def send_report(self, msg: MetricsReport):
"""
Serializes the MetricsReport dict to JSON and sends the result via RMR.
Raises an exception if the report has no MetricsData items.
Parameters
----------
msg: MetricsReport (required)
Dictionary with measurement data to encode and send
Returns
-------
bool
True if the send succeeded (possibly with retries), False otherwise
"""
if KEY_DATA not in msg or len(msg[KEY_DATA]) == 0:
raise EmptyReport
payload = json.dumps(msg).encode()
mdc_logger.debug("send_report: payload is {}".format(payload))
sbuf = rmr.rmr_alloc_msg(vctx=self.vctx,
size=len(payload),
payload=payload,
mtype=RIC_METRICS,
gen_transaction_id=True)
for _ in range(0, RETRIES):
sbuf = rmr.rmr_send_msg(self.vctx, sbuf)
post_send_summary = rmr.message_summary(sbuf)
mdc_logger.debug("send_report: try {0} result is {1}".format(
_, post_send_summary[rmr.RMR_MS_MSG_STATE]))
# stop trying if RMR does not indicate retry
if post_send_summary[rmr.RMR_MS_MSG_STATE] != rmr.RMR_ERR_RETRY:
break
rmr.rmr_free_msg(sbuf)
if post_send_summary[rmr.RMR_MS_MSG_STATE] != rmr.RMR_OK:
mdc_logger.warning(
"send_report: failed after {} retries".format(RETRIES))
return False
return True
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))
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)