starlingx
/
fault
Code Issues Proposed changes

Fix indentation and style issues in fmAPI 

Several indentation issues were solved, also some style was applied
to improve code's readability.

No funcionality changes were done.

Story: 2006425
Task: 36322

Change-Id: Ie3339ed10254a053a2e26397337c45dfa2d552bd
Signed-off-by: Erich Cordoba <erich.cordoba.malibran@intel.com>
This commit is contained in:
Erich Cordoba 2019-08-21 16:04:49 -05:00
parent 96f4179575
commit f9ba635bfd
2 changed files with 394 additions and 370 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

163
fm-common/sources/fmAPI.cpp
View File

@ -51,25 +51,30 @@ static bool m_connected = false;
static bool m_thread = false; static bool m_thread = false;
typedef std::list<fm_buff_t> FmRequestListT; typedef std::list<fm_buff_t> FmRequestListT;
static FmRequestListT & GetListOfFmRequests(){
static FmRequestListT & GetListOfFmRequests() {
static FmRequestListT reqs; static FmRequestListT reqs;
return reqs; return reqs;
} }
static CFmMutex & getListMutex(){
static CFmMutex & getListMutex() {
static CFmMutex *m = new CFmMutex; static CFmMutex *m = new CFmMutex;
return *m; return *m;
} }
static CFmMutex & getThreadMutex(){
static CFmMutex & getThreadMutex() {
static CFmMutex *m = new CFmMutex; static CFmMutex *m = new CFmMutex;
return *m; return *m;
} }
CFmMutex & getAPIMutex(){
CFmMutex & getAPIMutex() {
static pthread_mutex_t ml = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP; static pthread_mutex_t ml = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;
static CFmMutex *m = NULL; static CFmMutex *m = NULL;
if (m == NULL){ if (m == NULL) {
pthread_mutex_lock(&ml); pthread_mutex_lock(&ml);
m = new CFmMutex; m = new CFmMutex;
pthread_mutex_unlock(&ml); pthread_mutex_unlock(&ml);
@ -77,16 +82,19 @@ CFmMutex & getAPIMutex(){
return *m; return *m;
} }
static void enqueue(fm_buff_t &req){
static void enqueue(fm_buff_t &req) {
CFmMutexGuard m(getListMutex()); CFmMutexGuard m(getListMutex());
GetListOfFmRequests().push_back(req); GetListOfFmRequests().push_back(req);
} }
static bool dequeue(fm_buff_t &req){
static bool dequeue(fm_buff_t &req) {
CFmMutexGuard m(getListMutex()); CFmMutexGuard m(getListMutex());
if (GetListOfFmRequests().size() == 0){ if (GetListOfFmRequests().size() == 0) {
return false; return false;
} }
FmRequestListT::iterator it = GetListOfFmRequests().begin(); FmRequestListT::iterator it = GetListOfFmRequests().begin();
req.clear(); req.clear();
req = (*it); req = (*it);
@ -94,12 +102,13 @@ static bool dequeue(fm_buff_t &req){
return true; return true;
} }
static bool fm_lib_reconnect() { static bool fm_lib_reconnect() {
char addr[INET6_ADDRSTRLEN]; char addr[INET6_ADDRSTRLEN];
while (!m_connected) { while (!m_connected) {
struct addrinfo hints; struct addrinfo hints;
struct addrinfo *result=NULL, *rp; struct addrinfo *result = NULL, *rp;
memset(&hints,0,sizeof(hints)); memset(&hints,0,sizeof(hints));
hints.ai_family = AF_UNSPEC; /* Allow IPv4 or IPv6 */ hints.ai_family = AF_UNSPEC; /* Allow IPv4 or IPv6 */
hints.ai_socktype = SOCK_STREAM; /* Datagram socket */ hints.ai_socktype = SOCK_STREAM; /* Datagram socket */
@ -109,22 +118,22 @@ static bool fm_lib_reconnect() {
hints.ai_addr = NULL; hints.ai_addr = NULL;
hints.ai_next = NULL; hints.ai_next = NULL;
int rc = getaddrinfo(FM_MGR_HOST_NAME,NULL, int rc = getaddrinfo(FM_MGR_HOST_NAME, NULL,
&hints, &hints,
&result); &result);
if (rc!=0) { if (rc != 0) {
FM_ERROR_LOG("controller lookup failed... errno:%d",errno); FM_ERROR_LOG("controller lookup failed... errno:%d", errno);
break; break;
} else { } else {
for (rp = result; rp != NULL; rp = rp->ai_next) { for (rp = result; rp != NULL; rp = rp->ai_next) {
if (rp->ai_family==AF_INET||rp->ai_family==AF_INET6) { if (rp->ai_family == AF_INET || rp->ai_family==AF_INET6) {
if(rp->ai_family==AF_INET) { if(rp->ai_family == AF_INET) {
inet_ntop(AF_INET, &(((sockaddr_in*)rp->ai_addr)->sin_addr), addr, sizeof(addr)); inet_ntop(AF_INET, &(((sockaddr_in*)rp->ai_addr)->sin_addr), addr, sizeof(addr));
} else if (rp->ai_family==AF_INET6) { } else if (rp->ai_family == AF_INET6) {
inet_ntop(AF_INET6, &(((sockaddr_in6*)rp->ai_addr)->sin6_addr), addr, sizeof(addr)); inet_ntop(AF_INET6, &(((sockaddr_in6*)rp->ai_addr)->sin6_addr), addr, sizeof(addr));
} }
m_connected=m_client.connect(addr,8001,rp->ai_family); m_connected = m_client.connect(addr, 8001, rp->ai_family);
if (m_connected==true) { if (m_connected == true) {
FM_INFO_LOG("Connected to FM Manager."); FM_INFO_LOG("Connected to FM Manager.");
break; break;
} else { } else {
@ -140,6 +149,7 @@ static bool fm_lib_reconnect() {
return (m_connected); return (m_connected);
} }
EFmErrorT fm_msg_utils_prep_requet_msg(fm_buff_t &buff, EFmErrorT fm_msg_utils_prep_requet_msg(fm_buff_t &buff,
EFmMsgActionsT act, EFmMsgActionsT act,
const void * data, const void * data,
@ -156,18 +166,19 @@ EFmErrorT fm_msg_utils_prep_requet_msg(fm_buff_t &buff,
hdr->msg_size = len; hdr->msg_size = len;
hdr->version = EFmMsgV1; hdr->version = EFmMsgV1;
hdr->msg_rc = 0; hdr->msg_rc = 0;
memcpy(ptr_to_data(buff),data,len); memcpy(ptr_to_data(buff), data, len);
return FM_ERR_OK; return FM_ERR_OK;
} }
static void fmApiJobHandlerThread(void *context){
while (true){ static void fmApiJobHandlerThread(void *context) {
while (true) {
fm_buff_t buff; fm_buff_t buff;
buff.clear(); buff.clear();
while (dequeue(buff)){ while (dequeue(buff)) {
while (true) { while (true) {
while (!fm_lib_reconnect()){ while (!fm_lib_reconnect()) {
fmThreadSleep(200); fmThreadSleep(200);
} }
fm_log_request(buff); fm_log_request(buff);
@ -181,13 +192,12 @@ static void fmApiJobHandlerThread(void *context){
fm_log_response(buff, in_buff, true); fm_log_response(buff, in_buff, true);
m_connected = false; m_connected = false;
continue; continue;
} } else {
else {
fm_log_response(buff, in_buff); fm_log_response(buff, in_buff);
break; break;
} }
}else{ } else {
//retry after write failure // retry after write failure
fm_log_request(buff, true); fm_log_request(buff, true);
m_connected = false; m_connected = false;
continue; continue;
@ -198,23 +208,24 @@ static void fmApiJobHandlerThread(void *context){
} }
} }
static bool fm_lib_thread(){
static bool fm_lib_thread() {
CFmMutexGuard m(getThreadMutex()); CFmMutexGuard m(getThreadMutex());
if (!m_thread){ if (!m_thread) {
FM_INFO_LOG("Creating thread"); FM_INFO_LOG("Creating thread");
if (!fmCreateThread(fmApiJobHandlerThread,NULL)) { if (!fmCreateThread(fmApiJobHandlerThread, NULL)) {
FM_ERROR_LOG("Fail to create API job thread"); FM_ERROR_LOG("Fail to create API job thread");
} } else {
else {
m_thread = true; m_thread = true;
} }
} }
return m_thread; return m_thread;
} }
static EFmErrorT fm_check_thread_pending_request(){
static EFmErrorT fm_check_thread_pending_request() {
CFmMutexGuard m(getThreadMutex()); CFmMutexGuard m(getThreadMutex());
if (m_thread){ if (m_thread) {
CHECK_LIST_NOT_EMPTY(GetListOfFmRequests()); CHECK_LIST_NOT_EMPTY(GetListOfFmRequests());
} }
return FM_ERR_OK; return FM_ERR_OK;
@ -233,20 +244,21 @@ EFmErrorT fm_init_lib() {
return FM_ERR_OK; return FM_ERR_OK;
} }
EFmErrorT fm_set_fault(const SFmAlarmDataT *alarm, EFmErrorT fm_set_fault(const SFmAlarmDataT *alarm,
fm_uuid_t *uuid){ fm_uuid_t *uuid) {
CFmMutexGuard m(getAPIMutex()); CFmMutexGuard m(getAPIMutex());
if (!fm_lib_reconnect()) return FM_ERR_NOCONNECT; if (!fm_lib_reconnect()) return FM_ERR_NOCONNECT;
fm_buff_t buff; fm_buff_t buff;
buff.clear(); buff.clear();
EFmErrorT erc = fm_msg_utils_prep_requet_msg(buff,EFmCreateFault, EFmErrorT erc = fm_msg_utils_prep_requet_msg(buff, EFmCreateFault,
alarm,sizeof(*alarm)); alarm,sizeof(*alarm));
if (erc!=FM_ERR_OK) return erc; if (erc!=FM_ERR_OK) return erc;
if(m_client.write_packet(buff)) { if (m_client.write_packet(buff)) {
if(!m_client.read_packet(buff)) { if (!m_client.read_packet(buff)) {
m_connected = false; m_connected = false;
return FM_ERR_NOCONNECT; return FM_ERR_NOCONNECT;
} }
@ -263,19 +275,20 @@ EFmErrorT fm_set_fault(const SFmAlarmDataT *alarm,
return FM_ERR_OK; return FM_ERR_OK;
} }
EFmErrorT fm_clear_fault(AlarmFilter *filter){
EFmErrorT fm_clear_fault(AlarmFilter *filter) {
CFmMutexGuard m(getAPIMutex()); CFmMutexGuard m(getAPIMutex());
if (!fm_lib_reconnect()) return FM_ERR_NOCONNECT; if (!fm_lib_reconnect()) return FM_ERR_NOCONNECT;
fm_buff_t buff; fm_buff_t buff;
buff.clear(); buff.clear();
EFmErrorT erc = fm_msg_utils_prep_requet_msg(buff,EFmDeleteFault, EFmErrorT erc = fm_msg_utils_prep_requet_msg(buff, EFmDeleteFault,
filter,sizeof(*filter)); filter, sizeof(*filter));
if (erc!=FM_ERR_OK) return erc; if (erc!=FM_ERR_OK) return erc;
if(m_client.write_packet(buff)) { if (m_client.write_packet(buff)) {
if(!m_client.read_packet(buff)) { if (!m_client.read_packet(buff)) {
m_connected = false; m_connected = false;
return FM_ERR_NOCONNECT; return FM_ERR_NOCONNECT;
} }
@ -287,19 +300,20 @@ EFmErrorT fm_clear_fault(AlarmFilter *filter){
return FM_ERR_OK; return FM_ERR_OK;
} }
EFmErrorT fm_clear_all(fm_ent_inst_t *inst_id){
EFmErrorT fm_clear_all(fm_ent_inst_t *inst_id) {
CFmMutexGuard m(getAPIMutex()); CFmMutexGuard m(getAPIMutex());
if (!fm_lib_reconnect()) return FM_ERR_NOCONNECT; if (!fm_lib_reconnect()) return FM_ERR_NOCONNECT;
fm_buff_t buff; fm_buff_t buff;
buff.clear(); buff.clear();
EFmErrorT erc = fm_msg_utils_prep_requet_msg(buff,EFmDeleteFaults, EFmErrorT erc = fm_msg_utils_prep_requet_msg(buff, EFmDeleteFaults,
(*inst_id), sizeof(*inst_id)); (*inst_id), sizeof(*inst_id));
if (erc!=FM_ERR_OK) return erc; if (erc!=FM_ERR_OK) return erc;
if(m_client.write_packet(buff)) { if (m_client.write_packet(buff)) {
if(!m_client.read_packet(buff)) { if (!m_client.read_packet(buff)) {
m_connected = false; m_connected = false;
FM_ERROR_LOG("Read ERR: return FM_ERR_NOCONNECT"); FM_ERROR_LOG("Read ERR: return FM_ERR_NOCONNECT");
return FM_ERR_NOCONNECT; return FM_ERR_NOCONNECT;
@ -314,7 +328,7 @@ EFmErrorT fm_clear_all(fm_ent_inst_t *inst_id){
} }
EFmErrorT fm_get_fault(AlarmFilter *filter, SFmAlarmDataT *alarm ){ EFmErrorT fm_get_fault(AlarmFilter *filter, SFmAlarmDataT *alarm ) {
CFmMutexGuard m(getAPIMutex()); CFmMutexGuard m(getAPIMutex());
if (!fm_lib_reconnect()) return FM_ERR_NOCONNECT; if (!fm_lib_reconnect()) return FM_ERR_NOCONNECT;
@ -322,12 +336,12 @@ EFmErrorT fm_get_fault(AlarmFilter *filter, SFmAlarmDataT *alarm ){
fm_buff_t buff; fm_buff_t buff;
buff.clear(); buff.clear();
EFmErrorT erc = fm_msg_utils_prep_requet_msg(buff,EFmGetFault, EFmErrorT erc = fm_msg_utils_prep_requet_msg(buff, EFmGetFault,
filter,sizeof(*filter)); filter,sizeof(*filter));
if (erc!=FM_ERR_OK) return erc; if (erc!=FM_ERR_OK) return erc;
if(m_client.write_packet(buff)) { if (m_client.write_packet(buff)) {
if(!m_client.read_packet(buff)) { if (!m_client.read_packet(buff)) {
m_connected = false; m_connected = false;
return FM_ERR_NOCONNECT; return FM_ERR_NOCONNECT;
} }
@ -343,8 +357,10 @@ EFmErrorT fm_get_fault(AlarmFilter *filter, SFmAlarmDataT *alarm ){
return FM_ERR_OK; return FM_ERR_OK;
} }
EFmErrorT fm_get_faults(fm_ent_inst_t *inst_id, EFmErrorT fm_get_faults(fm_ent_inst_t *inst_id,
SFmAlarmDataT *alarm, unsigned int *max_alarms_to_get) { SFmAlarmDataT *alarm,
unsigned int *max_alarms_to_get) {
CFmMutexGuard m(getAPIMutex()); CFmMutexGuard m(getAPIMutex());
if (!fm_lib_reconnect()) return FM_ERR_NOCONNECT; if (!fm_lib_reconnect()) return FM_ERR_NOCONNECT;
@ -352,17 +368,17 @@ EFmErrorT fm_get_faults(fm_ent_inst_t *inst_id,
fm_buff_t buff; fm_buff_t buff;
buff.clear(); buff.clear();
EFmErrorT erc = fm_msg_utils_prep_requet_msg(buff,EFmGetFaults, EFmErrorT erc = fm_msg_utils_prep_requet_msg(buff, EFmGetFaults,
(*inst_id),sizeof(*inst_id)); (*inst_id),sizeof(*inst_id));
if (erc!=FM_ERR_OK) return erc; if (erc!=FM_ERR_OK) return erc;
if(m_client.write_packet(buff)) { if (m_client.write_packet(buff)) {
if(!m_client.read_packet(buff)) { if(!m_client.read_packet(buff)) {
m_connected = false; m_connected = false;
return FM_ERR_NOCONNECT; return FM_ERR_NOCONNECT;
} }
if (ptr_to_hdr(buff)->msg_rc != FM_ERR_OK){ if (ptr_to_hdr(buff)->msg_rc != FM_ERR_OK) {
*max_alarms_to_get = 0; *max_alarms_to_get = 0;
EFmErrorT rc = (EFmErrorT)ptr_to_hdr(buff)->msg_rc; EFmErrorT rc = (EFmErrorT)ptr_to_hdr(buff)->msg_rc;
return rc; return rc;
@ -383,7 +399,7 @@ EFmErrorT fm_get_faults(fm_ent_inst_t *inst_id,
if (*max_alarms_to_get < *len) { if (*max_alarms_to_get < *len) {
return FM_ERR_NOT_ENOUGH_SPACE; return FM_ERR_NOT_ENOUGH_SPACE;
} }
if (pkt_size < (*len*sizeof(SFmAlarmDataT)) ) { if (pkt_size < (*len*sizeof(SFmAlarmDataT))) {
return FM_ERR_COMMUNICATIONS; return FM_ERR_COMMUNICATIONS;
} }
*max_alarms_to_get = *len; *max_alarms_to_get = *len;
@ -396,8 +412,10 @@ EFmErrorT fm_get_faults(fm_ent_inst_t *inst_id,
return FM_ERR_OK; return FM_ERR_OK;
} }
EFmErrorT fm_get_faults_by_id(fm_alarm_id *alarm_id, SFmAlarmDataT *alarm,
unsigned int *max_alarms_to_get){ EFmErrorT fm_get_faults_by_id(fm_alarm_id *alarm_id,
SFmAlarmDataT *alarm,
unsigned int *max_alarms_to_get) {
CFmMutexGuard m(getAPIMutex()); CFmMutexGuard m(getAPIMutex());
if (!fm_lib_reconnect()) return FM_ERR_NOCONNECT; if (!fm_lib_reconnect()) return FM_ERR_NOCONNECT;
@ -405,12 +423,12 @@ EFmErrorT fm_get_faults_by_id(fm_alarm_id *alarm_id, SFmAlarmDataT *alarm,
fm_buff_t buff; fm_buff_t buff;
buff.clear(); buff.clear();
EFmErrorT erc = fm_msg_utils_prep_requet_msg(buff,EFmGetFaultsById, EFmErrorT erc = fm_msg_utils_prep_requet_msg(buff, EFmGetFaultsById,
(*alarm_id),sizeof(*alarm_id)); (*alarm_id), sizeof(*alarm_id));
if (erc!=FM_ERR_OK) return erc; if (erc!=FM_ERR_OK) return erc;
if(m_client.write_packet(buff)) { if (m_client.write_packet(buff)) {
if(!m_client.read_packet(buff)) { if (!m_client.read_packet(buff)) {
m_connected = false; m_connected = false;
return FM_ERR_NOCONNECT; return FM_ERR_NOCONNECT;
} }
@ -449,11 +467,12 @@ EFmErrorT fm_get_faults_by_id(fm_alarm_id *alarm_id, SFmAlarmDataT *alarm,
return FM_ERR_OK; return FM_ERR_OK;
} }
/* /*
* APIs that enqueue the request and return ok for acknowledgment. * APIs that enqueue the request and return ok for acknowledgment.
* A backgroup thread will pick up the request and send it to the FM Manager * A backgroup thread will pick up the request and send it to the FM Manager
*/ */
EFmErrorT fm_set_fault_async(const SFmAlarmDataT *alarm, fm_uuid_t *uuid){ EFmErrorT fm_set_fault_async(const SFmAlarmDataT *alarm, fm_uuid_t *uuid) {
if ( !fm_lib_thread()) return FM_ERR_RESOURCE_UNAVAILABLE; if ( !fm_lib_thread()) return FM_ERR_RESOURCE_UNAVAILABLE;
CHECK_LIST_FULL(GetListOfFmRequests()); CHECK_LIST_FULL(GetListOfFmRequests());
@ -462,30 +481,31 @@ EFmErrorT fm_set_fault_async(const SFmAlarmDataT *alarm, fm_uuid_t *uuid){
fm_buff_t buff; fm_buff_t buff;
buff.clear(); buff.clear();
fm_uuid_create(id); fm_uuid_create(id);
EFmErrorT erc = fm_msg_utils_prep_requet_msg(buff,EFmCreateFault, EFmErrorT erc = fm_msg_utils_prep_requet_msg(buff, EFmCreateFault,
alarm,sizeof(*alarm)); alarm, sizeof(*alarm));
if (erc!=FM_ERR_OK) return erc; if (erc != FM_ERR_OK) return erc;
memcpy(ptr_to_data(buff), id, sizeof(fm_uuid_t)-1); memcpy(ptr_to_data(buff), id, sizeof(fm_uuid_t)-1);
FM_INFO_LOG("Enqueue raise alarm request: UUID (%s) alarm id (%s) instant id (%s)", FM_INFO_LOG("Enqueue raise alarm request: UUID (%s) alarm id (%s) instant id (%s)",
id, alarm->alarm_id, alarm->entity_instance_id); id, alarm->alarm_id, alarm->entity_instance_id);
enqueue(buff); enqueue(buff);
if (uuid != NULL){ if (uuid != NULL) {
memcpy(*uuid,id,sizeof(*uuid)-1); memcpy(*uuid,id,sizeof(*uuid)-1);
} }
return FM_ERR_OK; return FM_ERR_OK;
} }
EFmErrorT fm_clear_fault_async(AlarmFilter *filter){
EFmErrorT fm_clear_fault_async(AlarmFilter *filter) {
if ( !fm_lib_thread()) return FM_ERR_RESOURCE_UNAVAILABLE; if ( !fm_lib_thread()) return FM_ERR_RESOURCE_UNAVAILABLE;
CHECK_LIST_FULL(GetListOfFmRequests()); CHECK_LIST_FULL(GetListOfFmRequests());
fm_buff_t buff; fm_buff_t buff;
buff.clear(); buff.clear();
EFmErrorT erc = fm_msg_utils_prep_requet_msg(buff,EFmDeleteFault, EFmErrorT erc = fm_msg_utils_prep_requet_msg(buff, EFmDeleteFault,
filter,sizeof(*filter)); filter, sizeof(*filter));
if (erc!=FM_ERR_OK) return erc; if (erc!=FM_ERR_OK) return erc;
FM_INFO_LOG("Enqueue clear alarm request: alarm id (%s), instant id (%s)", FM_INFO_LOG("Enqueue clear alarm request: alarm id (%s), instant id (%s)",
@ -495,14 +515,15 @@ EFmErrorT fm_clear_fault_async(AlarmFilter *filter){
return FM_ERR_OK; return FM_ERR_OK;
} }
EFmErrorT fm_clear_all_async(fm_ent_inst_t *inst_id){
EFmErrorT fm_clear_all_async(fm_ent_inst_t *inst_id) {
if ( !fm_lib_thread()) return FM_ERR_RESOURCE_UNAVAILABLE; if ( !fm_lib_thread()) return FM_ERR_RESOURCE_UNAVAILABLE;
CHECK_LIST_FULL(GetListOfFmRequests()); CHECK_LIST_FULL(GetListOfFmRequests());
fm_buff_t buff; fm_buff_t buff;
buff.clear(); buff.clear();
EFmErrorT erc = fm_msg_utils_prep_requet_msg(buff,EFmDeleteFaults, EFmErrorT erc = fm_msg_utils_prep_requet_msg(buff, EFmDeleteFaults,
(*inst_id), sizeof(*inst_id)); (*inst_id), sizeof(*inst_id));
if (erc!=FM_ERR_OK) return erc; if (erc!=FM_ERR_OK) return erc;

5
fm-common/sources/fmAPI.h
View File

@ -184,9 +184,12 @@ typedef enum{
typedef struct { typedef struct {
char alarm_id[FM_MAX_BUFFER_LENGTH]; char alarm_id[FM_MAX_BUFFER_LENGTH];
fm_ent_inst_t entity_instance_id; fm_ent_inst_t entity_instance_id;
}AlarmFilter ; }AlarmFilter;
/*
* APIs to create, clear and query alarms.
*/
EFmErrorT fm_set_fault(const SFmAlarmDataT *alarm, fm_uuid_t *uuid); EFmErrorT fm_set_fault(const SFmAlarmDataT *alarm, fm_uuid_t *uuid);
EFmErrorT fm_clear_fault(AlarmFilter *filter); EFmErrorT fm_clear_fault(AlarmFilter *filter);