def set_error_code(data_dict, return_obj): exception = None exception_str = None if 'exception' in data_dict: exception = data_dict['exception'] exception_str = str(exception) error_code = ErrorMapper.DEFAULT_ERROR error_message = 'Error when converting STIX pattern to data source query' if exception_str: error_message += ': ' + exception_str if exception is not None: exception_type = type(exception).__name__ ErrorMapper.logger.error("received exception => {}: {}".format( exception_type, exception)) ErrorMapper.logger.debug(logger.exception_to_string(exception)) if exception_type in error_mapping: error_code = error_mapping[exception_type][0] error_message = error_mapping[exception_type][1] exception_message = str(exception) if (len(exception_message) > 0): if len(error_message) > 0: error_message += ' : ' error_message += exception_message ErrorMapperBase.set_error_code(return_obj, error_code, message=error_message)
def set_error_code(json_data, return_obj): error_code = ErrorMapper.DEFAULT_ERROR for error_package in error_mapping: search_type = error_package[0] search_criteria = error_package[1] result_error = error_package[2] if ErrorCaptureType.ERROR_MESSAGE == search_type: if 'error' in return_obj and search_criteria in return_obj[ 'error']: error_code = result_error elif ErrorCaptureType.STRUCT_VALUE == search_type: search_path = search_criteria[0] desired_value = search_criteria[1] stuct_search_result = ErrorResponder.get_struct_item( json_data, search_path[:-1]) if stuct_search_result is not None and search_path[ -1] in stuct_search_result and stuct_search_result[ search_path[-1]] == desired_value: error_code = result_error if error_code == ErrorMapper.DEFAULT_ERROR: ErrorMapper.logger.debug('failed to map: ' + str(json_data)) if isinstance(error_code, tuple): ErrorMapperBase.set_error_code(return_obj, error_code[0], error_code[1]) else: ErrorMapperBase.set_error_code(return_obj, error_code)
def fill_error(return_object, message_struct=None, message_path=None, message=None, error=None, connector=None): return_object['success'] = False if connector: return_object['connector'] = connector error_code = ErrorCode.TRANSMISSION_UNKNOWN if message is None: message = '' struct_item = ErrorResponder.get_struct_item(message_struct, message_path) if struct_item is not None: if len(message) > 0: message += ';' if (isinstance(struct_item, list)): struct_item = json.dumps(struct_item) message += str(struct_item) error_msg = '' if error is not None: str_error = str(error) logger.error("error occurred: " + str_error) logger.debug(utils_logger.exception_to_string(error)) if isinstance(error, SSLError): error_code = ErrorCode.TRANSMISSION_AUTH_SSL error_msg = 'Wrong certificate: ' + str_error elif isinstance(error, ConnectionError): error_code = ErrorCode.TRANSMISSION_CONNECT error_msg = 'Connection error: ' + str_error else: error_msg = str(error) if len(error_msg) > 0: if len(message) > 0: message += '; ' message += error_msg if message is not None and len(message) > 0: if error_code.value == ErrorCode.TRANSMISSION_UNKNOWN.value: if 'uthenticat' in message or 'uthoriz' in message or 'access denied' in message: error_code = ErrorCode.TRANSMISSION_AUTH_CREDENTIALS elif 'query_syntax_error' in message: error_code = ErrorCode.TRANSMISSION_QUERY_PARSING_ERROR elif 'Forbidden' in message or 'forbidden' in message: error_code = ErrorCode.TRANSMISSION_FORBIDDEN message = '{} connector error => {}'.format( connector, str(message)) return_object['error'] = str(message) ErrorMapperBase.set_error_code(return_object, error_code.value, connector=connector) if error_code == ErrorCode.TRANSMISSION_UNKNOWN: ErrorResponder.call_module_error_mapper(message_struct, return_object, connector)
def set_error_code(json_data, return_obj): code = None try: code = int(json_data['code']) except Exception: pass error_code = error_mapping.get(code, ErrorMapper.DEFAULT_ERROR) if error_code == ErrorMapper.DEFAULT_ERROR: ErrorMapper.logger.error("failed to map: %s", json_data) ErrorMapperBase.set_error_code(return_obj, error_code)
def set_error_code(cls, json_data, return_obj): error_code = cls.DEFAULT_ERROR try: # Carbon Black Cloud stores error messages in 'translation_key' error_code = json_data['translation_key'] except ValueError: cls.logger.debug(json_data) if error_code == ErrorMapper.DEFAULT_ERROR: cls.logger.error(f'failed to map: {str(json_data)}') ErrorMapperBase.set_error_code(return_obj, error_code)
def fill_error(return_object, message_struct=None, message_path=None, message=None, error=None): return_object['success'] = False error_code = ErrorCode.TRANSMISSION_UNKNOWN if message is None: message = '' struct_item = ErrorResponder.get_struct_item(message_struct, message_path) if struct_item is not None: if len(message) > 0: message += ';' if (isinstance(struct_item, list)): struct_item = json.dumps(struct_item) message += str(struct_item) error_msg = '' if error is not None: str_error = str(error) #TODO replace with logger + stacktrace it to logger ErrorResponder.logger.error("error occurred: " + str_error) if isinstance(error, SSLError): error_code = ErrorCode.TRANSMISSION_AUTH_SSL error_msg = 'Wrong certificate: ' + str_error elif isinstance(error, ConnectionError): error_code = ErrorCode.TRANSMISSION_CONNECT error_msg = 'Connection error: ' + str_error else: error_msg = str(error) if len(error_msg) > 0: if len(message) > 0: message += '; ' message += error_msg if message is not None and len(message) > 0: if error_code.value == ErrorCode.TRANSMISSION_UNKNOWN.value: if 'uthenticat' in message or 'uthoriz' in message: error_code = ErrorCode.TRANSMISSION_AUTH_CREDENTIALS elif 'query_syntax_error' in message: error_code = ErrorCode.TRANSMISSION_QUERY_PARSING_ERROR return_object['error'] = str(message) ErrorMapperBase.set_error_code(return_object, error_code.value) if error_code == ErrorCode.TRANSMISSION_UNKNOWN: ErrorResponder.call_module_error_mapper(message_struct, return_object)
def set_error_code(json_data, return_obj): code = None try: code = json_data['code'] except Exception: pass error_code = ErrorMapper.DEFAULT_ERROR if code in error_mapping: error_code = error_mapping[code] if error_code == ErrorMapper.DEFAULT_ERROR: ErrorMapper.logger.error("failed to map: " + str(json_data)) ErrorMapperBase.set_error_code(return_obj, error_code)
def set_error_code(json_data, return_obj): error_type = '' try: error_type = json_data['error']['type'] except Exception: pass error_code = ErrorMapper.DEFAULT_ERROR if error_type in error_mapping: error_code = error_mapping[error_type] if error_code == ErrorMapper.DEFAULT_ERROR: ErrorMapper.logger.error("failed to map: " + str(json_data)) ErrorMapperBase.set_error_code(return_obj, error_code)
def set_error_code(json_data, return_obj): err_type = None try: err_type = json_data['type'] except KeyError: pass error_type = ErrorMapper.DEFAULT_ERROR if err_type in error_mapping: error_type = error_mapping.get(err_type) if error_type == ErrorMapper.DEFAULT_ERROR: ErrorMapper.logger.error("failed to map: %s", str(json_data)) ErrorMapperBase.set_error_code(return_obj, error_type)
def set_error_code(json_data, return_obj): """aws transmit specified error :param json_data: dict, error response of api_call :param return_obj: dict, returns error and error code""" error_type = '' try: error_type = json_data['__type'] except KeyError: pass error_code = ErrorMapper.DEFAULT_ERROR if error_type in ERROR_MAPPING: error_code = ERROR_MAPPING[error_type] if error_code == ErrorMapper.DEFAULT_ERROR: ErrorMapper.logger.debug("failed to map: " + str(json_data)) ErrorMapperBase.set_error_code(return_obj, error_code)
def call_module_error_mapper(json_data, return_object): caller_path_list = traceback.extract_stack()[-3].filename.split('/') if 'stix_translation.py' in caller_path_list[-1]: module_path = 'stix_shifter_utils.stix_translation.stix_translation_error_mapper' else: caller_module_name = caller_path_list[-3:-1] module_path = 'stix_shifter_modules.' + caller_module_name[0] + '.' + caller_module_name[1] + '.error_mapper' # path_start_position = ErrorResponder.rindex(caller_path_list, 'stix-shifter') # module_path = 'stix_shifter_modules.' + caller_module_name[0] + '.' + caller_module_name[1] + '.' + caller_module_name[0] + '_error_mapper' # module_path = '.'.join(caller_path_list[path_start_position: -1]) + '.' + caller_module_name + '_error_mapper' try: module = importlib.import_module(module_path) if json_data is not None: module.ErrorMapper.set_error_code(json_data, return_object) else: ErrorMapperBase.set_error_code(return_object, module.ErrorMapper.DEFAULT_ERROR) except ModuleNotFoundError: pass
def set_error_code(json_data, return_obj): message_text = None try: message_text = json_data['messages'][0]['text'] except Exception as e: print("failed to find the message_0_text in: " + str(json_data)) raise e error_code = ErrorMapper.DEFAULT_ERROR print('error code message: ' + message_text) for k, v in error_mapping.items(): if k in message_text: error_code = v break if error_code == ErrorMapper.DEFAULT_ERROR: print("failed to map: " + str(json_data)) ErrorMapperBase.set_error_code(return_obj, error_code)
def set_error_code(json_data, return_obj): """ Parses API error response, maps native error status to STIX error, and saves to response object. :param json_data: native error response object :type json_data: map :param return_obj: standard error response object to return :type return_obj: map """ code = None try: code = int(json_data['code']) except Exception: pass error_code = error_mapping.get(code, ErrorMapper.DEFAULT_ERROR) if error_code == ErrorMapper.DEFAULT_ERROR: ErrorMapper.logger.error("failed to map: %s", json_data) ErrorMapperBase.set_error_code(return_obj, error_code)
def set_error_code(json_data, return_obj): """ms_atp transmit specified error :param json_data: dict, error response of api_call :param return_obj: dict, returns error and error code""" if isinstance(json_data, tuple): error_type = 'HTTPSConnectionError' else: try: error_type = json_data['error']['code'] except Exception: error_type = json_data['error'] error_code = ErrorMapper.DEFAULT_ERROR if error_type in ERROR_MAPPING: error_code = ERROR_MAPPING[error_type] if error_code == ErrorMapper.DEFAULT_ERROR: print("failed to map: " + str(json_data)) ErrorMapperBase.set_error_code(return_obj, error_code)
def set_error_code(json_data, return_obj): """arcsight transmit specified error :param json_data: dict, error response of api_call :param return_obj: dict, returns error and error code""" try: error_type = json_data['code'] except Exception: error_type = json_data.__class__.__name__ # logger down string error mapping if 'currently unavailable' in str(json_data): error_type = 'ConnectionError' error_code = ErrorMapper.DEFAULT_ERROR if error_type in ERROR_MAPPING: error_code = ERROR_MAPPING[error_type] if error_code == ErrorMapper.DEFAULT_ERROR: ErrorMapper.logger.debug("failed to map: " + str(json_data)) ErrorMapperBase.set_error_code(return_obj, error_code)