def send(self):
message = PartnerManager._create_send_message()
context = None
try:
business_id, agreement_id, data_dfs_path = self._get_send_request()
agreement = self._get_agreement(agreement_id)
PartnerManager._build_send_message(message, business_id,
data_dfs_path, agreement)
context = AS2Context(agreement, message)
data = self._get_send_data(data_dfs_path)
received_headers, received_body = self._send_data(data, context)
if agreement.outbound_agreement.mdn_mode == MdnMode.sync:
self._receive_sync_mdn(received_headers, received_body,
context)
except:
message.message_status = StatusType.failed
message.memo = str(sys.exc_info()[1])
finally:
if context is not None:
message.message_trace_list = context.trace_info_list
mq_setting = ConfigurationHelper.get_mq_setting(
'outbound_message_queue')
headers = {
'EventMessageKey':
'N/A' if message.key is None else message.key,
'LocalIdentity':
'N/A'
if message.local_identity is None else message.local_identity,
'TradingIdentity':
'N/A' if message.trading_identity is None else
message.trading_identity,
'Version':
'N/A' if message.version is None else message.version
}
self.send_to_message_queue(
mq_setting.queue_name,
mq_setting.password,
message,
headers=headers,
match_tag=mq_setting.serialization_match_tag)
return message
def _receive_async_mdn(self, headers, body, context):
mdn_dfs_name = "{key}.mdn".format(key=str(uuid.uuid4()).upper())
status, url = self._upload_data_to_dfs(mdn_dfs_name, body)
mdn_data_dfs_path = url
message_mdn = AS2MessageMdn(mdn_headers=[
NameValuePair(name=k, value=v) for k, v in headers.items()
],
mdn_data_dfs_path=mdn_data_dfs_path,
mdn_status=StatusType.successful,
direction=DirectionType.inbound,
mdn_mode=MdnMode. async,
in_date=datetime.utcnow(),
edit_date=datetime.utcnow())
mdn_decoder = MdnDecoder(headers, body, MdnMode. async, context)
try:
mdn_validate_result = mdn_decoder.decode()
message_mdn.mdn_validate_status = mdn_validate_result
message_mdn.mdn_message_id = mdn_decoder.mdn_message_id
message_mdn.original_message_id = mdn_decoder.original_message_id
message_mdn.mdn_disposition_mode = mdn_decoder.disposition_mode
message_mdn.mdn_disposition_type = mdn_decoder.disposition_type
message_mdn.mdn_disposition_modifier_code = mdn_decoder.disposition_modifier_code
message_mdn.mdn_disposition_modifier_value = mdn_decoder.disposition_modifier_value
message_mdn.mdn_disposition_description = mdn_decoder.disposition_description
message_mdn.mdn_mic_digest = mdn_decoder.mic_digest
message_mdn.mdn_mic_algorithm = mdn_decoder.mic_algorithm
except:
message_mdn.mdn_message_id = mdn_decoder.mdn_message_id
message_mdn.memo = str(sys.exc_info()[1])
message_mdn.mdn_status = StatusType.failed
message_mdn.mdn_validate_status = StatusType.failed
message_trace_list = context.trace_info_list
message = AsyncMdnReceive(message_mdn=message_mdn,
message_trace_list=message_trace_list)
mq_setting = ConfigurationHelper.get_mq_setting(
'inbound_async_mdn_queue')
PartnerManager.send_to_message_queue(
mq_setting.queue_name,
mq_setting.password,
message,
match_tag=mq_setting.serialization_match_tag)
def get_handlers():
conf = ConfigurationHelper.get_settings()
handler = conf['log_handler'].upper()
handlers = []
for hd in handler.split('|'):
if hd == "CONSOLE":
instance = logging.StreamHandler()
elif hd == "NLOG":
instance = FrameWorkLogHandler()
else:
continue
if instance is not None and conf['log_formatter'] is not None:
instance.setFormatter(logging.Formatter(conf['log_formatter']))
handlers.append(instance)
return handlers
def retry_failed_message(top):
count = 0
conf = ConfigurationHelper.get_settings()
msg_backup_path = os.path.join(conf['app_root_dir'], 'message')
if not os.path.exists(msg_backup_path):
return
try:
for path, dirs, files in os.walk(msg_backup_path):
for file_name in files:
count = count + 1
if count > top:
return
file_full_name = os.path.join(path, file_name)
logger.info('retry {0}'.format(file_full_name))
Monitor.retry(file_full_name)
except:
logger.exception('retry failed message with exception')
def save_failed_message(message_name, password, headers, message,
match_tag):
conf = ConfigurationHelper.get_settings()
msg = MessageRetry(
message_queue_name=message_name,
message_queue_password=password,
message_queue_headers=None if headers is None else
[NameValuePair(name=k, value=v) for k, v in headers.items()],
match_tag=match_tag,
message=message)
msg_backup_file_path = os.path.join(conf['app_root_dir'], 'message',
str(uuid.uuid4()) + '.msg')
msg_backup_path = os.path.dirname(msg_backup_file_path)
if not os.path.exists(msg_backup_path):
os.makedirs(msg_backup_path)
with open(msg_backup_file_path, 'w') as fp:
fp.write(jsonserializer.serialize(msg))
def __init__(self):
super(MonitorJob, self).__init__()
conf = ConfigurationHelper.get_settings()
self.interval = conf['app_monitor_interval']
self.per_count = conf['app_monitor_per_count']
self.daemon = True
def get_level():
conf = ConfigurationHelper.get_settings()
return conf['log_level'].upper()
def __init__(self):
self.server = socket.gethostname()
self.ip = socket.gethostbyname(self.server)
self.conf = ConfigurationHelper.get_settings()
super(FrameWorkLogHandler, self).__init__()
def receive(self, agreement_id=None):
message = self._create_received_message()
context = None
is_request_mdn = None
mdn_mode = None
try:
context = self._build_received_as2_context(agreement_id, message)
if context.agreement.profiler_enabled:
status, url = self._upload_data_to_dfs(
"{key}.in".format(key=message.key), self.body)
message.received_data_dfs_path = url
is_request_mdn = context.agreement.inbound_agreement.is_request_mdn
mdn_mode = context.agreement.inbound_agreement.mdn_mode
message.message_mdn.mdn_mode = mdn_mode
message.message_mdn.mdn_disposition_mode = 'automatic-action/MDN-sent-automatically'
message.message_mdn.mdn_disposition_type = 'processed'
try:
self._decode_received_content(context)
message.message_status = StatusType.successful
except AS2DecryptException as ex:
message.message_status = StatusType.failed
message.message_mdn.mdn_disposition_modifier_code = 'error'
message.message_mdn.mdn_disposition_modifier_value = 'decryption-failed'
message.memo = ex.msg
except AS2VerifySignatureException as ex:
message.message_status = StatusType.failed
message.message_mdn.mdn_disposition_modifier_code = 'error'
message.message_mdn.mdn_disposition_modifier_value = 'integrity-check-failed'
message.memo = ex.msg
except AS2DeCompressException as ex:
message.message_status = StatusType.failed
message.message_mdn.mdn_disposition_modifier_code = 'error'
message.message_mdn.mdn_disposition_modifier_value = 'decompression-failed'
message.memo = ex.msg
except:
message.message_status = StatusType.failed
message.message_mdn.mdn_disposition_modifier_code = 'error'
message.message_mdn.mdn_disposition_modifier_value = 'unexpected-processing-error'
message.memo = str(sys.exc_info()[1])
if is_request_mdn and mdn_mode == MdnMode.sync:
mdn_headers, mdn_body = self._mdn_encode(context)
message.sent_headers = context.message.message_mdn.mdn_headers
message.sent_data_dfs_path = context.message.message_mdn.mdn_data_dfs_path
return mdn_headers, mdn_body
return None, 'as2 message has been received'
except:
logger.exception('as2 message receive failed')
message.message_status = StatusType.failed
message.memo = str(sys.exc_info()[1])
raise Exception('unexpected processing error')
finally:
if context is not None:
message.message_trace_list = context.trace_info_list
headers = {
'EventMessageKey':
'N/A' if message.key is None else message.key,
'IsRequestMdn':
'N/A' if is_request_mdn is None else is_request_mdn,
'MdnMode':
'N/A' if mdn_mode is None else mdn_mode,
'LocalIdentity':
'N/A'
if message.local_identity is None else message.local_identity,
'TradingIdentity':
'N/A' if message.trading_identity is None else
message.trading_identity,
'Version':
'N/A' if message.version is None else message.version
}
mq_setting = ConfigurationHelper.get_mq_setting(
'inbound_message_queue')
PartnerManager.send_to_message_queue(
mq_setting.queue_name,
mq_setting.password,
message,
headers,
match_tag=mq_setting.serialization_match_tag)
def __init__(self, headers, body):
self.headers = headers
self.body = body
self.conf = ConfigurationHelper.get_settings()