def _handle_custom_message(self, message, response_message_id_supplier,
response_consumer, result_consumer, workspace):
response_message_id = response_message_id_supplier()
try:
debug_msg("Python - Respond to message: " + str(message))
response = self._respond(message, response_message_id, workspace)
debug_msg("Python - Responded to message: " + str(message) +
", response: " + str(response))
response_consumer[0] = response
except Exception as ex:
error_message = str(ex)
debug_msg(error_message, exc_info=True)
# Message format: Error message, pretty traceback, number of traceback elements (frames), list of frames
# where each frame is of the form: filename, line number, name, line.
error_pretty_traceback = traceback.format_exc()
error_traceback_frames = traceback.extract_tb(sys.exc_info()[2])
error_payload = PayloadEncoder().put_string(
error_message).put_string(error_pretty_traceback).put_int(
len(error_traceback_frames))
for frame in reversed(error_traceback_frames):
error_payload.put_string(frame[0]).put_int(
frame[1]).put_string(frame[2]).put_string(frame[3])
error_payload = error_payload.payload
# Inform Java that handling the request did not work.
error_response = AbstractRequestHandler._create_response(
message,
response_message_id,
success=False,
response_payload=error_payload)
response_consumer[0] = error_response
result_consumer(
None
) # We are done after the response (either success or failure) is sent.
return True
def _handle_custom_message(self, message, response_message_id_supplier,
response_consumer, result_consumer, workspace):
response_message_id = response_message_id_supplier()
try:
debug_msg("Python - Respond to message: " + str(message))
response = self._respond(message, response_message_id, workspace)
debug_msg("Python - Responded to message: " + str(message) +
", response: " + str(response))
response_consumer[0] = response
except Exception as ex:
error_message = str(ex)
debug_msg(error_message, exc_info=True)
error_traceback = traceback.format_exc()
error_payload = PayloadEncoder().put_string(
error_message).put_string(error_traceback).payload
# Inform Java that handling the request did not work.
error_response = AbstractRequestHandler._create_response(
message,
response_message_id,
success=False,
response_payload=error_payload)
response_consumer[0] = error_response
result_consumer(
None
) # We are done after the response (either success or failure) is sent.
return True
def _handle_custom_message(self, message, response_message_id_supplier, response_consumer, result_consumer,
workspace):
if message.category == "my-nested-request-from-java":
request_message_type = "first-request"
response_payload = None
else:
message_type = message.get_header_field(AbstractTaskHandler.FIELD_KEY_MESSAGE_TYPE)
if message_type == "first":
self._response_string_payload += PayloadDecoder(message.payload).get_next_string()
request_message_type = "second-request"
response_payload = None
elif message_type == "second":
workspace.unregister_task_handler("my-nested-request-from-java")
result_consumer(None)
self._response_string_payload += PayloadDecoder(message.payload).get_next_string()
request_message_type = AbstractTaskHandler.MESSAGE_TYPE_SUCCESS
response_payload = PayloadEncoder().put_string(self._response_string_payload).payload
else:
error_message = "Message type '" + message_type + "' is not recognized. Illegal state."
debug_util.debug_msg(error_message)
raise RuntimeError(error_message)
response_consumer[0] = Message(workspace._commands._messaging.create_next_message_id(), str(message.id),
payload=response_payload,
additional_options={AbstractTaskHandler.FIELD_KEY_MESSAGE_TYPE:
request_message_type})
return True
def resolve_knime_url(self, url):
"""
:param url: File must exist as Java side tries to download remote files to a temporary location.
"""
payload = PayloadEncoder().put_string(url).payload
return self.create_task(
PythonCommands._ResolveKnimeUrlTaskHandler(),
Message(self._messaging.create_next_message_id(),
"resolve_knime_url", payload))
def _respond(self, request, response_message_id, workspace):
source_code = PayloadDecoder(request.payload).get_next_string()
debug_msg('Executing:\n' + source_code)
output, error = workspace.execute(source_code, request.id)
debug_msg('Execution done.')
response_payload = PayloadEncoder().put_string(output).put_string(
error).payload
return AbstractRequestHandler._create_response(
request, response_message_id, response_payload=response_payload)
def _respond(self, request, response_message_id, workspace):
source_code = PayloadDecoder(request.payload).get_next_string()
debug_msg('Executing:\n' + source_code + '\n')
output, error = workspace.execute(source_code, request.id)
if error:
debug_msg('Error during execution. Message: \'' + error + '\'', exc_info=True)
else:
debug_msg('Execution done.')
response_payload = PayloadEncoder().put_string(output).put_string(error).payload
return AbstractRequestHandler._create_response(request, response_message_id, response_payload=response_payload)
def _create_string_payload(value):
return PayloadEncoder().put_string(value).payload
def _create_int_payload(value):
return PayloadEncoder().put_int(value).payload
def _create_byte_array_payload(value):
return PayloadEncoder().put_bytes(value).payload
def request_deserializer(self, id):
payload = PayloadEncoder().put_string(id).payload
return self.create_task(PythonCommands._DeserializerRequestTaskHandler(),
Message(self._messaging.create_next_message_id(), "deserializer_request", payload))
def _respond(self, request, response_message_id, workspace):
workspace.unregister_task_handler("my-request-from-java")
payload = PayloadEncoder().put_string("my-response-from-python").payload
return AbstractRequestHandler._create_response(request, response_message_id, response_payload=payload)
def _respond(self, request, response_message_id, workspace):
workspace.unregister_task_handler("my-request-from-java-that-causes-a-request-from-python")
result_from_request = trigger_request_from_python(workspace)
payload = PayloadEncoder().put_string(result_from_request + "-made-the-task-succeed").payload
return AbstractRequestHandler._create_response(request, response_message_id, True, payload)
def _create_message(self, message_category, payload=None):
payload = PayloadEncoder().put_string(str(payload)).payload if payload is not None else None
return Message(self._message_id_supplier(), self._reply_to, payload,
{AbstractTaskHandler.FIELD_KEY_MESSAGE_TYPE: message_category})
