def send_websocket_err_msg(self, grpc_call, user_msg='', pipeline_id=None):
"""Send an error messsage over websockets"""
assert grpc_call, 'grpc_call is required'
if pipeline_id:
user_msg = '%s error; pipeline %s: %s' % \
(grpc_call,
pipeline_id,
user_msg)
else:
user_msg = '%s error: %s' % \
(grpc_call,
user_msg)
# Send Websocket message
#
ws_msg = WebsocketMessage.get_fail_message(grpc_call, user_msg)
ws_msg.send_message(self.websocket_id)
# Log it
#
#LOGGER.info('SearchSolutionsHelper: %s', user_msg)
# Add error to class
#
self.add_err_msg(user_msg)
def make_produce_solution_call(pipeline_id, websocket_id, user_id, produce_params, **kwargs):
"""Celery task to make TA2 calls for:
ProduceSolution and GetProduceSolutionResults"""
assert pipeline_id, "pipeline_id must be set"
assert websocket_id, "websocket_id must be set"
assert user_id, "user_id must be set"
assert produce_params, "produce_params must be set"
produce_helper = ProduceSolutionHelper(\
pipeline_id, websocket_id,
user_id, produce_params, **kwargs)
print('produce 1')
if produce_helper.has_error():
user_msg = ('ProduceSolution failure for pipeline (%s): %s') % \
(pipeline_id, produce_helper.get_error_message())
ws_msg = WebsocketMessage.get_fail_message(\
ta2_static.PRODUCE_SOLUTION, user_msg)
ws_msg.send_message(websocket_id)
LOGGER.info('ProduceSolutionHelper: %s', user_msg)
return
LOGGER.info('ProduceSolutionHelper: OK!')
print('produce 2')
produce_helper.run_process()
def send_websocket_err_msg(self, grpc_call, user_msg=''):
"""Send an error messsage over websockets"""
assert grpc_call, 'grpc_call is required'
user_msg = '%s error; pipeline %s; dataset %s: %s' % \
(grpc_call,
self.pipeline_id,
self.produce_dataset_name,
user_msg)
# ----------------------------------
# Send Websocket message
# ----------------------------------
ws_msg = WebsocketMessage.get_fail_message(grpc_call, user_msg)
ws_msg.send_message(self.websocket_id)
# ----------------------------------
# Log it
# ----------------------------------
LOGGER.info('ProduceSolutionHelper: %s', user_msg)
# ----------------------------------
# Add error message to class
# ----------------------------------
self.add_err_msg(user_msg)
def make_score_solutions_call(pipeline_id, websocket_id, user_id,
score_params, **kwargs):
print('make_score_solutions_call 1')
assert pipeline_id, "pipeline_id must be set"
assert websocket_id, "websocket_id must be set"
assert user_id, "user_id must be set"
assert score_params, "score_params must be set"
score_helper = ScoreSolutionHelper(pipeline_id, websocket_id, user_id,
score_params, **kwargs)
if score_helper.has_error():
user_msg = ('ScoreSolution failure for pipeline (%s): %s') % \
(pipeline_id, score_helper.get_error_message())
ws_msg = WebsocketMessage.get_fail_message(\
ta2_static.SCORE_SOLUTION, user_msg)
ws_msg.send_message(websocket_id)
LOGGER.error(user_msg)
return
score_helper.run_process()
def add_err_msg(self, user_msg):
"""Add to base base "add_err_msg", also send a websocket message"""
# call the base "add_err_msg"
#
super().add_err_msg(user_msg)
if not self.websocket_id:
return
user_msg = '%s (datamart augment)' % \
(user_msg,)
# ----------------------------------
# Send Websocket message
# ----------------------------------
ws_msg = WebsocketMessage.get_fail_message(
dm_static.DATAMART_AUGMENT_PROCESS, user_msg)
print('send to websocket id: %s' % self.websocket_id)
ws_msg.send_message(self.websocket_id)
# ----------------------------------
# Log it
# ----------------------------------
LOGGER.info('WebsocketMessage: %s', user_msg)
def send_websocket_err_msg(self, user_msg):
"""Send an error messsage over websockets"""
# ----------------------------------
# Add error message to class
# ----------------------------------
self.add_err_msg(user_msg)
if not self.websocket_id:
return
user_msg = '%s (datamart augment)' % \
(user_msg,)
# ----------------------------------
# Send Websocket message
# ----------------------------------
ws_msg = WebsocketMessage.get_fail_message(DATAMART_AUGMENT_PROCESS,
user_msg)
ws_msg.send_message(self.websocket_id)
# ----------------------------------
# Log it
# ----------------------------------
LOGGER.info('WebsocketMessage: %s', user_msg)
def stream_and_store_results(raven_json_str, stored_request_id,
grpc_req_obj_name, grpc_call_name, **kwargs):
"""Make the grpc call which has a streaming response
grpc_req_obj_name: "core_pb2.GetSearchSolutionsResultsRequest", etc
grpc_call_name: "GetSearchSolutionsResults", etc
"""
core_stub, err_msg = TA2Connection.get_grpc_stub()
if err_msg:
StoredRequestUtil.set_error_status(stored_request_id, err_msg)
return
# optional: used to stream messages back to client via channels
#
websocket_id = kwargs.get('websocket_id', None)
#
grpc_req_obj = eval(grpc_req_obj_name)
grpc_rpc_call_function = eval('core_stub.%s' % grpc_call_name)
# --------------------------------
# convert the JSON string to a gRPC request
# Yes: done for the 2nd time
# --------------------------------
try:
req = Parse(raven_json_str, grpc_req_obj())
except ParseError as err_obj:
err_msg = 'Failed to convert JSON to gRPC: %s' % (err_obj)
StoredRequestUtil.set_error_status(stored_request_id, err_msg)
return
# --------------------------------
# Send the gRPC request
# --------------------------------
msg_cnt = 0
try:
# -----------------------------------------
# Iterate through the streaming responses
# -----------------------------------------
for reply in grpc_rpc_call_function(\
req, timeout=settings.TA2_GRPC_LONG_TIMEOUT):
msg_cnt += 1
stored_resp = None # to hold a StoredResponse object
# -----------------------------------------
# parse the response
# -----------------------------------------
msg_json_str = message_to_json(reply)
msg_json_info = json_loads(msg_json_str)
# -----------------------------------------
# does it look ok?
# -----------------------------------------
if not msg_json_info.success:
print('PROBLEM HERE TO LOG!')
user_msg = 'failed to store response: %s' % \
msg_json_info.err_msg
ws_msg = WebsocketMessage.get_fail_message(\
grpc_call_name, user_msg, msg_cnt=msg_cnt)
ws_msg.send_message(websocket_id)
continue
# -----------------------------------------
# Looks good, save the response
# -----------------------------------------
stored_resp_info = StoredResponse.add_response(\
stored_request_id,
response=msg_json_info.result_obj)
# -----------------------------------------
# Make sure the response was saved (probably won't happen)
# -----------------------------------------
if not stored_resp_info.success:
# Not good but probably won't happen
# send a message to the user...
#
user_msg = 'failed to store response: %s' % \
msg_json_info.err_msg
ws_msg = WebsocketMessage.get_fail_message(\
grpc_call_name, user_msg, msg_cnt=msg_cnt)
ws_msg.send_message(websocket_id)
# Wait for the next response...
continue
# -----------------------------------------------
# send responses back to any open WebSockets
# ---------------------------------------------
if websocket_id:
stored_resp = stored_resp_info.result_obj
ws_msg = WebsocketMessage.get_success_message(\
grpc_call_name,
'it worked',
msg_cnt=msg_cnt,
data=stored_resp.as_dict())
print('ws_msg: %s' % ws_msg)
#print('ws_msg', ws_msg.as_dict())
ws_msg.send_message(websocket_id)
StoredResponse.mark_as_read(stored_resp)
# -----------------------------------------------
print('msg received #%d' % msg_cnt)
except grpc.RpcError as err_obj:
StoredRequestUtil.set_error_status(\
stored_request_id,
str(err_obj))
return
#except Exception as err_obj:
# StoredRequestUtil.set_error_status(\
# stored_request_id,
# str(err_obj))
# return
StoredRequestUtil.set_finished_ok_status(stored_request_id)