689 lines
26 KiB
C++
689 lines
26 KiB
C++
//
|
|
// Copyright (c) 2014 Wind River Systems, Inc.
|
|
//
|
|
// SPDX-License-Identifier: Apache-2.0
|
|
//
|
|
|
|
#include "fmAlarmUtils.h"
|
|
|
|
#include <uuid/uuid.h>
|
|
|
|
#include <stdlib.h>
|
|
#include <pthread.h>
|
|
#include <map>
|
|
#include <vector>
|
|
|
|
#include "fmDbUtils.h"
|
|
#include "fmLog.h"
|
|
|
|
|
|
typedef std::map<int, std::string> itos_t;
|
|
typedef std::map<std::string, int> stoi_t;
|
|
typedef std::vector<std::string> strvect_t;
|
|
|
|
static pthread_mutex_t mutex = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;
|
|
|
|
static itos_t state_to_str;
|
|
static itos_t severity_to_str;
|
|
static itos_t type_to_str;
|
|
static itos_t cause_to_str;
|
|
static itos_t bool_to_str;
|
|
static itos_t err_to_str;
|
|
|
|
|
|
static stoi_t state_to_int;
|
|
static stoi_t severity_to_int;
|
|
static stoi_t type_to_int;
|
|
static stoi_t cause_to_int;
|
|
static stoi_t bool_to_int;
|
|
static stoi_t err_to_int;
|
|
|
|
#define RETURN_FALSE return false
|
|
#define RETURN return
|
|
#define STRCP_TO(charb, str, return_action) \
|
|
do { \
|
|
if (((str).length() == 0) || \
|
|
((str).length() == 1 && ((str).c_str())[0] == ' ')) { \
|
|
memset(charb, 0, sizeof(charb)); \
|
|
} else { \
|
|
int ret = snprintf(charb, sizeof(charb), "%s", str.c_str()); \
|
|
if (ret < 0) { \
|
|
FM_WARNING_LOG("STRCP_TO fail because of decode error."); \
|
|
return_action; \
|
|
} \
|
|
} \
|
|
}while(0)
|
|
|
|
|
|
void add_both_tables(int id, const char *str, itos_t &t1, stoi_t &t2 ) {
|
|
t1[id] = str;
|
|
t2[str] = id;
|
|
}
|
|
|
|
|
|
static void init_tables() {
|
|
pthread_mutex_lock(&mutex);
|
|
static bool has_inited = false;
|
|
|
|
while (!has_inited) {
|
|
add_both_tables(FM_ALARM_STATE_CLEAR, "clear", state_to_str, state_to_int);
|
|
add_both_tables(FM_ALARM_STATE_SET, "set", state_to_str, state_to_int);
|
|
add_both_tables(FM_ALARM_STATE_MSG, "msg", state_to_str, state_to_int);
|
|
add_both_tables(FM_ALARM_STATE_LOG, "log", state_to_str, state_to_int);
|
|
|
|
add_both_tables(FM_ALARM_SEVERITY_CLEAR, "not-applicable", severity_to_str, severity_to_int);
|
|
add_both_tables(FM_ALARM_SEVERITY_WARNING, "warning", severity_to_str, severity_to_int);
|
|
add_both_tables(FM_ALARM_SEVERITY_MINOR, "minor", severity_to_str, severity_to_int);
|
|
add_both_tables(FM_ALARM_SEVERITY_MAJOR, "major", severity_to_str, severity_to_int);
|
|
add_both_tables(FM_ALARM_SEVERITY_CRITICAL, "critical", severity_to_str, severity_to_int);
|
|
|
|
add_both_tables(FM_ALARM_TYPE_UNKNOWN, "other", type_to_str, type_to_int);
|
|
add_both_tables(FM_ALARM_COMM, "communication", type_to_str, type_to_int);
|
|
add_both_tables(FM_ALARM_QOS, "qos", type_to_str, type_to_int);
|
|
add_both_tables(FM_ALARM_PROCESSING_ERROR, "processing-error", type_to_str, type_to_int);
|
|
add_both_tables(FM_ALARM_EQUIPMENT, "equipment", type_to_str, type_to_int);
|
|
add_both_tables(FM_ALARM_ENVIRONMENTAL, "environmental", type_to_str, type_to_int);
|
|
add_both_tables(FM_ALARM_INTERGRITY, "integrity-violation", type_to_str, type_to_int);
|
|
add_both_tables(FM_ALARM_OPERATIONAL, "operational-violation", type_to_str, type_to_int);
|
|
add_both_tables(FM_ALARM_PHYSICAL, "physical-violation", type_to_str, type_to_int);
|
|
add_both_tables(FM_ALARM_SECURITY, "security-service-or-mechanism-violation", type_to_str, type_to_int);
|
|
add_both_tables(FM_ALARM_TIME, "time-domain-violation", type_to_str, type_to_int);
|
|
|
|
add_both_tables(FM_ALARM_CAUSE_UNKNOWN, "not-applicable", cause_to_str, cause_to_int);
|
|
add_both_tables(FM_ALARM_ADAPTOR_ERROR, "adaptor-error", cause_to_str, cause_to_int);
|
|
add_both_tables(FM_ALARM_APP_SUBSYS_FAILURE, "application-subsystem-failure", cause_to_str, cause_to_int);
|
|
add_both_tables(FM_ALARM_BANDWIDTH_REDUCED, "bandwidth-reduced", cause_to_str, cause_to_int);
|
|
add_both_tables(FM_ALARM_CALL_ERROR, "call-establishment-error", cause_to_str, cause_to_int);
|
|
add_both_tables(FM_ALARM_COMM_PROTOCOL_ERROR, "communication-protocol-error", cause_to_str, cause_to_int);
|
|
add_both_tables(FM_ALARM_COMM_SUBSYS_FAILURE, "communication-subsystem-failure", cause_to_str, cause_to_int);
|
|
add_both_tables(FM_ALARM_CONFIG_ERROR, "configuration-or-customization-error", cause_to_str, cause_to_int);
|
|
add_both_tables(FM_ALARM_CONGESTION, "congestion", cause_to_str, cause_to_int);
|
|
add_both_tables(FM_ALARM_CORRUPT_DATA, "corrupt-data", cause_to_str, cause_to_int);
|
|
add_both_tables(FM_ALARM_CPU_LIMITED_EXCEEDED, "cpu-cycles-limit-exceeded", cause_to_str, cause_to_int);
|
|
add_both_tables(FM_ALARM_DATASET_ERROR, "dataset-or-modem-error", cause_to_str, cause_to_int);
|
|
add_both_tables(FM_ALARM_DEGRADED_SIGNAL, "degraded-signal", cause_to_str, cause_to_int);
|
|
add_both_tables(FM_ALARM_DTE_DCE_INTERFACE_ERROR, "dte-dce-interface-error", cause_to_str, cause_to_int);
|
|
add_both_tables(FM_ALARM_DOOR_OPEN, "enclosure-door-open", cause_to_str, cause_to_int);
|
|
add_both_tables(FM_ALARM_EQUIPMENT_MALFUNCTION, "equipment-malfunction", cause_to_str, cause_to_int);
|
|
add_both_tables(FM_ALARM_EXCESSIVE_VIBRATION, "excessive-vibration'", cause_to_str, cause_to_int);
|
|
add_both_tables(FM_ALARM_FILE_ERROR, "file-error", cause_to_str, cause_to_int);
|
|
add_both_tables(FM_ALARM_FIRE_DETECTED, "fire-detected", cause_to_str, cause_to_int);
|
|
add_both_tables(FM_ALARM_FLOOD_DETECTED, "flood-detected", cause_to_str, cause_to_int);
|
|
add_both_tables(FM_ALARM_FRAMING_ERROR, "framing-error", cause_to_str, cause_to_int);
|
|
add_both_tables(FM_ALARM_COOLING_PROBLEM, "heating-ventilation-cooling-system-problem", cause_to_str, cause_to_int);
|
|
add_both_tables(FM_ALARM_HUMIDITY_UNACCEPTABLE, "humidity-unacceptable", cause_to_str, cause_to_int);
|
|
add_both_tables(FM_ALARM_IO_DEVICE_ERROR, "io-device-error", cause_to_str, cause_to_int);
|
|
add_both_tables(FM_ALARM_INPUT_DEVICE_ERROR, "input-device-error", cause_to_str, cause_to_int);
|
|
add_both_tables(FM_ALARM_LAN_ERROR, "lan-error", cause_to_str, cause_to_int);
|
|
add_both_tables(FM_ALARM_LEAK_DETECTED, "leak-detected", cause_to_str, cause_to_int);
|
|
add_both_tables(FM_ALARM_LOCAL_TX_ERROR, "local-node-transmission-error", cause_to_str, cause_to_int);
|
|
add_both_tables(FM_ALARM_LOSS_OF_FRAME, "loss-of-frame", cause_to_str, cause_to_int);
|
|
add_both_tables(FM_ALARM_LOSS_OF_SIGNAL, "loss-of-signal", cause_to_str, cause_to_int);
|
|
add_both_tables(FM_ALARM_MATERIAL_SUPPlY_EXHAUSTED, "material-supply-exhausted", cause_to_str, cause_to_int);
|
|
add_both_tables(FM_ALARM_MULTIPLEXER_PROBLEM, "multiplexer-problem", cause_to_str, cause_to_int);
|
|
add_both_tables(FM_ALARM_OUT_OF_MEMORY, "out-of-memory", cause_to_str, cause_to_int);
|
|
add_both_tables(FM_ALARM_OUTPUT_DEVICE_ERROR, "output-device-error", cause_to_str, cause_to_int);
|
|
add_both_tables(FM_ALARM_PERMFORMANCE_DEGRADED, "performance-degraded", cause_to_str, cause_to_int);
|
|
add_both_tables(FM_ALARM_POWER_PROBLEM, "power-problem", cause_to_str, cause_to_int);
|
|
add_both_tables(FM_ALARM_PROCESSOR_PROBLEM, "processor-problem", cause_to_str, cause_to_int);
|
|
add_both_tables(FM_ALARM_PUMP_FAILURE, "pump-failure", cause_to_str, cause_to_int);
|
|
add_both_tables(FM_ALARM_Q_SIZE_EXCEEDED, "queue-size-exceeded", cause_to_str, cause_to_int);
|
|
add_both_tables(FM_ALARM_RX_FAILURE, "receive-failure", cause_to_str, cause_to_int);
|
|
add_both_tables(FM_ALARM_RXER_FAILURE, "receiver-failure", cause_to_str, cause_to_int);
|
|
add_both_tables(FM_ALARM_REMOTE_TX_ERROR, "remote-node-transmission-error", cause_to_str, cause_to_int);
|
|
add_both_tables(FM_ALARM_RESOURCE_NEAR_CAPACITY, "resource-at-or-nearing-capacity", cause_to_str, cause_to_int);
|
|
add_both_tables(FM_ALARM_RESPONSE_TIME_EXCESSIVE, "response-time-excessive", cause_to_str, cause_to_int);
|
|
add_both_tables(FM_ALARM_RETX_RATE_EXCESSIVE, "retransmission-rate-excessive", cause_to_str, cause_to_int);
|
|
add_both_tables(FM_ALARM_SOFTWARE_ERROR, "software-error", cause_to_str, cause_to_int);
|
|
add_both_tables(FM_ALARM_PROGRAM_TERMINATED, "software-program-abnormally-terminated", cause_to_str, cause_to_int);
|
|
add_both_tables(FM_ALARM_PROGRAM_ERROR, "software-program-error", cause_to_str, cause_to_int);
|
|
add_both_tables(FM_ALARM_STORAGE_PROBLEM, "storage-capacity-problem", cause_to_str, cause_to_int);
|
|
add_both_tables(FM_ALARM_TEMP_UNACCEPTABLE, "temperature-unacceptable", cause_to_str, cause_to_int);
|
|
add_both_tables(FM_ALARM_THRESHOLD_CROSSED, "threshold-crossed", cause_to_str, cause_to_int);
|
|
add_both_tables(FM_ALARM_TIMING_PROBLEM, "timing-problem", cause_to_str, cause_to_int);
|
|
add_both_tables(FM_ALARM_TOXIC_LEAK_DETECTED, "toxic-leak-detected", cause_to_str, cause_to_int);
|
|
add_both_tables(FM_ALARM_TRANSMIT_FAILURE, "transmit-failure", cause_to_str, cause_to_int);
|
|
add_both_tables(FM_ALARM_TRANSMITTER_FAILURE, "transmitter-failure", cause_to_str, cause_to_int);
|
|
add_both_tables(FM_ALARM_UNDERLYING_RESOURCE_UNAVAILABLE, "underlying-resource-unavailable", cause_to_str, cause_to_int);
|
|
add_both_tables(FM_ALARM_VERSION_MISMATCH, "version-mismatch", cause_to_str, cause_to_int);
|
|
add_both_tables(FM_ALARM_DUPLICATE_INFO, "duplicate-information", cause_to_str, cause_to_int);
|
|
add_both_tables(FM_ALARM_INFO_MISSING, "information-missing", cause_to_str, cause_to_int);
|
|
add_both_tables(FM_ALARM_INFO_MODIFICATION, "information-modification-detected", cause_to_str, cause_to_int);
|
|
add_both_tables(FM_ALARM_INFO_OUT_OF_SEQ, "information-out-of-sequence", cause_to_str, cause_to_int);
|
|
add_both_tables(FM_ALARM_UNEXPECTED_INFO, "unexpected-information", cause_to_str, cause_to_int);
|
|
add_both_tables(FM_ALARM_DENIAL_OF_SERVICE, "denial-of-service", cause_to_str, cause_to_int);
|
|
add_both_tables(FM_ALARM_OUT_OF_SERVICE, "out-of-service", cause_to_str, cause_to_int);
|
|
add_both_tables(FM_ALARM_PROCEDURAL_ERROR, "procedural-error", cause_to_str, cause_to_int);
|
|
add_both_tables(FM_ALARM_UNSPECIFIED_REASON, "unspecified-reason", cause_to_str, cause_to_int);
|
|
add_both_tables(FM_ALARM_CABLE_TAMPER, "cable-tamper", cause_to_str, cause_to_int);
|
|
add_both_tables(FM_ALARM_INTRUSION_DETECTION, "intrusion-detection", cause_to_str, cause_to_int);
|
|
add_both_tables(FM_ALARM_AUTH_FAILURE, "authentication-failure", cause_to_str, cause_to_int);
|
|
add_both_tables(FM_ALARM_BREACH_CONFIDENT, "breach-of-confidentiality", cause_to_str, cause_to_int);
|
|
add_both_tables(FM_ALARM_NON_REPUD_FAILURE, "non-repudiation-failure", cause_to_str, cause_to_int);
|
|
add_both_tables(FM_ALARM_UNAUTH_ACCESS_ATTEMP, "unauthorized-access-attempt", cause_to_str, cause_to_int);
|
|
add_both_tables(FM_ALARM_DELAYED_INFO, "delayed-information", cause_to_str, cause_to_int);
|
|
add_both_tables(FM_ALARM_KEY_EXPIRED, "key-expired", cause_to_str, cause_to_int);
|
|
add_both_tables(FM_ALARM_OUT_OF_HR_ACTIVITY, "out-of-hours-activity", cause_to_str, cause_to_int);
|
|
|
|
add_both_tables(FM_ERR_OK, "Ok", err_to_str, err_to_int);
|
|
add_both_tables(FM_ERR_ALARM_EXISTS, "FM_ERR_ALARM_EXISTS", err_to_str, err_to_int);
|
|
add_both_tables(FM_ERR_INVALID_ATTRIBUTE, "FM_ERR_INVALID_ATTRIBUTE", err_to_str, err_to_int);
|
|
add_both_tables(FM_ERR_ENTITY_NOT_FOUND, "FM_ERR_ENTITY_NOT_FOUND", err_to_str, err_to_int);
|
|
add_both_tables(FM_ERR_DB_OPERATION_FAILURE, "FM_ERR_DB_OPERATION_FAILURE", err_to_str, err_to_int);
|
|
add_both_tables(FM_ERR_SCRIPT_FAILURE, "FM_ERR_SCRIPT_FAILURE", err_to_str, err_to_int);
|
|
add_both_tables(FM_ERR_NOCONNECT, "FM_ERR_NOCONNECT", err_to_str, err_to_int);
|
|
add_both_tables(FM_ERR_NOMEM, "FM_ERR_NOMEM", err_to_str, err_to_int);
|
|
add_both_tables(FM_ERR_COMMUNICATIONS, "FM_ERR_COMMUNICATIONS", err_to_str, err_to_int);
|
|
add_both_tables(FM_ERR_NOT_ENOUGH_SPACE, "FM_ERR_NOT_ENOUGH_SPACE", err_to_str, err_to_int);
|
|
add_both_tables(FM_ERR_INVALID_REQ, "FM_ERR_INVALID_REQ", err_to_str, err_to_int);
|
|
add_both_tables(FM_ERR_SERVER_NO_MEM, "FM_ERR_SERVER_NO_MEM", err_to_str, err_to_int);
|
|
add_both_tables(FM_ERR_INVALID_PARAMETER, "FM_ERR_INVALID_PARAMETER", err_to_str, err_to_int);
|
|
add_both_tables(FM_ERR_RESOURCE_UNAVAILABLE, "FM_ERR_RESOURCE_UNAVAILABLE", err_to_str, err_to_int);
|
|
|
|
add_both_tables(0, "False", bool_to_str, bool_to_int);
|
|
add_both_tables(1, "True", bool_to_str, bool_to_int);
|
|
|
|
has_inited = true;
|
|
}
|
|
pthread_mutex_unlock(&mutex);
|
|
}
|
|
|
|
|
|
static void add_s(std::string &s) { s+="###"; }
|
|
|
|
|
|
static std::string tostr(int id, const itos_t &t ) {
|
|
itos_t::const_iterator it = t.find(id);
|
|
if (it != t.end())
|
|
return it->second;
|
|
return "unknown";
|
|
}
|
|
|
|
|
|
static int toint(const std::string &s, const stoi_t &t) {
|
|
stoi_t::const_iterator it = t.find(s);
|
|
if (it != t.end())
|
|
return it->second;
|
|
return 0;
|
|
}
|
|
|
|
|
|
static std::string chkstr(const std::string &s) {
|
|
if (s.length() == 0)
|
|
return " ";
|
|
return s;
|
|
}
|
|
|
|
|
|
static void str_to_vector(const std::string &s,
|
|
std::vector<std::string> &alarm) {
|
|
size_t offset = 0;
|
|
alarm.clear();
|
|
if (s.length() <= 3)
|
|
return;
|
|
|
|
while (true) {
|
|
size_t beg = (offset == 0) ? 0 : s.find("###", offset);
|
|
if (beg == std::string::npos) break;
|
|
size_t e = s.find("###", beg+3);
|
|
std::string cont = s.substr(beg + 3, e - (beg + 3));
|
|
alarm.push_back(cont);
|
|
offset = e;
|
|
}
|
|
}
|
|
|
|
|
|
static void fm_set_uuid(SFmAlarmDataT *a, std::string &s,
|
|
bool is_get) {
|
|
if (is_get)
|
|
s = chkstr(a->uuid);
|
|
else
|
|
STRCP_TO(a->uuid, s, RETURN);
|
|
}
|
|
|
|
|
|
static void fm_tr_alarm_id(SFmAlarmDataT *a, std::string &s,
|
|
bool is_get) {
|
|
if (is_get)
|
|
s = chkstr(a->alarm_id);
|
|
else
|
|
STRCP_TO(a->alarm_id, s, RETURN);
|
|
}
|
|
|
|
|
|
static void fm_alarm_state(SFmAlarmDataT *a, std::string &s,
|
|
bool is_get) {
|
|
if (is_get)
|
|
s = tostr(a->alarm_state, state_to_str);
|
|
else
|
|
a->alarm_state = (EFmAlarmStateT)toint(s, state_to_int);
|
|
}
|
|
|
|
|
|
static void fm_entity_id(SFmAlarmDataT *a, std::string &s,
|
|
bool is_get) {
|
|
if (is_get)
|
|
s = chkstr(a->entity_type_id);
|
|
else
|
|
STRCP_TO(a->entity_type_id, s, RETURN);
|
|
}
|
|
|
|
|
|
static void fm_instance_id(SFmAlarmDataT *a, std::string &s,
|
|
bool is_get) {
|
|
if (is_get)
|
|
s = chkstr(a->entity_instance_id);
|
|
else
|
|
STRCP_TO(a->entity_instance_id, s, RETURN);
|
|
}
|
|
|
|
|
|
static void fm_timestamp(SFmAlarmDataT *a, std::string &s,
|
|
bool is_get) {
|
|
if (is_get)
|
|
fm_db_util_make_timestamp_string(s, a->timestamp);
|
|
else
|
|
fm_db_util_get_timestamp(s.c_str(), a->timestamp);
|
|
}
|
|
|
|
|
|
static void fm_alarm_severity(SFmAlarmDataT *a, std::string &s,
|
|
bool is_get) {
|
|
if (is_get)
|
|
s = tostr(a->severity, severity_to_str);
|
|
else
|
|
a->severity = (EFmAlarmSeverityT)toint(s, severity_to_int);
|
|
}
|
|
|
|
|
|
static void fm_reason_text(SFmAlarmDataT *a, std::string &s,
|
|
bool is_get) {
|
|
if (is_get)
|
|
s = chkstr(a->reason_text);
|
|
else
|
|
STRCP_TO(a->reason_text, s, RETURN);
|
|
}
|
|
|
|
|
|
static void fm_alarm_type(SFmAlarmDataT *a, std::string &s,
|
|
bool is_get) {
|
|
if (is_get)
|
|
s = tostr(a->alarm_type, type_to_str);
|
|
else
|
|
a->alarm_type = (EFmAlarmTypeT)toint(s, type_to_int);
|
|
}
|
|
|
|
|
|
static void fm_prop_cause(SFmAlarmDataT *a, std::string &s,
|
|
bool is_get) {
|
|
if (is_get)
|
|
s = tostr(a->probable_cause, cause_to_str);
|
|
else
|
|
a->probable_cause = (EFmAlarmProbableCauseT)toint(s, cause_to_int);
|
|
}
|
|
|
|
|
|
static void fm_repair(SFmAlarmDataT *a, std::string &s,
|
|
bool is_get) {
|
|
if (is_get)
|
|
s = chkstr(a->proposed_repair_action);
|
|
else
|
|
STRCP_TO(a->proposed_repair_action, s, RETURN);
|
|
}
|
|
|
|
|
|
static void fm_service_affect(SFmAlarmDataT *a, std::string &s,
|
|
bool is_get) {
|
|
if (is_get)
|
|
s = tostr(a->service_affecting, bool_to_str);
|
|
else
|
|
a->service_affecting = (((s == "t") || (s == "True"))? 1 :0);
|
|
}
|
|
|
|
|
|
static void fm_suppression(SFmAlarmDataT *a, std::string &s,
|
|
bool is_get) {
|
|
if (is_get)
|
|
s = tostr(a->suppression, bool_to_str);
|
|
else
|
|
a->suppression = (((s == "t") || (s == "True"))? 1 :0);
|
|
}
|
|
|
|
|
|
static void fm_inhibit_alarm(SFmAlarmDataT *a, std::string &s,
|
|
bool is_get) {
|
|
if (is_get)
|
|
s = tostr(a->inhibit_alarms, bool_to_str);
|
|
else
|
|
a->inhibit_alarms = (((s == "t") || (s == "True"))? 1 :0);
|
|
}
|
|
|
|
|
|
typedef void (*set_get_field_type)(SFmAlarmDataT *a, std::string &s, bool is_get);
|
|
|
|
|
|
struct alarm_struct_update_t {
|
|
EFmAlarmIndexMap id;
|
|
set_get_field_type func;
|
|
} fm_alarm_convert_func[] = {
|
|
{ FM_ALM_IX_UUID, fm_set_uuid },
|
|
{ FM_ALM_IX_ALARM_ID, fm_tr_alarm_id },
|
|
{ FM_ALM_IX_ALARM_STATE, fm_alarm_state },
|
|
{ FM_ALM_IX_ENTITY_ID, fm_entity_id },
|
|
{ FM_ALM_IX_INSTANCE_ID, fm_instance_id },
|
|
{ FM_ALM_IX_TIMESTAMP, fm_timestamp },
|
|
{ FM_ALM_IX_SEVERITY, fm_alarm_severity },
|
|
{ FM_ALM_IX_REASON, fm_reason_text },
|
|
{ FM_ALM_IX_ALARM_TYPE, fm_alarm_type },
|
|
{ FM_ALM_IX_PROBABLE_CAUSE, fm_prop_cause },
|
|
{ FM_ALM_IX_REPAIR_ACTION, fm_repair },
|
|
{ FM_ALM_IX_SERVICE_AFFECT, fm_service_affect },
|
|
{ FM_ALM_IX_SUPPRESSION, fm_suppression },
|
|
{ FM_ALM_IX_INHIBIT_ALARM, fm_inhibit_alarm }
|
|
};
|
|
|
|
|
|
static set_get_field_type find_func_set_get(EFmAlarmIndexMap id) {
|
|
size_t ix = 0;
|
|
size_t mx = sizeof (fm_alarm_convert_func) / sizeof(*fm_alarm_convert_func);
|
|
for ( ; ix < mx ; ++ix ) {
|
|
if (fm_alarm_convert_func[ix].id == id)
|
|
return fm_alarm_convert_func[ix].func;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
|
|
bool fm_alarm_set_field(EFmAlarmIndexMap field, SFmAlarmDataT *a,
|
|
std::string &val) {
|
|
init_tables();
|
|
set_get_field_type p = find_func_set_get(field);
|
|
if (p == NULL) return false;
|
|
p(a, val, false);
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
struct log_struct_update_t {
|
|
EFmLogIndexMap id;
|
|
set_get_field_type func;
|
|
} fm_log_convert_func[] = {
|
|
{ FM_LOG_IX_UUID, fm_set_uuid },
|
|
{ FM_LOG_IX_LOG_ID, fm_tr_alarm_id },
|
|
{ FM_LOG_IX_ENTITY_ID, fm_entity_id },
|
|
{ FM_LOG_IX_INSTANCE_ID, fm_instance_id },
|
|
{ FM_LOG_IX_TIMESTAMP, fm_timestamp },
|
|
{ FM_LOG_IX_SEVERITY, fm_alarm_severity },
|
|
{ FM_LOG_IX_REASON, fm_reason_text },
|
|
{ FM_LOG_IX_LOG_TYPE, fm_alarm_type },
|
|
{ FM_LOG_IX_PROBABLE_CAUSE, fm_prop_cause },
|
|
{ FM_LOG_IX_SERVICE_AFFECT, fm_service_affect }
|
|
};
|
|
|
|
|
|
static set_get_field_type fm_log_find_func_set_get(EFmLogIndexMap id) {
|
|
size_t ix = 0;
|
|
size_t mx = sizeof (fm_log_convert_func) / sizeof(*fm_log_convert_func);
|
|
for ( ; ix < mx ; ++ix ) {
|
|
if (fm_log_convert_func[ix].id == id)
|
|
return fm_log_convert_func[ix].func;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
|
|
bool fm_log_set_field(EFmLogIndexMap field, SFmAlarmDataT *a,
|
|
std::string &val) {
|
|
init_tables();
|
|
set_get_field_type p = fm_log_find_func_set_get(field);
|
|
if (p == NULL) return false;
|
|
p(a, val, false);
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
struct event_log_struct_update_t {
|
|
EFmEventLogIndexMap id;
|
|
set_get_field_type func;
|
|
} fm_event_log_convert_func[] = {
|
|
{ FM_EVENT_LOG_IX_UUID, fm_set_uuid },
|
|
{ FM_EVENT_LOG_IX_EVENT_ID, fm_tr_alarm_id },
|
|
{ FM_EVENT_LOG_IX_STATE, fm_alarm_state },
|
|
{ FM_EVENT_LOG_IX_ENTITY_ID, fm_entity_id },
|
|
{ FM_EVENT_LOG_IX_INSTANCE_ID, fm_instance_id },
|
|
{ FM_EVENT_LOG_IX_TIMESTAMP, fm_timestamp },
|
|
{ FM_EVENT_LOG_IX_SEVERITY, fm_alarm_severity },
|
|
{ FM_EVENT_LOG_IX_REASON, fm_reason_text },
|
|
{ FM_EVENT_LOG_IX_EVENT_TYPE, fm_alarm_type },
|
|
{ FM_EVENT_LOG_IX_PROBABLE_CAUSE, fm_prop_cause },
|
|
{ FM_EVENT_LOG_IX_REPAIR_ACTION, fm_repair },
|
|
{ FM_EVENT_LOG_IX_SERVICE_AFFECT, fm_service_affect },
|
|
{ FM_EVENT_LOG_IX_SUPPRESSION, fm_suppression }
|
|
};
|
|
|
|
|
|
static set_get_field_type fm_event_log_find_func_set_get(EFmEventLogIndexMap id) {
|
|
size_t ix = 0;
|
|
size_t mx = sizeof (fm_event_log_convert_func) / sizeof(*fm_event_log_convert_func);
|
|
for ( ; ix < mx ; ++ix ) {
|
|
if (fm_event_log_convert_func[ix].id == id)
|
|
return fm_event_log_convert_func[ix].func;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
|
|
bool fm_event_log_set_field(EFmEventLogIndexMap field, SFmAlarmDataT *a,
|
|
std::string &val) {
|
|
init_tables();
|
|
set_get_field_type p = fm_event_log_find_func_set_get(field);
|
|
if (p == NULL) return false;
|
|
p(a, val, false);
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
bool fm_alarm_get_field(EFmAlarmIndexMap field, const SFmAlarmDataT *a,
|
|
std::string &val) {
|
|
init_tables();
|
|
set_get_field_type p = find_func_set_get(field);
|
|
if (p == NULL) return false;
|
|
p((SFmAlarmDataT*)a, val, true);
|
|
return true;
|
|
}
|
|
|
|
|
|
static std::string fm_alarm_to_string(const SFmAlarmDataT *a) {
|
|
std::string s;
|
|
size_t ix = 0;
|
|
size_t mx = FM_ALM_IX_INHIBIT_ALARM;
|
|
std::string field;
|
|
|
|
for ( ; ix <= mx ; ++ix ) {
|
|
fm_alarm_get_field(((EFmAlarmIndexMap)ix), a, field);
|
|
s += field;
|
|
add_s(s);
|
|
}
|
|
return s;
|
|
}
|
|
|
|
|
|
void fm_alarm_to_list(const SFmAlarmDataT *a, std::vector<std::string> &list) {
|
|
size_t ix = 0;
|
|
size_t mx = FM_ALM_IX_INHIBIT_ALARM;
|
|
std::string field;
|
|
|
|
for ( ; ix <= mx ; ++ix ) {
|
|
fm_alarm_get_field(((EFmAlarmIndexMap)ix), a, field);
|
|
list.push_back(field);
|
|
}
|
|
}
|
|
|
|
|
|
void fm_formatted_str_to_vector(const std::string &s,
|
|
std::vector<std::string> &alarm) {
|
|
str_to_vector(s, alarm);
|
|
}
|
|
|
|
|
|
/**
|
|
* public APIs
|
|
*/
|
|
|
|
EFmErrorT fm_error_from_string(const std::string &str) {
|
|
return (EFmErrorT)toint(str, err_to_int);
|
|
}
|
|
|
|
|
|
std::string fm_error_from_int(EFmErrorT id) {
|
|
return tostr((int)id, err_to_str);
|
|
}
|
|
|
|
|
|
bool fm_alarm_filter_to_string(const AlarmFilter *filter, std::string &str) {
|
|
init_tables();
|
|
|
|
str += chkstr(filter->alarm_id);
|
|
add_s(str);
|
|
str += chkstr(filter->entity_instance_id);
|
|
add_s(str);
|
|
return true;
|
|
}
|
|
|
|
|
|
bool fm_alarm_filter_from_string(const std::string &str, AlarmFilter *filter) {
|
|
strvect_t s;
|
|
str_to_vector(str, s);
|
|
|
|
if (s.size() < 2) {
|
|
FM_ERROR_LOG("Alarm filter wrong format: %s", str.c_str());
|
|
return false;
|
|
}
|
|
|
|
init_tables();
|
|
|
|
STRCP_TO(filter->alarm_id, s[0], RETURN_FALSE);
|
|
STRCP_TO(filter->entity_instance_id, s[1], RETURN_FALSE);
|
|
return true;
|
|
}
|
|
|
|
|
|
bool fm_alarm_to_string(const SFmAlarmDataT *alarm, std::string &str) {
|
|
init_tables();
|
|
str += fm_alarm_to_string(alarm);
|
|
return str.size() > 0;
|
|
}
|
|
|
|
bool fm_alarm_from_string(const std::string &alstr, SFmAlarmDataT *a) {
|
|
strvect_t s;
|
|
str_to_vector(alstr, s);
|
|
|
|
// includes adjustment for last entry + 1 (for starting at 0)
|
|
if (s.size() < (FM_ALM_IX_MAX)) {
|
|
return false;
|
|
}
|
|
|
|
init_tables();
|
|
|
|
size_t ix = 0;
|
|
size_t mx = s.size();
|
|
for ( ; ix < mx ; ++ix ) {
|
|
fm_alarm_set_field((EFmAlarmIndexMap)ix, a, s[ix]);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
void fm_uuid_create(fm_uuid_t &uuid) {
|
|
uuid_t uu;
|
|
|
|
memset(uuid, 0, sizeof(uuid));
|
|
uuid_generate(uu);
|
|
uuid_unparse_lower(uu, uuid);
|
|
}
|
|
|
|
|
|
void fm_log_request(fm_buff_t &req, bool failed) {
|
|
SFmMsgHdrT *hdr = ptr_to_hdr(req);
|
|
std::string description;
|
|
|
|
if (failed) {
|
|
description.assign("Failed to send FM");
|
|
} else {
|
|
description.assign("Sending FM");
|
|
}
|
|
|
|
switch (hdr->action) {
|
|
case EFmCreateFault: {
|
|
SFmAlarmDataT *data = (SFmAlarmDataT *)ptr_to_data(req);
|
|
FM_INFO_LOG("%s raise alarm request: alarm_id (%s), entity_id (%s)",
|
|
description.c_str(), data->alarm_id, data->entity_instance_id);
|
|
}
|
|
break;
|
|
case EFmDeleteFault: {
|
|
AlarmFilter *filter = (AlarmFilter *)ptr_to_data(req);
|
|
FM_INFO_LOG("%s clear alarm request: alarm_id (%s), entity_id (%s)",
|
|
description.c_str(), filter->alarm_id, filter->entity_instance_id);
|
|
}
|
|
break;
|
|
case EFmDeleteFaults: {
|
|
fm_ent_inst_t *entity_id = (fm_ent_inst_t*)ptr_to_data(req);
|
|
fm_ent_inst_t &eid = *entity_id;
|
|
FM_INFO_LOG("%s clear all request: entity_id (%s)", description.c_str(), eid);
|
|
}
|
|
break;
|
|
default:
|
|
FM_ERROR_LOG("Unexpected API action:%u\n", hdr->action);
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
void fm_log_response(fm_buff_t &req, fm_buff_t &resp, bool failed) {
|
|
SFmMsgHdrT *hdr = ptr_to_hdr(req);
|
|
SFmMsgHdrT *resp_hdr = ptr_to_hdr(resp);
|
|
|
|
switch (hdr->action) {
|
|
case EFmCreateFault: {
|
|
SFmAlarmDataT *data = (SFmAlarmDataT *)ptr_to_data(req);
|
|
if (failed) {
|
|
FM_WARNING_LOG("Failed to get response for FM raise alarm: alarm_id (%s), entity_id (%s)",
|
|
data->alarm_id, data->entity_instance_id);
|
|
} else {
|
|
FM_INFO_LOG("FM Response for raise alarm: (%d), alarm_id (%s), entity_id (%s)",
|
|
resp_hdr->msg_rc, data->alarm_id, data->entity_instance_id);
|
|
}
|
|
}
|
|
break;
|
|
case EFmDeleteFault: {
|
|
AlarmFilter *filter = (AlarmFilter *)ptr_to_data(req);
|
|
if (failed) {
|
|
FM_WARNING_LOG("Failed to get response for FM clear alarm: alarm_id (%s), entity_id (%s)",
|
|
filter->alarm_id, filter->entity_instance_id);
|
|
} else {
|
|
FM_INFO_LOG("FM Response for clear alarm: (%d), alarm_id (%s), entity_id (%s)",
|
|
resp_hdr->msg_rc, filter->alarm_id, filter->entity_instance_id);
|
|
}
|
|
}
|
|
break;
|
|
case EFmDeleteFaults: {
|
|
fm_ent_inst_t *entity_id = (fm_ent_inst_t*)ptr_to_data(req);
|
|
fm_ent_inst_t &eid = *entity_id;
|
|
if (failed) {
|
|
FM_WARNING_LOG("Failed to get response for FM clear all: entity_id (%s)", eid);
|
|
} else {
|
|
FM_INFO_LOG("FM Response for clear all: (%d), entity_id (%s)",
|
|
resp_hdr->msg_rc, eid);
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
FM_ERROR_LOG("Unexpected API action:%u\n", hdr->action);
|
|
break;
|
|
}
|
|
}
|