def handle_control_message(self, socket):
"""Handle a control message on the given socket
Args:
socket(zmq.Socket): The socket to receive a message and reply on
"""
message_handlers = {
"status": self.status,
"configure": self.configure,
"request_configuration": self.request_configuration,
"request_version": self.version,
"shutdown": self.shutdown,
}
# The first message part is a channel ID
channel_id = socket.recv()
# The second message part is the IpcMessage
message = IpcMessage(from_str=socket.recv())
request_type = message.get_msg_val()
handler = message_handlers.get(request_type, None)
if handler is not None:
reply = handler(message)
else:
error = "Unknown request type: {}".format(request_type)
self._logger.error(error)
reply = self._construct_reply(
message.get_msg_val(), message.get_msg_id(), error
)
socket.send(channel_id, zmq.SNDMORE)
socket.send(reply.encode())
def _send_message(self, msg, timeout):
msg.set_msg_id(self.message_id)
self.message_id = (self.message_id + 1) % self.MESSAGE_ID_MAX
self.logger.debug("Sending control message:\n%s", msg.encode())
with self._lock:
self.ctrl_channel.send(msg.encode())
expected_id = msg.get_msg_id()
id = None
while not id == expected_id:
pollevts = self.ctrl_channel.poll(timeout)
if pollevts == zmq.POLLIN:
reply = IpcMessage(from_str=self.ctrl_channel.recv())
id = reply.get_msg_id()
if not id == expected_id:
self.logger.warn("Dropping reply message with id [" +
str(id) + "] as was expecting [" +
str(expected_id) + "]")
continue
if reply.is_valid() and reply.get_msg_type(
) == IpcMessage.ACK:
self.logger.debug("Request successful: %s", reply)
return True, reply.attrs
else:
self.logger.debug("Request unsuccessful")
return False, reply.attrs
else:
self.logger.warning("Received no response")
return False, None
def test_round_trip_from_empty_msg():
# Instantiate an empty message
the_msg = IpcMessage()
# Set the message type and value
msg_type = "cmd"
the_msg.set_msg_type(msg_type)
msg_val = "reset"
the_msg.set_msg_val(msg_val)
msg_id = 61616
the_msg.set_msg_id(msg_id)
# Define and set some parameters
paramInt1 = 1234;
paramInt2 = 901201;
paramInt3 = 4567;
paramStr = "paramString"
the_msg.set_param('paramInt1', paramInt1)
the_msg.set_param('paramInt2', paramInt2)
the_msg.set_param('paramInt3', paramInt3)
the_msg.set_param('paramStr', paramStr)
# Retrieve the encoded version
the_msg_encoded = the_msg.encode()
# Create another message from the encoded version
msg_from_encoded = IpcMessage(from_str=the_msg_encoded)
# Validate the contents of all attributes and parameters of the new message
assert_equal(msg_from_encoded.get_msg_type(), msg_type)
assert_equal(msg_from_encoded.get_msg_val(), msg_val)
assert_equal(msg_from_encoded.get_msg_timestamp(), the_msg.get_msg_timestamp())
assert_equal(msg_from_encoded.get_msg_id(), the_msg.get_msg_id())
assert_equal(msg_from_encoded.get_param('paramInt1'), paramInt1)
assert_equal(msg_from_encoded.get_param('paramInt2'), paramInt2)
assert_equal(msg_from_encoded.get_param('paramInt3'), paramInt3)
assert_equal(msg_from_encoded.get_param('paramStr'), paramStr)
def test_valid_ipc_msg_from_string():
# Instantiate a valid message from a JSON string
json_str = """
{\"msg_type\":\"cmd\",
\"msg_val\":\"status\",
\"timestamp\" : \"2015-01-27T15:26:01.123456\",
\"id\":322,
\"params\" : {
\"paramInt\" : 1234,
\"paramStr\" : \"testParam\",
\"paramDouble\" : 3.1415
}
}
"""
# Instantiate a valid message from the JSON string
the_msg = IpcMessage(from_str=json_str)
# Check the message is indeed valid
assert_true(the_msg.is_valid())
# Check that all attributes are as expected
assert_equals(the_msg.get_msg_type(), "cmd")
assert_equals(the_msg.get_msg_val(), "status")
assert_equals(the_msg.get_msg_timestamp(), "2015-01-27T15:26:01.123456")
assert_equals(the_msg.get_msg_id(), 322)
# Check that all parameters are as expected
assert_equals(the_msg.get_param("paramInt"), 1234)
assert_equals(the_msg.get_param("paramStr"), "testParam")
assert_equals(the_msg.get_param("paramDouble"), 3.1415)
# Check valid message throws an exception on missing parameter
with assert_raises(IpcMessageException) as cm:
missingParam = the_msg.get_param("missingParam")
ex = cm.exception
assert_equals(ex.msg, 'Missing parameter missingParam')
# Check valid message can fall back to default value if parameter missing
defaultParamValue = 90210
assert_equals(the_msg.get_param("missingParam", defaultParamValue), defaultParamValue)
def handle_control_message(self, receiver):
"""Handle control message.
:param: receiver: ZeroMQ channel to receive message from
"""
channel_id = receiver.recv()
message_val = ""
message_id = 0
try:
message = IpcMessage(from_str=receiver.recv())
message_val = message.get_msg_val()
message_id = message.get_msg_id()
if message.get_msg_val() == 'status':
reply = self.handle_status_message(message_id)
elif message.get_msg_val() == 'request_configuration':
reply = self.handle_request_config_message(message_id)
elif message.get_msg_val() == 'request_version':
reply = self.handle_request_version_message(message_id)
elif message.get_msg_val() == 'configure':
self.logger.debug('handling control configure message')
self.logger.debug(message)
params = message.attrs['params']
reply = self.handle_configure_message(params, message_id)
else:
reply = IpcMessage(IpcMessage.NACK, message_val, id=message_id)
reply.set_param('error', 'Unknown message value type')
except Exception as err:
self.logger.error(
'Unexpected Exception handling control message: ' + str(err))
reply = IpcMessage(IpcMessage.NACK, message_val, id=message_id)
reply.set_param('error', 'Error processing control message')
receiver.send(channel_id, zmq.SNDMORE)
receiver.send(reply.encode())