/*****************************************************************************\
* Name: plms_healthcheck_start *
* *
* Description: To start the health check *
* *
* Arguments: NULL *
* *
* Returns: NCSCC_RC_SUCCESS - everything is OK *
* NCSCC_RC_FAILURE - failure *
* NOTE: *
\******************************************************************************/
static uint32_t plms_healthcheck_start()
{
SaAisErrorT error;
SaAmfHealthcheckKeyT Healthy;
char *health_key = 0;
PLMS_CB * cb = plms_cb;
TRACE_ENTER();
if (cb->healthCheckStarted == true) {
return NCSCC_RC_SUCCESS;
}
/** start the AMF health check **/
memset(&Healthy, 0, sizeof(Healthy));
health_key = getenv("PLMS_ENV_HEALTHCHECK_KEY");
if (health_key == NULL || strlen(health_key) > SA_AMF_HEALTHCHECK_KEY_MAX) {
strcpy((char *)Healthy.key, "PL12");
/* Log it */
} else {
strncpy((char *)Healthy.key, health_key, SA_AMF_HEALTHCHECK_KEY_MAX);
}
Healthy.keyLen = strlen((char *)Healthy.key);
error = saAmfHealthcheckStart(cb->amf_hdl, &cb->comp_name, &Healthy,SA_AMF_HEALTHCHECK_AMF_INVOKED, SA_AMF_NODE_FAILFAST);
if (error != SA_AIS_OK) {
LOG_ER("Health Check start failed");
return NCSCC_RC_FAILURE;
} else {
cb->healthCheckStarted = true;
LOG_ER("Health Check started successfully");
return NCSCC_RC_SUCCESS;
}
}
/*****************************************************************************\
* Name: amf_healthcheck_start *
* *
* Description: To start the health check *
* *
* Arguments: SMFD_CB* - Control Block *
* *
* Returns: SA_AIS_OK - everything is OK *
* SA_AIS_ERR_* - failure *
* NOTE: *
\******************************************************************************/
static SaAisErrorT amf_healthcheck_start(smfd_cb_t * cb)
{
SaAisErrorT result;
SaAmfHealthcheckKeyT healthy;
char *health_key;
TRACE_ENTER();
/** start the AMF health check **/
memset(&healthy, 0, sizeof(healthy));
health_key = getenv("SMFSV_ENV_HEALTHCHECK_KEY");
if (health_key == NULL) {
strncpy((char *)healthy.key, "A1B2", SA_AMF_HEALTHCHECK_KEY_MAX);
} else {
if (strlen(health_key) > SA_AMF_HEALTHCHECK_KEY_MAX) {
LOG_ER("amf_healthcheck_start(): Helthcheck key to long");
return SA_AIS_ERR_NAME_TOO_LONG;
}
strncpy((char *)healthy.key, health_key, strlen(health_key)); //The key does not need to be null terminated
}
healthy.keyLen = strlen((const char *)healthy.key);
result = saAmfHealthcheckStart(cb->amf_hdl, &cb->comp_name, &healthy,
SA_AMF_HEALTHCHECK_AMF_INVOKED,
SA_AMF_COMPONENT_FAILOVER);
if (result != SA_AIS_OK)
LOG_ER("saAmfHealthcheckStart FAILED: %u", result);
TRACE_LEAVE();
return result;
}
/*****************************************************************************\
* Name: ntfs_healthcheck_start *
* *
* Description: To start the health check *
* *
* Arguments: NCSSA_CB* - Control Block *
* *
* Returns: SA_AIS_OK - everything is OK *
* SA_AIS_ERR_* - failure *
* NOTE: *
\******************************************************************************/
SaAisErrorT ntfs_amf_healthcheck_start()
{
SaAisErrorT error;
SaAmfHealthcheckKeyT healthy;
char *health_key;
TRACE_ENTER();
/** start the AMF health check **/
memset(&healthy, 0, sizeof(healthy));
health_key = (char *)getenv("NTFSV_ENV_HEALTHCHECK_KEY");
if (health_key == NULL) {
strncpy((char *)healthy.key, "F1B2", SA_AMF_HEALTHCHECK_KEY_MAX);
healthy.keyLen = strlen((const char *)healthy.key);
} else {
healthy.keyLen = strlen(health_key);
if (healthy.keyLen > sizeof(healthy.key))
healthy.keyLen = sizeof(healthy.key);
strncpy((char *)healthy.key, health_key, healthy.keyLen);
}
error = saAmfHealthcheckStart(ntfs_cb->amf_hdl, &ntfs_cb->comp_name, &healthy,
SA_AMF_HEALTHCHECK_AMF_INVOKED, SA_AMF_COMPONENT_FAILOVER);
if (error != SA_AIS_OK)
LOG_ER("saAmfHealthcheckStart FAILED: %u", error);
TRACE_LEAVE();
return error;
}
/*****************************************************************************\
* Name: lgs_healthcheck_start *
* *
* Description: To start the health check *
* *
* Arguments: NCSSA_CB* - Control Block *
* *
* Returns: SA_AIS_OK - everything is OK *
* SA_AIS_ERR_* - failure *
* NOTE: *
\******************************************************************************/
static SaAisErrorT amf_healthcheck_start(lgs_cb_t *lgs_cb)
{
SaAisErrorT error;
SaAmfHealthcheckKeyT healthy;
char *health_key;
TRACE_ENTER();
/** start the AMF health check **/
memset(&healthy, 0, sizeof(healthy));
health_key = getenv("LGSV_ENV_HEALTHCHECK_KEY");
if (health_key == NULL)
strcpy((char *)healthy.key, "F1B2");
else
strcpy((char *)healthy.key, health_key);
healthy.keyLen = strlen((char *)healthy.key);
error = saAmfHealthcheckStart(lgs_cb->amf_hdl, &lgs_cb->comp_name, &healthy,
SA_AMF_HEALTHCHECK_AMF_INVOKED, SA_AMF_COMPONENT_FAILOVER);
if (error != SA_AIS_OK)
LOG_ER("saAmfHealthcheckStart FAILED: %u", error);
TRACE_LEAVE();
return error;
}
/**
* Thread start routine to register with AMF and start health check
* Error handling: exits process at failure
* @param __cb control block pointer
*/
static void* amf_init_start(void *notused)
{
SaAisErrorT error;
const char *health_key;
SaAmfHealthcheckKeyT healthy;
TRACE_ENTER();
error = saAmfComponentRegister(immd_cb->amf_hdl, &immd_cb->comp_name, NULL);
if (error != SA_AIS_OK) {
LOG_ER("saAmfComponentRegister failed: %u, exiting", error);
exit(1);
}
memset(&healthy, 0, sizeof(healthy));
health_key = getenv("IMMSV_ENV_HEALTHCHECK_KEY");
if (health_key == NULL) {
strncpy((char *)healthy.key, "A1B2", sizeof(healthy.key));
healthy.keyLen = (SaUint16T) strlen((char *)healthy.key);
} else {
healthy.keyLen = (SaUint16T) strlen((char *)health_key);
if (healthy.keyLen < sizeof(healthy.key)) {
strncpy((char *)healthy.key, health_key, sizeof(healthy.key));
} else {
LOG_ER("Health check key too long:%u, exiting", healthy.keyLen);
exit(1);
}
}
error = saAmfHealthcheckStart(immd_cb->amf_hdl, &immd_cb->comp_name,
&healthy, SA_AMF_HEALTHCHECK_AMF_INVOKED, SA_AMF_COMPONENT_FAILOVER);
if (error != SA_AIS_OK) {
LOG_ER("saAmfHealthcheckStart failed: %u, exiting", error);
exit(1);
}
TRACE_LEAVE();
return NULL;
}
/*****************************************************************************\
* Name: dts_healthcheck_start *
* *
* Description: To start the health check *
* *
* Arguments: NCSSA_CB* - Control Block *
* *
* Returns: NCSCC_RC_SUCCESS - everything is OK *
* NCSCC_RC_FAILURE - failure *
* NOTE: *
\******************************************************************************/
static uns32 dts_healthcheck_start(DTS_CB *cb)
{
SaAisErrorT saf_status = SA_AIS_OK;
if (cb->healthCheckStarted == TRUE) {
return NCSCC_RC_SUCCESS;
}
/* start the healthcheck */
saf_status = saAmfHealthcheckStart(cb->amf_hdl,
&cb->comp_name,
&cb->health_chk_key, cb->invocationType, cb->recommendedRecovery);
if (saf_status != SA_AIS_OK) {
/* log the error */
return m_DTS_DBG_SINK(NCSCC_RC_FAILURE, "dts_healthcheck_start: Failed to start health check.");
}
cb->healthCheckStarted = TRUE;
return NCSCC_RC_SUCCESS;
}
/****************************************************************************
* Name : rde_amf_healthcheck_start
*
* Description : RDE informs AMF to stat healthcheck
*
* Arguments : rde_amf_cb - RDE control block pointer.
*
* Return Values : NCSCC_RC_SUCCESS/NCSCC_RC_FAILURE.
*
* Notes : None.
*****************************************************************************/
static uns32 rde_amf_healthcheck_start(RDE_AMF_CB *rde_amf_cb)
{
uns32 rc = NCSCC_RC_SUCCESS;
SaAisErrorT amf_error;
SaAmfHealthcheckKeyT Healthy;
SaNameT SaCompName;
char *phlth_ptr;
char hlth_str[256];
TRACE_ENTER();
/*
** Start the AMF health check
*/
memset(&SaCompName, 0, sizeof(SaCompName));
strcpy((char*)SaCompName.value, rde_amf_cb->comp_name);
SaCompName.length = strlen(rde_amf_cb->comp_name);
memset(&Healthy, 0, sizeof(Healthy));
phlth_ptr = getenv("RDE_HA_ENV_HEALTHCHECK_KEY");
if (phlth_ptr == NULL) {
/*
** default health check key
*/
strcpy(hlth_str, "BAD10");
} else {
strcpy(hlth_str, phlth_ptr);
}
strcpy((char*)Healthy.key, hlth_str);
Healthy.keyLen = strlen((char*)Healthy.key);
amf_error = saAmfHealthcheckStart(rde_amf_cb->amf_hdl, &SaCompName, &Healthy,
SA_AMF_HEALTHCHECK_AMF_INVOKED, SA_AMF_COMPONENT_RESTART);
if (amf_error != SA_AIS_OK) {
LOG_ER("saAmfHealthcheckStart FAILED %u", amf_error);
rc = NCSCC_RC_FAILURE;
}
return rc;
}
static SaAisErrorT service_start(void)
{
SaAisErrorT rc;
int status;
status = exec_command(start_script);
if (status == 0) {
rc = saAmfHealthcheckStart(my_amf_hdl, &my_comp_name, &my_healthcheck_key,
SA_AMF_HEALTHCHECK_AMF_INVOKED, SA_AMF_COMPONENT_RESTART);
if (rc != SA_AIS_OK) {
syslog(LOG_ERR, "service_start: saAmfHealthcheckStart FAILED (%u)", rc);
return SA_AIS_ERR_FAILED_OPERATION;
}
if (pidfile) {
SaAmfRecommendedRecoveryT recrec = SA_AMF_NO_RECOMMENDATION;
SaInt32T descendentsTreeDepth = 0;
SaAmfPmErrorsT pmErr = SA_AMF_PM_ZERO_EXIT | SA_AMF_PM_NON_ZERO_EXIT;
pid = getpidfromfile(pidfile, true);
syslog(LOG_INFO, "Starting supervision of PID %u", pid);
rc = saAmfPmStart(my_amf_hdl, &my_comp_name, pid, descendentsTreeDepth, pmErr, recrec);
if (SA_AIS_OK != rc) {
syslog(LOG_ERR, "service_start: saAmfPmStart FAILED (%u)", rc);
return SA_AIS_ERR_FAILED_OPERATION;
}
}
}
if (status == 0)
return SA_AIS_OK;
else
return SA_AIS_ERR_FAILED_OPERATION;
}
/****************************************************************************
Name : pxy_pxd_amf_process
Description : This routine is an entry point for the AMF interface task.
It demonstrates the use of following AMF APIs
a) saAmfInitialize
b) saAmfSelectionObjectGet
c) saAmfCompNameGet
d) saAmfComponentRegister
e) saAmfDispatch
Arguments : None.
Return Values : None.
Notes : None
******************************************************************************/
void pxy_pxd_amf_process (void)
{
SaAisErrorT rc;
NCS_SEL_OBJ_SET wait_sel_objs, all_sel_objs;
SaSelectionObjectT pxy_amf_sel_obj,pxd_amf_sel_obj[PXY_PXD_NUM_OF_PROXIED_COMP];
NCS_SEL_OBJ pxy_amf_ncs_sel_obj,pxd_amf_ncs_sel_obj[PXY_PXD_NUM_OF_PROXIED_COMP];
NCS_SEL_OBJ highest_sel_obj,wait_sel_fd;
int ret = 0;
uns32 comp_inv_hc_time_out = 500;
uns32 index = 0;
/* this is to allow to establish MDS session with AvSv */
m_NCS_TASK_SLEEP(3000);
pxy_pxd_proxy_initialize();
rc = pxy_pxd_proxy_amf_init();
if (SA_AIS_OK != rc)
return;
for(index = 0; index < PXY_PXD_NUM_OF_PROXIED_COMP; index++)
rc = pxy_pxd_proxied_amf_init(index);
if (SA_AIS_OK != rc)
return;
/* Get the selection object corresponding to this AMF handle */
rc = saAmfSelectionObjectGet(pxy_pxd_cb.pxy_info.amfHandle, &pxy_amf_sel_obj);
if (SA_AIS_OK != rc)
{
saAmfFinalize(pxy_pxd_cb.pxy_info.amfHandle);
return;
}
for(index = 0; index < PXY_PXD_NUM_OF_PROXIED_COMP; index++)
{
/* Get the selection object corresponding to this AMF handle */
rc = saAmfSelectionObjectGet(pxy_pxd_cb.pxd_info[index].amfHandle,
&pxd_amf_sel_obj[index]);
if (SA_AIS_OK != rc)
{
saAmfFinalize(pxy_pxd_cb.pxy_info.amfHandle);
printf("\n AMF Selection Object Get Failed for index %d !!!\n",index);
return;
}
}
printf("\n AMF Selection Object Get Successful !!! \n");
rc = saAmfComponentNameGet(pxy_pxd_cb.pxy_info.amfHandle,
&pxy_pxd_cb.pxy_info.compName);
if (SA_AIS_OK != rc)
{
saAmfFinalize(pxy_pxd_cb.pxy_info.amfHandle);
return;
}
printf("\n Component Name Get Successful !!! \n CompName: %s \n",
pxy_pxd_cb.pxy_info.compName.value);
rc = saAmfComponentRegister(pxy_pxd_cb.pxy_info.amfHandle,
&pxy_pxd_cb.pxy_info.compName, 0);
if (SA_AIS_OK != rc)
{
saAmfFinalize(pxy_pxd_cb.pxy_info.amfHandle);
return;
}
printf("\n Proxy Component Registered !!! \n");
/* Reset the wait select objects */
m_NCS_SEL_OBJ_ZERO(&all_sel_objs);
m_SET_FD_IN_SEL_OBJ((uns32)pxy_amf_sel_obj, pxy_amf_ncs_sel_obj);
m_NCS_SEL_OBJ_SET(pxy_amf_ncs_sel_obj, &all_sel_objs);
highest_sel_obj = pxy_amf_ncs_sel_obj;
for(index = 0; index < PXY_PXD_NUM_OF_PROXIED_COMP; index++)
{
m_SET_FD_IN_SEL_OBJ((uns32)pxd_amf_sel_obj[index], pxd_amf_ncs_sel_obj[index]);
m_NCS_SEL_OBJ_SET(pxd_amf_ncs_sel_obj[index], &all_sel_objs);
highest_sel_obj = m_GET_HIGHER_SEL_OBJ(highest_sel_obj, pxd_amf_ncs_sel_obj[index]);
}
wait_sel_objs = all_sel_objs;
wait_sel_fd = highest_sel_obj;
/* Now wait forever */
while ((ret = m_NCS_SEL_OBJ_SELECT(wait_sel_fd, &wait_sel_objs, NULL, NULL,
&comp_inv_hc_time_out)) != -1)
{
comp_inv_hc_time_out = 500;
/* Check if it's an event from AMF */
if(m_NCS_SEL_OBJ_ISSET(pxy_amf_ncs_sel_obj, &wait_sel_objs))
{
printf("\n Got Proxy AMF event!!! \n");
/* There is an AMF callback waiting to be be processed. Process it */
rc = saAmfDispatch(pxy_pxd_cb.pxy_info.amfHandle, SA_DISPATCH_ALL);
if (SA_AIS_OK != rc)
{
printf("\n Proxy saAmfDispatch failed !!! \n");
break;
}
}
for(index = 0; index < PXY_PXD_NUM_OF_PROXIED_COMP; index++)
{
if(TRUE == pxy_pxd_cb.pxd_info[index].reg_pxied_comp)
{
printf("\n Before registering pxd[%d]!!!\n",index);
/* Need to register proxied component */
rc = saAmfComponentRegister(pxy_pxd_cb.pxd_info[index].amfHandle,
&pxy_pxd_cb.pxd_info[index].compName,
&pxy_pxd_cb.pxy_info.compName);
if (SA_AIS_OK == rc)
{
printf("\n Proxied[%d] Component Registeration Successful. "
"Comp %s. rc is %d\n",index,
pxy_pxd_cb.pxd_info[index].compName.value,rc);
pxy_pxd_cb.pxd_info[index].health_start = TRUE;
pxy_pxd_cb.pxd_info[index].reg_pxied_comp = FALSE;
}
else if (SA_AIS_ERR_TRY_AGAIN == rc)
{
printf("\n Proxied[%d] Component Registeration failed. TRY_AGAIN"
" Comp %s. rc is %d\n",index,
pxy_pxd_cb.pxd_info[index].compName.value,rc);
}
else
{
printf("\n Proxied[%d] Component Registeration failed."
" Comp %s. rc is %d\n",index,
pxy_pxd_cb.pxd_info[index].compName.value,rc);
pxy_pxd_cb.pxd_info[index].reg_pxied_comp = FALSE;
}
}
} /* if(TRUE == pxy_pxd_cb.reg_pxied_comp) */
/* Section 1 Starts : Health Check : SA_AMF_HEALTHCHECK_AMF_INVOKED */
{
SaAmfHealthcheckInvocationT hc_inv;
SaAmfRecommendedRecoveryT rec_rcvr;
for(index = 0; index < PXY_PXD_NUM_OF_PROXIED_COMP; index++)
{
if(TRUE == pxy_pxd_cb.pxd_info[index].health_start)
{
printf("\n Before registering hc [%d]!!!\n",index);
hc_inv = SA_AMF_HEALTHCHECK_AMF_INVOKED;
rec_rcvr = SA_AMF_COMPONENT_FAILOVER;
rc = saAmfHealthcheckStart(pxy_pxd_cb.pxd_info[index].amfHandle,
&pxy_pxd_cb.pxd_info[index].compName,
&pxy_pxd_cb.pxd_info[index].healthcheck_key,
hc_inv, rec_rcvr);
if (SA_AIS_OK == rc )
{
printf("Started AMF-Initiated HealthCheck (with Component "
"Failover Recommended Recovery) \n Comp: %s \n"
"HealthCheckKey: %s \n",
pxy_pxd_cb.pxd_info[index].compName.value,
pxy_pxd_cb.pxd_info[index].healthcheck_key.key);
pxy_pxd_cb.pxd_info[index].health_start = FALSE;
pxy_pxd_cb.pxd_info[index].health_start_comp_inv = TRUE;
}
else if(SA_AIS_ERR_TRY_AGAIN == rc)
{
printf(" AMF-Initiated HealthCheck TRY_AGAIN (with Component"
" Failover Recommended Recovery) \n Comp: %s \n"
"HealthCheckKey: %s. Res %d \n",
pxy_pxd_cb.pxd_info[index].compName.value,
pxy_pxd_cb.pxd_info[index].healthcheck_key.key, rc);
}
else
{
printf(" AMF-Initiated HealthCheck failed (with Component "
"Failover Recommended Recovery) \n Comp: %s \n"
"HealthCheckKey: %s. Res %d \n",
pxy_pxd_cb.pxd_info[index].compName.value,
pxy_pxd_cb.pxd_info[index].healthcheck_key.key, rc);
pxy_pxd_cb.pxd_info[index].health_start = FALSE;
}
} /* if(TRUE == pxy_pxd_cb.pxd_info[index].health_start)*/
}
}
/* Section 1 Ends : Health Check : SA_AMF_HEALTHCHECK_AMF_INVOKED */
if(TRUE == pxy_pxd_cb.unreg_pxied_comp)
{
for(index = 0; index < PXY_PXD_NUM_OF_PROXIED_COMP; index++)
{
printf("\n Before unregistering PXD[%d]!!! \n",index);
/* Need to unregister proxied component */
rc = saAmfComponentUnregister(pxy_pxd_cb.pxd_info[index].amfHandle,
&pxy_pxd_cb.pxd_info[index].compName,
&pxy_pxd_cb.pxy_info.compName);
if (SA_AIS_OK != rc)
{
printf("\n Proxied Component unreg failed. Comp %s, Pxy Comp %s, Res %d\n",
pxy_pxd_cb.pxd_info[index].compName.value,
pxy_pxd_cb.pxy_info.compName.value,rc);
}
else
printf("\n Proxied Component unreg Succ. Comp %s, Pxy Comp %s\n",
pxy_pxd_cb.pxd_info[index].compName.value,
pxy_pxd_cb.pxy_info.compName.value);
pxy_pxd_cb.unreg_pxied_comp = FALSE;
pxy_pxd_cb.pxd_info[index].health_start_comp_inv = FALSE;
}
}
for(index = 0; index < PXY_PXD_NUM_OF_PROXIED_COMP; index++)
{
/* Check if it's an event from AMF */
if(m_NCS_SEL_OBJ_ISSET(pxd_amf_ncs_sel_obj[index], &wait_sel_objs))
{
printf("\n Before Pxd dispatch PXD[%d] !!!\n",index);
/* There is an AMF callback waiting to be be processed. Process it */
rc = saAmfDispatch(pxy_pxd_cb.pxd_info[index].amfHandle, SA_DISPATCH_ONE);
if (SA_AIS_OK != rc)
{
printf("\n PXD[%d] saAmfDispatch failed !!! \n",index);
break;
}
}
}
/* Again set AMF select object to wait for another callback */
wait_sel_objs = all_sel_objs;
wait_sel_fd = highest_sel_obj;
}/* While loop */
printf("\n\n Proxy Exited, ret %d!!!\n\n",ret);
return;
}
int main (int argc, char **argv) {
int result;
SaSelectionObjectT select_fd;
fd_set read_fds;
extern char *optarg;
extern int optind;
int c;
memset (&compNameGlobal, 0, sizeof (SaNameT));
signal (SIGINT, sigintr_handler);
#if ! defined(TS_CLASS) && (defined(OPENAIS_BSD) || defined(OPENAIS_LINUX) || defined(OPENAIS_SOLARIS))
result = sched_setscheduler (0, SCHED_RR, &sched_param);
if (result == -1) {
printf ("couldn't set sched priority\n");
}
#endif
for (;;){
c = getopt(argc,argv,"h:n:");
if (c==-1) {
break;
}
switch (c) {
case 0 :
break;
case 'h':
health_flag = 0;
sscanf (optarg,"%ud" ,&healthcheck_count);
break;
case 'n':
setSanameT (&compNameGlobal, optarg);
break;
default :
break;
}
}
result = saAmfInitialize (&handle, &amfCallbacks, &version);
if (result != SA_OK) {
printf ("initialize result is %d\n", result);
exit (1);
}
FD_ZERO (&read_fds);
saAmfSelectionObjectGet (handle, &select_fd);
FD_SET (select_fd, &read_fds);
if (compNameGlobal.length <= 0) {
setSanameT (&compNameGlobal, "comp_b_in_su_2");
}
result = saAmfHealthcheckStart (handle,
&compNameGlobal,
&key0,
SA_AMF_HEALTHCHECK_AMF_INVOKED,
SA_AMF_COMPONENT_FAILOVER);
printf ("start %d\n", result);
result = saAmfHealthcheckStart (handle,
&compNameGlobal,
&key0,
SA_AMF_HEALTHCHECK_AMF_INVOKED,
SA_AMF_COMPONENT_FAILOVER);
printf ("start %d\n", result);
result = saAmfComponentRegister (handle, &compNameGlobal, NULL);
printf ("register result is %d (should be 1)\n", result);
do {
select (select_fd + 1, &read_fds, 0, 0, 0);
saAmfDispatch (handle, SA_DISPATCH_ALL);
} while (result && stop == 0);
sleep (5);
result = saAmfHealthcheckStart (handle,
&compNameGlobal,
&key0,
SA_AMF_HEALTHCHECK_AMF_INVOKED,
SA_AMF_COMPONENT_FAILOVER);
do {
select (select_fd + 1, &read_fds, 0, 0, 0);
saAmfDispatch (handle, SA_DISPATCH_ALL);
} while (result);
saAmfFinalize (handle);
exit (0);
}
/****************************************************************************
* Name : gld_se_lib_init
*
* Description : Invoked to Initialize the GLD
*
*
* Arguments :
* Return Values : NCSCC_RC_SUCCESS/NCSCC_RC_FAILURE..
*
* Notes : None.
*****************************************************************************/
uns32 gld_se_lib_init(NCS_LIB_REQ_INFO *req_info)
{
GLSV_GLD_CB *gld_cb;
SaAisErrorT amf_error;
uns32 res = NCSCC_RC_SUCCESS;
SaAmfHealthcheckKeyT Healthy;
int8 *health_key;
/* Register with Logging subsystem */
if (NCS_GLSV_LOG == 1)
gld_flx_log_reg();
/* Allocate and initialize the control block */
gld_cb = m_MMGR_ALLOC_GLSV_GLD_CB;
if (gld_cb == NULL) {
m_LOG_GLD_MEMFAIL(GLD_CB_ALLOC_FAILED, __FILE__, __LINE__);
return NCSCC_RC_FAILURE;
}
memset(gld_cb, 0, sizeof(GLSV_GLD_CB));
/* TBD- Pool id is to be set */
gl_gld_hdl = gld_cb->my_hdl = ncshm_create_hdl(gld_cb->hm_poolid, NCS_SERVICE_ID_GLD, (NCSCONTEXT)gld_cb);
if (0 == gld_cb->my_hdl) {
m_LOG_GLD_HEADLINE(GLD_CREATE_HANDLE_FAILED, NCSFL_SEV_ERROR, __FILE__, __LINE__, 0);
m_MMGR_FREE_GLSV_GLD_CB(gld_cb);
return NCSCC_RC_FAILURE;
}
/* Initialize the cb parameters */
if (gld_cb_init(gld_cb) != NCSCC_RC_SUCCESS) {
m_MMGR_FREE_GLSV_GLD_CB(gld_cb);
return NCSCC_RC_FAILURE;
}
/* Initialize amf framework */
if (gld_amf_init(gld_cb) != NCSCC_RC_SUCCESS) {
m_LOG_GLD_SVC_PRVDR(GLD_AMF_INIT_ERROR, NCSFL_SEV_ERROR, __FILE__, __LINE__);
m_MMGR_FREE_GLSV_GLD_CB(gld_cb);
return NCSCC_RC_FAILURE;
}
m_LOG_GLD_SVC_PRVDR(GLD_AMF_INIT_SUCCESS, NCSFL_SEV_INFO, __FILE__, __LINE__);
/* Bind to MDS */
if (gld_mds_init(gld_cb) != NCSCC_RC_SUCCESS) {
saAmfFinalize(gld_cb->amf_hdl);
m_MMGR_FREE_GLSV_GLD_CB(gld_cb);
m_LOG_GLD_SVC_PRVDR(GLD_MDS_INSTALL_FAIL, NCSFL_SEV_ERROR, __FILE__, __LINE__);
return NCSCC_RC_FAILURE;
} else
m_LOG_GLD_SVC_PRVDR(GLD_MDS_INSTALL_SUCCESS, NCSFL_SEV_INFO, __FILE__, __LINE__);
/* Initialise with the MBCSV service */
if (glsv_gld_mbcsv_register(gld_cb) != NCSCC_RC_SUCCESS) {
m_LOG_GLD_MBCSV(GLD_MBCSV_INIT_FAILED, NCSFL_SEV_ERROR, __FILE__, __LINE__);
gld_mds_shut(gld_cb);
saAmfFinalize(gld_cb->amf_hdl);
m_MMGR_FREE_GLSV_GLD_CB(gld_cb);
return NCSCC_RC_FAILURE;
} else {
m_LOG_GLD_MBCSV(GLD_MBCSV_INIT_SUCCESS, NCSFL_SEV_INFO, __FILE__, __LINE__);
}
/* register glsv with imm */
amf_error = gld_imm_init(gld_cb);
if (amf_error != SA_AIS_OK) {
glsv_gld_mbcsv_unregister(gld_cb);
gld_mds_shut(gld_cb);
saAmfFinalize(gld_cb->amf_hdl);
m_MMGR_FREE_GLSV_GLD_CB(gld_cb);
gld_log(NCSFL_SEV_ERROR, "Imm Init Failed %u\n", amf_error);
return NCSCC_RC_FAILURE;
}
/* TASK CREATION AND INITIALIZING THE MAILBOX */
if ((m_NCS_IPC_CREATE(&gld_cb->mbx) != NCSCC_RC_SUCCESS) ||
(m_NCS_IPC_ATTACH(&gld_cb->mbx) != NCSCC_RC_SUCCESS) ||
(m_NCS_TASK_CREATE((NCS_OS_CB)gld_main_process,
&gld_cb->mbx, "GLD", m_GLD_TASK_PRIORITY,
m_GLD_STACKSIZE,
&gld_cb->task_hdl) != NCSCC_RC_SUCCESS) ||
(m_NCS_TASK_START(gld_cb->task_hdl) != NCSCC_RC_SUCCESS)) {
m_LOG_GLD_HEADLINE(GLD_IPC_TASK_INIT, NCSFL_SEV_ERROR, __FILE__, __LINE__, 0);
saImmOiFinalize(gld_cb->immOiHandle);
glsv_gld_mbcsv_unregister(gld_cb);
gld_mds_shut(gld_cb);
saAmfFinalize(gld_cb->amf_hdl);
m_NCS_TASK_RELEASE(gld_cb->task_hdl);
m_NCS_IPC_RELEASE(&gld_cb->mbx, NULL);
m_MMGR_FREE_GLSV_GLD_CB(gld_cb);
return (NCSCC_RC_FAILURE);
}
m_NCS_EDU_HDL_INIT(&gld_cb->edu_hdl);
/* register GLD component with AvSv */
amf_error = saAmfComponentRegister(gld_cb->amf_hdl, &gld_cb->comp_name, (SaNameT *)NULL);
if (amf_error != SA_AIS_OK) {
m_LOG_GLD_SVC_PRVDR(GLD_AMF_REG_ERROR, NCSFL_SEV_ERROR, __FILE__, __LINE__);
m_NCS_EDU_HDL_FLUSH(&gld_cb->edu_hdl);
m_NCS_TASK_RELEASE(gld_cb->task_hdl);
m_NCS_IPC_RELEASE(&gld_cb->mbx, NULL);
saImmOiFinalize(gld_cb->immOiHandle);
glsv_gld_mbcsv_unregister(gld_cb);
gld_mds_shut(gld_cb);
saAmfFinalize(gld_cb->amf_hdl);
m_MMGR_FREE_GLSV_GLD_CB(gld_cb);
return NCSCC_RC_FAILURE;
} else
m_LOG_GLD_SVC_PRVDR(GLD_AMF_REG_SUCCESS, NCSFL_SEV_INFO, __FILE__, __LINE__);
/** start the AMF health check **/
memset(&Healthy, 0, sizeof(Healthy));
health_key = (int8 *)getenv("GLSV_ENV_HEALTHCHECK_KEY");
if (health_key == NULL) {
if (strlen("A1B2") < sizeof(Healthy.key))
strncpy((char *)Healthy.key, "A1B2", sizeof(Healthy.key));
m_LOG_GLD_HEADLINE(GLD_HEALTH_KEY_DEFAULT_SET, NCSFL_SEV_INFO, __FILE__, __LINE__, 0);
} else {
if (strlen((char *)health_key) < sizeof(Healthy.key))
strncpy((char *)Healthy.key, (char *)health_key, SA_AMF_HEALTHCHECK_KEY_MAX - 1);
}
Healthy.keyLen = strlen((char *)Healthy.key);
amf_error = saAmfHealthcheckStart(gld_cb->amf_hdl, &gld_cb->comp_name, &Healthy,
SA_AMF_HEALTHCHECK_AMF_INVOKED, SA_AMF_COMPONENT_FAILOVER);
if (amf_error != SA_AIS_OK) {
m_LOG_GLD_SVC_PRVDR(GLD_AMF_HLTH_CHK_START_FAIL, NCSFL_SEV_ERROR, __FILE__, __LINE__);
saAmfComponentUnregister(gld_cb->amf_hdl, &gld_cb->comp_name, (SaNameT *)NULL);
m_NCS_EDU_HDL_FLUSH(&gld_cb->edu_hdl);
m_NCS_TASK_RELEASE(gld_cb->task_hdl);
m_NCS_IPC_RELEASE(&gld_cb->mbx, NULL);
saImmOiFinalize(gld_cb->immOiHandle);
glsv_gld_mbcsv_unregister(gld_cb);
gld_mds_shut(gld_cb);
saAmfFinalize(gld_cb->amf_hdl);
m_MMGR_FREE_GLSV_GLD_CB(gld_cb);
} else
m_LOG_GLD_SVC_PRVDR(GLD_AMF_HLTH_CHK_START_DONE, NCSFL_SEV_INFO, __FILE__, __LINE__);
return (res);
}
/****************************************************************************
Name : avsv_amf_csi_set_callback
Description : This routine is a callback to set (add/modify) the HA state
of a CSI (or all the CSIs) that is newly/already assigned
to the component. It is specified as a part of AMF
initialization. It demonstrates the use of following
AMF APIs:
a) saAmfHAStateGet()
b) saAmfHealthcheckStart()
c) saAmfProtectionGroupTrack()
d) saAmfComponentUnregister()
e) saAmfFinalize()
Arguments : inv - particular invocation of this callback function
comp_name - ptr to the component name
ha_state - ha state to be assumed by the CSI (or all the
CSIs)
csi_desc - CSI descriptor
Return Values : None.
Notes : This routine starts health check on the active entity. If
the CSI transitions from standby to active, the demo is
considered over & then the usage of 'Component Unregister' &
'AMF Finalize' is illustrated.
******************************************************************************/
void avsv_amf_csi_set_callback(SaInvocationT inv,
const SaNameT *comp_name,
SaAmfHAStateT ha_state,
SaAmfCSIDescriptorT csi_desc)
{
SaAmfHAStateT ha_st;
SaAisErrorT rc;
SaAmfHealthcheckInvocationT hc_inv;
SaAmfRecommendedRecoveryT rec_rcvr;
SaNameT *csi_name;
SaUint8T trk_flags;
SaAmfProtectionGroupNotificationBufferT *not_buf;
syslog(LOG_INFO, "Dispatched 'CSI Set' Callback for Component: '%s'", comp_name->value);
syslog(LOG_INFO, "\tCSIName: %s \n HAState: %s \n CSIFlags: %s ",
csi_desc.csiName.value, ha_state_str[ha_state], csi_flag_str[csi_desc.csiFlags]);
/* Store the ha state */
gl_ha_state = ha_state;
/* Respond immediately */
rc = saAmfResponse(gl_amf_hdl, inv, SA_AIS_OK);
if ( SA_AIS_OK != rc ) {
syslog(LOG_ERR, "saAmfResponse FAILED - %u", rc);
saAmfComponentUnregister(gl_amf_hdl, &gl_comp_name, 0);
saAmfFinalize(gl_amf_hdl);
return;
}
/*
* If ha-state is active & it's a new assignment, demonstrate the usage
* of ha-state-get & start healthcheck
*/
if ( (SA_AMF_HA_ACTIVE == ha_state) &&
(SA_AMF_CSI_NEW_ASSIGN ==
csi_desc.csiStateDescriptor.activeDescriptor.transitionDescriptor) ) {
/*######################################################################
Demonstrating the use of saAmfHAStateGet()
######################################################################*/
syslog(LOG_INFO, "INVOKING saAmfHAStateGet() API !!!");
sleep(2);
rc = saAmfHAStateGet(gl_amf_hdl, &gl_comp_name, &csi_desc.csiName, &ha_st);
if ( SA_AIS_OK != rc ) {
syslog(LOG_ERR, "saAmfHAStateGet FAILED - %u", rc);
saAmfComponentUnregister(gl_amf_hdl, &gl_comp_name, 0);
saAmfFinalize(gl_amf_hdl);
return;
}
syslog(LOG_INFO, "CompName: %s \n CSIName: %s \n HAState: %s ",
gl_comp_name.value, csi_desc.csiName.value,
ha_state_str[ha_st]);
/*######################################################################
Demonstrating the use of saAmfHealthcheckStart()
######################################################################*/
syslog(LOG_INFO, "DEMONSTRATING AMF-INITIATED HEALTHCHECK !!!");
sleep(2);
/* Fill the healthcheck parameters */
hc_inv = SA_AMF_HEALTHCHECK_AMF_INVOKED;
rec_rcvr = SA_AMF_COMPONENT_FAILOVER;
/* Start the Healthcheck */
rc = saAmfHealthcheckStart(gl_amf_hdl, &gl_comp_name, &gl_healthcheck_key,
hc_inv, rec_rcvr);
if ( SA_AIS_OK != rc ) {
syslog(LOG_ERR, "saAmfHealthcheckStart FAILED - %u", rc);
saAmfComponentUnregister(gl_amf_hdl, &gl_comp_name, 0);
saAmfFinalize(gl_amf_hdl);
return;
}
syslog(LOG_INFO, "Started AMF-Initiated HealthCheck (with Component Failover Recommended Recovery) \n Comp: %s \n HealthCheckKey: %s ",
gl_comp_name.value, gl_healthcheck_key.key);
}
/*
* If ha-state is standby, start tracking the protection group
* associated with this CSI & initiate counter reading from the active
*/
if ( SA_AMF_HA_STANDBY == ha_state ) {
/*######################################################################
Demonstrating the use of saAmfProtectionGroupTrack()
######################################################################*/
/* Fill the protection group track parameters */
csi_name = &csi_desc.csiName;
trk_flags = SA_TRACK_CHANGES_ONLY;
not_buf = NULL;
/* Start Tracking the Protection Group */
rc = saAmfProtectionGroupTrack(gl_amf_hdl, csi_name, trk_flags, not_buf);
if ( SA_AIS_OK != rc ) {
syslog(LOG_ERR, "saAmfProtectionGroupTrack FAILED - %u", rc);
saAmfComponentUnregister(gl_amf_hdl, &gl_comp_name, 0);
saAmfFinalize(gl_amf_hdl);
return;
}
syslog(LOG_INFO, "\n Started Protection Group Tracking \n CSI: %s \n Track Flags: Changes Only ",
csi_name->value);
}
/* If ha-state is active & it is a result of failover, stop the demo */
if ( (SA_AMF_HA_ACTIVE == ha_state) &&
(SA_AMF_CSI_NEW_ASSIGN !=
csi_desc.csiStateDescriptor.activeDescriptor.transitionDescriptor) ) {
syslog(LOG_INFO, "\n\n DEMO OVER (UNREGISTER & FINALIZE THE COMPONENT) !!! ");
/*######################################################################
Demonstrating the use of saAmfComponentUnregister()
######################################################################*/
sleep(15);
rc = saAmfComponentUnregister(gl_amf_hdl, &gl_comp_name, 0);
if ( SA_AIS_OK != rc ) {
syslog(LOG_ERR, "saAmfComponentUnregister FAILED - %u", rc);
return;
}
syslog(LOG_INFO, " Component UnRegistered !!! ");
/*######################################################################
Demonstrating the use of saAmfFinalize()
######################################################################*/
sleep(2);
rc = saAmfFinalize(gl_amf_hdl);
if ( SA_AIS_OK != rc ) {
syslog(LOG_ERR, "saAmfFinalize FAILED - %u", rc);
return;
}
syslog(LOG_INFO, " AMF Finalize Done !!! ");
/* Reset the ha state */
gl_ha_state = 0;
}
}
/****************************************************************************
* Name : glnd_cb_create
*
* Description : This will create the CB and create the internal structures
*
* Arguments : pool id - pool id for the handle manager
*
* Return Values : GLND CB Pointer
*
* Notes : None.
*****************************************************************************/
GLND_CB *glnd_cb_create(uns32 pool_id)
{
GLND_CB *glnd_cb = NULL;
NCS_PATRICIA_PARAMS params = { 0 };
SaAmfHealthcheckKeyT healthy;
int8 *health_key = NULL;
SaAisErrorT amf_error;
/* register with the Log service */
glnd_flx_log_reg();
/* allocate the memory */
glnd_cb = m_MMGR_ALLOC_GLND_CB;
if (!glnd_cb) {
m_LOG_GLND_MEMFAIL(GLND_CB_ALLOC_FAILED, __FILE__, __LINE__);
glnd_flx_log_dereg();
return NULL;
}
memset(glnd_cb, 0, sizeof(GLND_CB));
glnd_cb->pool_id = pool_id;
/* create the handle */
glnd_cb->cb_hdl_id = ncshm_create_hdl((uns8)pool_id, NCS_SERVICE_ID_GLND, (NCSCONTEXT)glnd_cb);
if (!glnd_cb->cb_hdl_id) {
m_LOG_GLND_HEADLINE(GLND_CB_TAKE_HANDLE_FAILED, NCSFL_SEV_ERROR, __FILE__, __LINE__);
goto hdl_err;
}
/* create the internal strucutures */
/* create the client Tree */
params.key_size = sizeof(SaLckHandleT);
params.info_size = 0;
if ((ncs_patricia_tree_init(&glnd_cb->glnd_client_tree, ¶ms)) != NCSCC_RC_SUCCESS) {
m_LOG_GLND_HEADLINE(GLND_CLIENT_TREE_INIT_FAILED, NCSFL_SEV_ERROR, __FILE__, __LINE__);
goto client_err;
}
/* create the agent tree */
params.key_size = sizeof(MDS_DEST);
params.info_size = 0;
if ((ncs_patricia_tree_init(&glnd_cb->glnd_agent_tree, ¶ms)) != NCSCC_RC_SUCCESS) {
m_LOG_GLND_HEADLINE(GLND_AGENT_TREE_INIT_FAILED, NCSFL_SEV_ERROR, __FILE__, __LINE__);
goto agent_err;
}
/* create the Resource tree */
params.key_size = sizeof(SaLckResourceIdT);
params.info_size = 0;
if ((ncs_patricia_tree_init(&glnd_cb->glnd_res_tree, ¶ms)) != NCSCC_RC_SUCCESS) {
m_LOG_GLND_HEADLINE(GLND_RSC_TREE_INIT_FAILED, NCSFL_SEV_ERROR, __FILE__, __LINE__);
goto res_err;
}
/* create the mail box and attach it */
if (m_NCS_IPC_CREATE(&glnd_cb->glnd_mbx) != NCSCC_RC_SUCCESS) {
m_LOG_GLND_HEADLINE(GLND_IPC_CREATE_FAILED, NCSFL_SEV_ERROR, __FILE__, __LINE__);
goto mbx_create_err;
}
if (m_NCS_IPC_ATTACH(&glnd_cb->glnd_mbx) != NCSCC_RC_SUCCESS) {
m_LOG_GLND_HEADLINE(GLND_IPC_ATTACH_FAILED, NCSFL_SEV_ERROR, __FILE__, __LINE__);
goto mbx_attach_err;
}
/* EDU initialisation */
m_NCS_EDU_HDL_INIT(&glnd_cb->glnd_edu_hdl);
/* resigter with the MDS */
if (glnd_mds_register(glnd_cb) != NCSCC_RC_SUCCESS) {
m_LOG_GLND_HEADLINE(GLND_MDS_REGISTER_FAILED, NCSFL_SEV_ERROR, __FILE__, __LINE__);
goto mds_err;
} else
m_LOG_GLND_HEADLINE(GLND_MDS_REGISTER_SUCCESS, NCSFL_SEV_NOTICE, __FILE__, __LINE__);
/* Initialise with the AMF service */
if (glnd_amf_init(glnd_cb) != NCSCC_RC_SUCCESS) {
m_LOG_GLND_HEADLINE(GLND_AMF_INIT_FAILED, NCSFL_SEV_ERROR, __FILE__, __LINE__);
goto amf_init_err;
} else
m_LOG_GLND_HEADLINE(GLND_AMF_INIT_SUCCESS, NCSFL_SEV_NOTICE, __FILE__, __LINE__);
/* register with the AMF service */
if (glnd_amf_register(glnd_cb) != NCSCC_RC_SUCCESS) {
m_LOG_GLND_HEADLINE(GLND_AMF_REGISTER_FAILED, NCSFL_SEV_ERROR, __FILE__, __LINE__);
goto amf_reg_err;
} else
m_LOG_GLND_HEADLINE(GLND_AMF_REGISTER_SUCCESS, NCSFL_SEV_NOTICE, __FILE__, __LINE__);
/* everything went off well.. store the hdl in the global variable */
gl_glnd_hdl = glnd_cb->cb_hdl_id;
/* start the AMF Health Check */
memset(&healthy, 0, sizeof(healthy));
health_key = (int8 *)getenv("GLSV_ENV_HEALTHCHECK_KEY");
if (health_key == NULL) {
if (strlen("A1B2") < sizeof(healthy.key))
strncpy((char *)healthy.key, "A1B2", sizeof(healthy.key));
/* TBD Log the info */
} else {
if (strlen((char *)health_key) <= sizeof(healthy.key))
strncpy((char *)healthy.key, (char *)health_key, SA_AMF_HEALTHCHECK_KEY_MAX - 1);
}
healthy.keyLen = strlen((char *)healthy.key);
amf_error = saAmfHealthcheckStart(glnd_cb->amf_hdl, &glnd_cb->comp_name, &healthy,
SA_AMF_HEALTHCHECK_AMF_INVOKED, SA_AMF_COMPONENT_RESTART);
if (amf_error != SA_AIS_OK) {
m_LOG_GLND_HEADLINE(GLND_AMF_HEALTHCHECK_START_FAILED, NCSFL_SEV_ERROR, __FILE__, __LINE__);
} else
m_LOG_GLND_HEADLINE(GLND_AMF_HEALTHCHECK_START_SUCCESS, NCSFL_SEV_NOTICE, __FILE__, __LINE__);
if (glnd_cb->node_state != GLND_CLIENT_INFO_GET_STATE) {
TRACE("setting the state as GLND_OPERATIONAL_STATE");
/* GLND HAS STRTED */
glnd_cb->node_state = GLND_OPERATIONAL_STATE;
}
/*create a shared memory segment to Checkpint Resource info, lck_info & backup_event info */
if (glnd_shm_create(glnd_cb) != NCSCC_RC_SUCCESS)
goto glnd_shm_create_fail;
return glnd_cb;
glnd_shm_create_fail:
glnd_amf_deregister(glnd_cb);
amf_reg_err:
glnd_amf_de_init(glnd_cb);
amf_init_err:
glnd_mds_unregister(glnd_cb);
mds_err:
m_NCS_EDU_HDL_FLUSH(&glnd_cb->glnd_edu_hdl);
m_NCS_IPC_DETACH(&glnd_cb->glnd_mbx, glnd_cleanup_mbx, glnd_cb);
mbx_attach_err:
m_NCS_IPC_RELEASE(&glnd_cb->glnd_mbx, NULL);
mbx_create_err:
ncs_patricia_tree_destroy(&glnd_cb->glnd_res_tree);
res_err:
ncs_patricia_tree_destroy(&glnd_cb->glnd_agent_tree);
agent_err:
ncs_patricia_tree_destroy(&glnd_cb->glnd_client_tree);
client_err:
ncshm_destroy_hdl(NCS_SERVICE_ID_GLND, glnd_cb->cb_hdl_id);
hdl_err:
glnd_flx_log_dereg();
/* free the control block */
m_MMGR_FREE_GLND_CB(glnd_cb);
return NULL;
}
/**
* Initialize with AMF
* @param amf_sel_obj [out]
*
* @return SaAisErrorT
*/
static SaAisErrorT amf_initialize(SaSelectionObjectT *amf_sel_obj)
{
SaAisErrorT rc;
SaAmfCallbacksT amf_callbacks = {0};
SaVersionT api_ver =
{.releaseCode = 'B', api_ver.majorVersion = 0x01, api_ver.minorVersion = 0x01};
/* Initialize our callbacks */
amf_callbacks.saAmfCSISetCallback = amf_csi_set_callback;
amf_callbacks.saAmfCSIRemoveCallback = amf_csi_remove_callback;
amf_callbacks.saAmfHealthcheckCallback = amf_healthcheck_callback;
amf_callbacks.saAmfComponentTerminateCallback = amf_comp_terminate_callback;
rc = saAmfInitialize(&my_amf_hdl, &amf_callbacks, &api_ver);
if (rc != SA_AIS_OK) {
syslog(LOG_ERR, " saAmfInitialize FAILED %u", rc);
goto done;
}
rc = saAmfSelectionObjectGet(my_amf_hdl, amf_sel_obj);
if (rc != SA_AIS_OK) {
syslog(LOG_ERR, "saAmfSelectionObjectGet FAILED %u", rc);
goto done;
}
rc = saAmfComponentNameGet(my_amf_hdl, &my_comp_name);
if (rc != SA_AIS_OK) {
syslog(LOG_ERR, "saAmfComponentNameGet FAILED %u", rc);
goto done;
}
rc = saAmfComponentRegister(my_amf_hdl, &my_comp_name, 0);
if (rc != SA_AIS_OK) {
syslog(LOG_ERR, "saAmfComponentRegister FAILED %u", rc);
goto done;
}
rc = saAmfHealthcheckStart(my_amf_hdl, &my_comp_name, &my_healthcheck_key,
SA_AMF_HEALTHCHECK_AMF_INVOKED, SA_AMF_COMPONENT_RESTART);
if (rc != SA_AIS_OK) {
syslog(LOG_ERR, "saAmfHealthcheckStart FAILED - %u", rc);
goto done;
}
done:
return rc;
}
int main(int argc, char **argv)
{
SaAisErrorT rc;
SaSelectionObjectT amf_sel_obj;
struct pollfd fds[1];
char *env_comp_name;
/* Environment variable "SA_AMF_COMPONENT_NAME" exist when started by AMF */
if ((env_comp_name = getenv("SA_AMF_COMPONENT_NAME")) == NULL) {
fprintf(stderr, "not started by AMF exiting...\n");
exit(EXIT_FAILURE);
}
/* Daemonize ourselves and detach from terminal.
** This important since our start script will hang forever otherwise.
** Note daemon() is not LSB but impl by libc so fairly portable...
*/
if (daemon(0, 0) == -1) {
syslog(LOG_ERR, "daemon failed: %s", strerror(errno));
goto done;
}
/* Install a TERM handler just to log and visualize when cleanup is called */
if ((signal(SIGTERM, sigterm_handler)) == SIG_ERR) {
syslog(LOG_ERR, "signal TERM failed: %s", strerror(errno));
goto done;
}
/* Create a PID file which is needed by our CLC-CLI script.
** Use AMF component name as file name so multiple instances of this
** component can be managed by the same script.
*/
create_pid_file("/tmp", env_comp_name);
/* Use syslog for logging */
openlog(basename(argv[0]), LOG_PID, LOG_USER);
/* Make a log to associate component name with PID */
syslog(LOG_INFO, "'%s' started", env_comp_name);
if (amf_initialize(&amf_sel_obj) != SA_AIS_OK)
goto done;
syslog(LOG_INFO, "Registered with AMF and HC started");
fds[0].fd = amf_sel_obj;
fds[0].events = POLLIN;
/* Loop forever waiting for events on watched file descriptors */
while (1) {
int res = poll(fds, 1, -1);
if (res == -1) {
if (errno == EINTR)
continue;
else {
syslog(LOG_ERR, "poll FAILED - %s", strerror(errno));
goto done;
}
}
if (fds[0].revents & POLLIN) {
/* An AMF event is received, call AMF dispatch which in turn will
* call our installed callbacks. In context of this main thread.
*/
rc = saAmfDispatch(my_amf_hdl, SA_DISPATCH_ONE);
if (rc != SA_AIS_OK) {
syslog(LOG_ERR, "saAmfDispatch FAILED %u", rc);
goto done;
}
}
}
done:
return EXIT_FAILURE;
}
