/**************************************************************************
Function: smfd_amf_init
Purpose: Function which initializes SMFD with AMF.
Input: None
Returns: SA_AIS_OK - everything is OK
SA_AIS_ERR_* - failure
**************************************************************************/
SaAisErrorT smfd_amf_init(smfd_cb_t * cb)
{
SaAmfCallbacksT amfCallbacks;
SaVersionT amf_version;
SaAisErrorT result;
TRACE_ENTER();
/* Initialize AMF callbacks */
memset(&amfCallbacks, 0, sizeof(SaAmfCallbacksT));
amfCallbacks.saAmfHealthcheckCallback = amf_health_chk_callback;
amfCallbacks.saAmfCSISetCallback = amf_csi_set_callback;
amfCallbacks.saAmfComponentTerminateCallback =
amf_comp_terminate_callback;
amfCallbacks.saAmfCSIRemoveCallback = amf_csi_rmv_callback;
amf_version.releaseCode = 'B';
amf_version.majorVersion = 0x01;
amf_version.minorVersion = 0x01;
/* Initialize the AMF library */
result = saAmfInitialize(&cb->amf_hdl, &amfCallbacks, &amf_version);
if (result != SA_AIS_OK) {
LOG_ER("saAmfInitialize() FAILED: %u", result);
goto done;
}
/* Obtain the AMF selection object to wait for AMF events */
result = saAmfSelectionObjectGet(cb->amf_hdl, &cb->amfSelectionObject);
if (result != SA_AIS_OK) {
LOG_ER("saAmfSelectionObjectGet() FAILED: %u", result);
goto done;
}
/* Get the component name */
result = saAmfComponentNameGet(cb->amf_hdl, &cb->comp_name);
if (result != SA_AIS_OK) {
LOG_ER("saAmfComponentNameGet() FAILED: %u", result);
goto done;
}
/* Register component with AMF */
result =
saAmfComponentRegister(cb->amf_hdl, &cb->comp_name,
(SaNameT *) NULL);
if (result != SA_AIS_OK) {
LOG_ER("saAmfComponentRegister() FAILED");
goto done;
}
/* Start AMF healthchecks */
if ((result = amf_healthcheck_start(cb)) != SA_AIS_OK) {
LOG_ER("health check start FAILED");
goto done;
}
done:
TRACE_LEAVE();
return result;
}
void dispatchLoop(void)
{
SaAisErrorT rc = SA_AIS_OK;
SaSelectionObjectT amf_dispatch_fd;
int maxFd;
fd_set read_fds;
if ( (rc = saAmfSelectionObjectGet(amfHandle, &amf_dispatch_fd)) != SA_AIS_OK)
errorExit(rc);
maxFd = amf_dispatch_fd; /* maxFd = max(amf_dispatch_fd,ckpt_dispatch_fd); */
do
{
FD_ZERO(&read_fds);
FD_SET(amf_dispatch_fd, &read_fds);
/* FD_SET(ckpt_dispatch_fd, &read_fds); */
if( select(maxFd + 1, &read_fds, NULL, NULL, NULL) < 0)
{
char errorStr[80];
int err = errno;
if (EINTR == err) continue;
errorStr[0] = 0; /* just in case strerror does not fill it in */
strerror_r(err, errorStr, 79);
break;
}
if (FD_ISSET(amf_dispatch_fd,&read_fds)) saAmfDispatch(amfHandle, SA_DISPATCH_ALL);
/* if (FD_ISSET(ckpt_dispatch_fd,&read_fds)) saCkptDispatch(ckptLibraryHandle, SA_DISPATCH_ALL); */
}while(!unblockNow);
}
/****************************************************************************
* Name : dts_amf_init
*
* Description : DTS initializes AMF for involking process and registers
* the various callback functions.
*
* Arguments : dts_cb_inst - DTS control block pointer.
*
* Return Values : NCSCC_RC_SUCCESS/NCSCC_RC_FAILURE.
*
* Notes : Changed the function to do intialize of callbacks & selection
* objects. Called from dts_amf_register.
*****************************************************************************/
uns32 dts_amf_init(DTS_CB *dts_cb_inst)
{
SaAmfCallbacksT amfCallbacks;
SaVersionT amf_version;
SaAisErrorT error;
memset(&amfCallbacks, 0, sizeof(SaAmfCallbacksT));
amfCallbacks.saAmfHealthcheckCallback = dts_saf_health_chk_callback;
amfCallbacks.saAmfCSISetCallback = dts_saf_CSI_set_callback;
amfCallbacks.saAmfCSIRemoveCallback = dts_saf_CSI_rem_callback;
amfCallbacks.saAmfComponentTerminateCallback = dts_saf_comp_terminate_callback;
m_DTS_GET_AMF_VER(amf_version);
error = saAmfInitialize((SaAmfHandleT *)&dts_cb_inst->amf_hdl, &amfCallbacks, &amf_version);
if (error != SA_AIS_OK) {
/* Log */
return m_DTS_DBG_SINK(NCSCC_RC_FAILURE, "dts_amf_init: DTS AMF Initialization fails.");
}
/* get the communication Handle */
error = saAmfSelectionObjectGet(dts_cb_inst->amf_hdl, &dts_cb_inst->dts_amf_sel_obj);
if (error != SA_AIS_OK) {
/* log the error */
return m_DTS_DBG_SINK(NCSCC_RC_FAILURE, "dts_amf_init: DTS AMF get selection object get failed.");
}
return (NCSCC_RC_SUCCESS);
}
int main(int argc, char *argv[])
{
SaAisErrorT rc = SA_AIS_OK;
SaSelectionObjectT dispatch_fd;
fd_set read_fds;
ClRcT ret = CL_OK;
/* Connect to the SAF cluster */
initializeAmf();
/* Do the application specific initialization here. */
FD_ZERO(&read_fds);
if ( (rc = saAmfSelectionObjectGet(amfHandle, &dispatch_fd)) != SA_AIS_OK)
errorExit(rc);
FD_SET(dispatch_fd, &read_fds);
/* Handle the AMF dispatch loop by spawning a thread that does it */
ret = clOsalTaskCreateDetached("DISPATCH-THREAD", CL_OSAL_SCHED_OTHER, 0, 0, saAmfDispatchThread, NULL);
if(ret != CL_OK)
{
clprintf(CL_LOG_SEV_ERROR, "Dispatch task create failed with rc 0x%x",rc);
return ret;
}
while (!unblockNow)
{
/* csa112: If I am active then I'll publish an event.
Note, any application can publish and event regardless of
HA state. This tutorial simply uses HA state so only
one of the two processes are publishing.
*/
if (running && ha_state == SA_AMF_HA_ACTIVE)
{
csa113Comp_PublishEvent();
}
sleep(1); /* Keep the event publish rate reasonable for this tutorial*/
}
/* Do the application specific finalization here. */
if ((rc = saEvtChannelClose(evtChannelHandle)) != SA_AIS_OK)
{
clprintf(CL_LOG_SEV_ERROR, "Failed [0x%x] to close event channel", rc);
}
if ((rc = saEvtFinalize(evtLibHandle)) != SA_AIS_OK)
{
clprintf(CL_LOG_SEV_ERROR, "Failed [0x%x] to finalize event library", rc);
}
/* Now finalize my connection with the SAF cluster */
if((rc = saAmfFinalize(amfHandle)) != SA_AIS_OK)
clprintf (CL_LOG_SEV_ERROR, "AMF finalization error[0x%X]", rc);
else
clprintf (CL_LOG_SEV_INFO, "AMF Finalized");
return 0;
}
void dispatchLoop(void)
{
SaAisErrorT rc = SA_AIS_OK;
SaSelectionObjectT amf_dispatch_fd;
int maxFd;
fd_set read_fds;
/*
* Get the AMF dispatch FD for the callbacks
*/
if ( (rc = saAmfSelectionObjectGet(amfHandle, &amf_dispatch_fd)) != SA_AIS_OK)
errorExit(rc);
maxFd = amf_dispatch_fd; /* maxFd = max(amf_dispatch_fd,ckpt_dispatch_fd); */
do
{
FD_ZERO(&read_fds);
FD_SET(amf_dispatch_fd, &read_fds);
if( select(maxFd + 1, &read_fds, NULL, NULL, NULL) < 0)
{
char errorStr[80];
int err = errno;
if (EINTR == err) continue;
errorStr[0] = 0; /* just in case strerror does not fill it in */
strerror_r(err, errorStr, 79);
//clprintf (CL_LOG_SEV_ERROR, "Error [%d] during dispatch loop select() call: [%s]",err,errorStr);
break;
}
if (FD_ISSET(amf_dispatch_fd,&read_fds)) saAmfDispatch(amfHandle, SA_DISPATCH_ALL);
}while(!unblockNow);
}
/****************************************************************************
* Name : plms_amf_init
*
* Description : PLMS initializes AMF for invoking process and registers
* the various callback functions.
*
* Arguments : PLMS_CB - PLMS control block pointer.
*
* Return Values : NCSCC_RC_SUCCESS/Error Code.
*
* Notes : None.
*****************************************************************************/
SaUint32T plms_amf_init()
{
PLMS_CB * cb = plms_cb;
SaAmfCallbacksT amfCallbacks;
SaVersionT amf_version;
uint32_t rc = NCSCC_RC_SUCCESS;
TRACE_ENTER();
if (cb->nid_started &&
amf_comp_name_get_set_from_file("PLMD_COMP_NAME_FILE", &cb->comp_name) != NCSCC_RC_SUCCESS)
goto done;
/* Initialize amf callbacks */
memset(&amfCallbacks, 0, sizeof(SaAmfCallbacksT));
amfCallbacks.saAmfHealthcheckCallback = plms_amf_health_chk_callback;
amfCallbacks.saAmfCSISetCallback = plms_amf_CSI_set_callback;
amfCallbacks.saAmfComponentTerminateCallback = plms_amf_comp_terminate_callback;
amfCallbacks.saAmfCSIRemoveCallback = plms_amf_csi_rmv_callback;
m_PLMS_GET_AMF_VER(amf_version);
/*Initialize the amf library */
rc = saAmfInitialize(&cb->amf_hdl, &amfCallbacks, &amf_version);
if (rc != SA_AIS_OK) {
LOG_ER(" plms_amf_init: saAmfInitialize() AMF initialization FAILED\n");
goto done;
}
LOG_IN(" plms_amf_init: saAmfInitialize() AMF initialization SUCCESS\n");
/* Obtain the amf selection object to wait for amf events */
if (SA_AIS_OK != (rc = saAmfSelectionObjectGet(cb->amf_hdl, &cb->amf_sel_obj))) {
LOG_ER("saAmfSelectionObjectGet() FAILED\n");
goto done;
}
LOG_IN("saAmfSelectionObjectGet() SUCCESS\n");
/* get the component name */
rc = saAmfComponentNameGet(cb->amf_hdl, &cb->comp_name);
if (rc != SA_AIS_OK) {
LOG_ER(" plmss_amf_init: saAmfComponentNameGet() FAILED\n");
goto done ;
}
rc = NCSCC_RC_SUCCESS;
done:
TRACE_LEAVE2("%u, %s", rc, cb->comp_name.value);
return rc;
} /*End plms_amf_init */
uns32 rde_amf_init(RDE_AMF_CB *rde_amf_cb)
{
uns32 rc = NCSCC_RC_SUCCESS;
SaAisErrorT amf_error = SA_AIS_OK;
SaNameT sname;
SaAmfCallbacksT amfCallbacks;
SaVersionT amf_version;
TRACE_ENTER();
if (amf_comp_name_get_set_from_file("RDE_COMP_NAME_FILE", &sname) != NCSCC_RC_SUCCESS)
return NCSCC_RC_FAILURE;
amfCallbacks.saAmfHealthcheckCallback = rde_saf_health_chk_callback;
amfCallbacks.saAmfCSISetCallback = rde_saf_CSI_set_callback;
amfCallbacks.saAmfCSIRemoveCallback = rde_saf_CSI_rem_callback;
amfCallbacks.saAmfComponentTerminateCallback = rde_saf_comp_terminate_callback;
m_RDE_GET_AMF_VER(amf_version);
amf_error = saAmfInitialize(&rde_amf_cb->amf_hdl, &amfCallbacks, &amf_version);
if (amf_error != SA_AIS_OK) {
LOG_ER("saAmfInitialize FAILED %u", amf_error);
return NCSCC_RC_FAILURE;
}
memset(&sname, 0, sizeof(sname));
amf_error = saAmfComponentNameGet(rde_amf_cb->amf_hdl, &sname);
if (amf_error != SA_AIS_OK) {
LOG_ER("saAmfComponentNameGet FAILED %u", amf_error);
return NCSCC_RC_FAILURE;
}
strcpy((char*)rde_amf_cb->comp_name, (char*)sname.value);
amf_error = saAmfSelectionObjectGet(rde_amf_cb->amf_hdl, &rde_amf_cb->amf_fd);
if (amf_error != SA_AIS_OK) {
LOG_ER("saAmfSelectionObjectGet FAILED %u", amf_error);
return NCSCC_RC_FAILURE;
}
amf_error = saAmfComponentRegister(rde_amf_cb->amf_hdl, &sname, (SaNameT *)NULL);
if (amf_error != SA_AIS_OK) {
LOG_ER("saAmfComponentRegister FAILED %u", amf_error);
return NCSCC_RC_FAILURE;
}
rc = rde_amf_healthcheck_start(rde_amf_cb);
if (rc != NCSCC_RC_SUCCESS)
return NCSCC_RC_FAILURE;
TRACE_LEAVE2("AMF Initialization SUCCESS......");
return(rc);
}
void dispatchLoop(void)
{
SaAisErrorT rc = SA_AIS_OK;
SaSelectionObjectT amf_dispatch_fd;
int maxFd;
fd_set read_fds;
/* This boilerplate code includes an example of how to simultaneously
dispatch for 2 services (in this case AMF and CKPT). But since checkpoint
is not initialized or used, it is commented out */
/* SaSelectionObjectT ckpt_dispatch_fd; */
/*
* Get the AMF dispatch FD for the callbacks
*/
if ( (rc = saAmfSelectionObjectGet(amfHandle, &amf_dispatch_fd)) != SA_AIS_OK)
errorExit(rc);
/* if ( (rc = saCkptSelectionObjectGet(ckptLibraryHandle, &ckpt_dispatch_fd)) != SA_AIS_OK)
errorExit(rc); */
maxFd = amf_dispatch_fd; /* maxFd = max(amf_dispatch_fd,ckpt_dispatch_fd); */
do
{
FD_ZERO(&read_fds);
FD_SET(amf_dispatch_fd, &read_fds);
/* FD_SET(ckpt_dispatch_fd, &read_fds); */
if( select(maxFd + 1, &read_fds, NULL, NULL, NULL) < 0)
{
char errorStr[80];
int err = errno;
if (EINTR == err) continue;
errorStr[0] = 0; /* just in case strerror does not fill it in */
strerror_r(err, errorStr, 79);
//clprintf (CL_LOG_SEV_ERROR, "Error [%d] during dispatch loop select() call: [%s]",err,errorStr);
break;
}
if (FD_ISSET(amf_dispatch_fd,&read_fds)) saAmfDispatch(amfHandle, SA_DISPATCH_ALL);
/* if (FD_ISSET(ckpt_dispatch_fd,&read_fds)) saCkptDispatch(ckptLibraryHandle, SA_DISPATCH_ALL); */
}while(!unblockNow);
}
static void* amfDispatcher(void *param)
{
SaSelectionObjectT dispatch_fd;
fd_set read_fds;
ClRcT rc;
FD_ZERO(&read_fds);
/*
* Get the AMF dispatch FD for the callbacks
*/
if ( (rc = saAmfSelectionObjectGet(amfHandle, &dispatch_fd)) != SA_AIS_OK)
{
clprintf (CL_LOG_SEV_ERROR, "Error getting selection object -- unable to dispatch AMF events");
return NULL;
}
FD_SET(dispatch_fd, &read_fds);
/*
* Block on AMF dispatch file descriptor for callbacks
*/
do
{
if( select(dispatch_fd + 1, &read_fds, NULL, NULL, NULL) < 0)
{
clprintf (CL_LOG_SEV_ERROR, "Error in select() -- unable to dispatch AMF events");
perror("");
break;
}
saAmfDispatch(amfHandle, SA_DISPATCH_ALL);
}while(!unblockNow);
return NULL;
}
/****************************************************************************
* Name : glnd_main_process
*
* Description : This is the function which is given as a input to the
* GLND task.
*
* Arguments : mbx - This is the mail box pointer on which GLND is
* going to block.
*
* Return Values : None.
*
* Notes : None.
*****************************************************************************/
void glnd_main_process(SYSF_MBX *mbx)
{
NCS_SEL_OBJ mbx_fd = m_NCS_IPC_GET_SEL_OBJ(mbx);
GLND_CB *glnd_cb = NULL;
TRACE_ENTER();
SaAmfHandleT amf_hdl;
SaSelectionObjectT amf_sel_obj;
SaAisErrorT amf_error;
struct pollfd sel[NUM_FD];
int term_fd;
/* take the handle */
glnd_cb = (GLND_CB *)m_GLND_TAKE_GLND_CB;
if (!glnd_cb) {
LOG_ER("GLND cb take handle failed");
goto end;
}
amf_hdl = glnd_cb->amf_hdl;
/*giveup the handle */
m_GLND_GIVEUP_GLND_CB;
amf_error = saAmfSelectionObjectGet(amf_hdl, &amf_sel_obj);
if (amf_error != SA_AIS_OK) {
LOG_ER("GLND amf get sel obj error");
goto end;
}
daemon_sigterm_install(&term_fd);
sel[FD_TERM].fd = term_fd;
sel[FD_TERM].events = POLLIN;
sel[FD_AMF].fd = amf_sel_obj;
sel[FD_AMF].events = POLLIN;
sel[FD_MBX].fd = m_GET_FD_FROM_SEL_OBJ(mbx_fd);
sel[FD_MBX].events = POLLIN;
while (osaf_poll(&sel[0], NUM_FD, -1) > 0) {
if (sel[FD_TERM].revents & POLLIN) {
daemon_exit();
}
if (((sel[FD_AMF].revents | sel[FD_MBX].revents) &
(POLLERR | POLLHUP | POLLNVAL)) != 0) {
LOG_ER("GLND poll() failure: %hd %hd",
sel[FD_AMF].revents, sel[FD_MBX].revents);
TRACE_LEAVE();
return;
}
/* process all the AMF messages */
if (sel[FD_AMF].revents & POLLIN) {
/* dispatch all the AMF pending function */
amf_error = saAmfDispatch(amf_hdl, SA_DISPATCH_ALL);
if (amf_error != SA_AIS_OK) {
TRACE_2("GLND amf dispatch failure");
}
}
/* process the GLND Mail box */
if (sel[FD_MBX].revents & POLLIN) {
glnd_cb = (GLND_CB *)m_GLND_TAKE_GLND_CB;
if (glnd_cb) {
/* now got the IPC mail box event */
glnd_process_mbx(glnd_cb, mbx);
m_GLND_GIVEUP_GLND_CB; /* giveup the handle */
} else
break;
}
}
TRACE("DANGER: Exiting the Select loop of GLND");
end:
TRACE_LEAVE();
return;
}
static PyObject* initializeAmf(PyObject *self, PyObject *args)
{
SaNameT appName = {0};
SaAmfCallbacksT callbacks;
SaVersionT version;
ClIocPortT iocPort;
ClRcT rc = SA_AIS_OK;
PyEval_InitThreads();
PyThreadState* pts = PyThreadState_Get();
thePythonInterpreter = pts->interp;
/* Put the EO name received from the environment in the appropriate variable */
//strncpy(clEoConfig.EOname,getenv("ASP_COMPNAME"),CL_EO_MAX_NAME_LEN-1);
mypid = getpid();
/*
* Initialize and register with CPM. 'version' specifies the
* version of AMF with which this application would like to
* interface. 'callbacks' is used to register the callbacks this
* component expects to receive.
*/
version.releaseCode = 'B';
version.majorVersion = 01;
version.minorVersion = 01;
callbacks.saAmfHealthcheckCallback = NULL;
callbacks.saAmfComponentTerminateCallback = clCompAppTerminate;
callbacks.saAmfCSISetCallback = clCompAppAMFCSISet;
callbacks.saAmfCSIRemoveCallback = clCompAppAMFCSIRemove;
callbacks.saAmfProtectionGroupTrackCallback = NULL;
/*
* Initialize AMF client library.
*/
if ( (rc = saAmfInitialize(&amfHandle, &callbacks, &version)) != SA_AIS_OK)
goto errorexit;
clprintf (CL_LOG_SEV_INFO, "AmfInitialize successful");
if (1)
{
SaSelectionObjectT dispatch_fd;
fd_set read_fds;
FD_ZERO(&read_fds);
/*
* Get the AMF dispatch FD for the callbacks
*/
if ( (rc = saAmfSelectionObjectGet(amfHandle, &dispatch_fd)) != SA_AIS_OK)
{
clprintf (CL_LOG_SEV_ERROR, "Error getting selection object -- unable to dispatch AMF events");
return NULL;
}
}
/*
* Do the application specific initialization here.
*/
/*
* ---BEGIN_APPLICATION_CODE---
*/
#if 0
if (1)
{
void (*extensions[])(void) = { init_asp, initasppycustom, 0 };
clPyGlueInit("clusterMgrApp",extensions);
}
#endif
/*
* ---END_APPLICATION_CODE---
*/
/*
* Now register the component with AMF. At this point it is
* ready to provide service, i.e. take work assignments.
*/
if ( (rc = saAmfComponentNameGet(amfHandle, &appName)) != SA_AIS_OK)
goto errorexit;
clprintf (CL_LOG_SEV_INFO, "component name get successful");
if ( (rc = saAmfComponentRegister(amfHandle, &appName, NULL)) != SA_AIS_OK)
goto errorexit;
clprintf (CL_LOG_SEV_INFO, "component register successful");
/*
* Print out standard information for this component.
*/
clEoMyEoIocPortGet(&iocPort);
clprintf (CL_LOG_SEV_INFO, "Component [%s] : PID [%d]. Initializing\n", appName.value, mypid);
clprintf (CL_LOG_SEV_INFO, " IOC Address : 0x%x\n", clIocLocalAddressGet());
clprintf (CL_LOG_SEV_INFO, " IOC Port : 0x%x\n", iocPort);
/*
* ---BEGIN_APPLICATION_CODE---
*/
//clPyGlueStart();
/*
* ---END_APPLICATION_CODE---
*/
rc = clOsalTaskCreateDetached("AmfDispatcher",CL_OSAL_SCHED_OTHER, CL_OSAL_THREAD_PRI_NOT_APPLICABLE, 0, amfDispatcher,NULL);
errorexit:
if (rc != CL_OK)
{
char str[256];
snprintf(str,255,"Component [%s] : PID [%d]. Initialization error [0x%x]\n", appName.value, mypid, rc);
clprintf (CL_LOG_SEV_ERROR, str);
//return PyInt_FromLong(rc);
PyObject* errData = Py_BuildValue("is",rc,str);
PyErr_SetObject(PyExc_SystemError,errData);
return NULL;
}
Py_RETURN_NONE;
}
/**************************************************************************
Function: ntfs_amf_register
Purpose: Function which registers NTFS with AMF.
Input: None
Returns: SA_AIS_OK - everything is OK
SA_AIS_ERR_* - failure
**************************************************************************/
SaAisErrorT ntfs_amf_init()
{
SaAmfCallbacksT amfCallbacks;
SaVersionT amf_version;
SaAisErrorT error = SA_AIS_OK;
TRACE_ENTER();
if (ntfs_cb->nid_started &&
amf_comp_name_get_set_from_file("NTFD_COMP_NAME_FILE", &ntfs_cb->comp_name) != NCSCC_RC_SUCCESS)
goto done;
/* Initialize AMF callbacks */
memset(&amfCallbacks, 0, sizeof(SaAmfCallbacksT));
amfCallbacks.saAmfHealthcheckCallback = amf_health_chk_callback;
amfCallbacks.saAmfCSISetCallback = amf_csi_set_callback;
amfCallbacks.saAmfComponentTerminateCallback = amf_comp_terminate_callback;
amfCallbacks.saAmfCSIRemoveCallback = amf_csi_rmv_callback;
amf_version.releaseCode = 'B';
amf_version.majorVersion = 0x01;
amf_version.minorVersion = 0x01;
/* Initialize the AMF library */
error = saAmfInitialize(&ntfs_cb->amf_hdl, &amfCallbacks, &amf_version);
if (error != SA_AIS_OK) {
LOG_ER("saAmfInitialize() FAILED: %u", error);
goto done;
}
/* Obtain the AMF selection object to wait for AMF events */
error = saAmfSelectionObjectGet(ntfs_cb->amf_hdl, &ntfs_cb->amfSelectionObject);
if (error != SA_AIS_OK) {
LOG_ER("saAmfSelectionObjectGet() FAILED: %u", error);
goto done;
}
/* Get the component name */
error = saAmfComponentNameGet(ntfs_cb->amf_hdl, &ntfs_cb->comp_name);
if (error != SA_AIS_OK) {
LOG_ER("saAmfComponentNameGet() FAILED: %u", error);
goto done;
}
/* Register component with AMF */
error = saAmfComponentRegister(ntfs_cb->amf_hdl, &ntfs_cb->comp_name, (SaNameT *)NULL);
if (error != SA_AIS_OK) {
LOG_ER("saAmfComponentRegister() FAILED");
goto done;
}
/* Start AMF healthchecks */
if (ntfs_amf_healthcheck_start() != SA_AIS_OK){
LOG_ER("ntfs_amf_healthcheck_start() FAILED");
error = NCSCC_RC_FAILURE;
goto done;
}
done:
TRACE_LEAVE();
return error;
}
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_main_process
*
* Description : This is the function which is given as a input to the
* GLD task.
* This function will be select of both the FD's (AMF FD and
* Mail Box FD), depending on which FD has been selected, it
* will call the corresponding routines.
*
* Arguments : mbx - This is the mail box pointer on which GLD is
* going to block.
*
* Return Values : None.
*
* Notes : None.
*****************************************************************************/
static void gld_main_process(SYSF_MBX *mbx)
{
NCS_SEL_OBJ mbx_fd;
SaAisErrorT error = SA_AIS_OK;
GLSV_GLD_CB *gld_cb = NULL;
NCS_MBCSV_ARG mbcsv_arg;
SaSelectionObjectT amf_sel_obj;
if ((gld_cb = (GLSV_GLD_CB *)ncshm_take_hdl(NCS_SERVICE_ID_GLD, gl_gld_hdl))
== NULL) {
m_LOG_GLD_HEADLINE(GLD_TAKE_HANDLE_FAILED, NCSFL_SEV_ERROR, __FILE__, __LINE__, 0);
return;
}
mbx_fd = ncs_ipc_get_sel_obj(&gld_cb->mbx);
error = saAmfSelectionObjectGet(gld_cb->amf_hdl, &amf_sel_obj);
if (error != SA_AIS_OK) {
m_LOG_GLD_SVC_PRVDR(GLD_AMF_SEL_OBJ_GET_ERROR, NCSFL_SEV_ERROR, __FILE__, __LINE__);
return;
}
/* Set up all file descriptors to listen to */
fds[FD_AMF].fd = amf_sel_obj;
fds[FD_AMF].events = POLLIN;
fds[FD_MBCSV].fd = gld_cb->mbcsv_sel_obj;
fds[FD_MBCSV].events = POLLIN;
fds[FD_MBX].fd = mbx_fd.rmv_obj;
fds[FD_MBX].events = POLLIN;
fds[FD_IMM].fd = gld_cb->imm_sel_obj;
fds[FD_IMM].events = POLLIN;
while (1) {
if (gld_cb->immOiHandle != 0) {
fds[FD_IMM].fd = gld_cb->imm_sel_obj;
fds[FD_IMM].events = POLLIN;
nfds = FD_IMM + 1;
} else {
nfds = FD_IMM;
}
int ret = poll(fds, nfds, -1);
if (ret == -1) {
if (errno == EINTR)
continue;
gld_log(NCSFL_SEV_ERROR, "poll failed - %s", strerror(errno));
break;
}
if (fds[FD_AMF].revents & POLLIN) {
if (gld_cb->amf_hdl != 0) {
/* dispatch all the AMF pending function */
error = saAmfDispatch(gld_cb->amf_hdl, SA_DISPATCH_ALL);
if (error != SA_AIS_OK) {
m_LOG_GLD_SVC_PRVDR(GLD_AMF_DISPATCH_ERROR, NCSFL_SEV_ERROR, __FILE__,
__LINE__);
}
} else
gld_log(NCSFL_SEV_ERROR, "gld_cb->amf_hdl == 0");
}
if (fds[FD_MBCSV].revents & POLLIN) {
/* dispatch all the MBCSV pending callbacks */
mbcsv_arg.i_op = NCS_MBCSV_OP_DISPATCH;
mbcsv_arg.i_mbcsv_hdl = gld_cb->mbcsv_handle;
mbcsv_arg.info.dispatch.i_disp_flags = SA_DISPATCH_ALL;
if (ncs_mbcsv_svc(&mbcsv_arg) != SA_AIS_OK) {
m_LOG_GLD_HEADLINE(GLD_MBCSV_DISPATCH_FAILURE, NCSFL_SEV_ERROR, __FILE__, __LINE__, 0);
}
}
if (fds[FD_MBX].revents & POLLIN)
gld_process_mbx(mbx);
/* process the IMM messages */
if (gld_cb->immOiHandle && fds[FD_IMM].revents & POLLIN) {
/* dispatch all the IMM pending function */
error = saImmOiDispatch(gld_cb->immOiHandle, SA_DISPATCH_ONE);
/*
** BAD_HANDLE is interpreted as an IMM service restart. Try
** reinitialize the IMM OI API in a background thread and let
** this thread do business as usual especially handling write
** requests.
**
** All other errors are treated as non-recoverable (fatal) and will
** cause an exit of the process.
*/
if (error == SA_AIS_ERR_BAD_HANDLE) {
gld_log(NCSFL_SEV_ERROR, "saImmOiDispatch returned BAD_HANDLE %u", error);
/*
** Invalidate the IMM OI handle, this info is used in other
** locations. E.g. giving TRY_AGAIN responses to a create and
** close resource requests. That is needed since the IMM OI
** is used in context of these functions.
*/
gld_cb->immOiHandle = 0;
gld_imm_reinit_bg(gld_cb);
} else if (error != SA_AIS_OK) {
gld_log(NCSFL_SEV_ERROR, "saImmOiDispatch FAILED: %u", error);
break;
}
}
}
return;
}
/**
* 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;
}
/****************************************************************************
* Name : amf_init
*
* Description : Initialize AMF for involking process and register
* the various callback functions.
*
* Arguments : immd_cb - IMMD control block pointer.
*
* Return Values : NCSCC_RC_SUCCESS/NCSCC_RC_FAILURE.
*
* Notes : None.
*****************************************************************************/
uint32_t immd_amf_init(IMMD_CB *immd_cb)
{
static SaAmfCallbacksT amfCallbacks;
SaVersionT amf_version;
SaAisErrorT error;
uint32_t res = NCSCC_RC_FAILURE;
pthread_t thread;
pthread_attr_t attr;
TRACE_ENTER();
if (immd_cb->nid_started &&
amf_comp_name_get_set_from_file("IMMD_COMP_NAME_FILE",
&immd_cb->comp_name) != NCSCC_RC_SUCCESS)
goto done;
memset(&amfCallbacks, 0, sizeof(SaAmfCallbacksT));
amfCallbacks.saAmfHealthcheckCallback = immd_saf_hlth_chk_cb;
amfCallbacks.saAmfCSISetCallback = immd_saf_csi_set_cb;
amfCallbacks.saAmfComponentTerminateCallback = immd_amf_comp_terminate_callback;
amfCallbacks.saAmfCSIRemoveCallback = immd_amf_csi_rmv_callback;
m_IMMSV_GET_AMF_VER(amf_version);
/*
* Perform the non blocking part of initialization.
* If the AMF implementation of these calls would change and become
* synchronous, this code would have to be changed too.
*/
error = saAmfInitialize(&immd_cb->amf_hdl, &amfCallbacks, &amf_version);
if (error != SA_AIS_OK) {
LOG_ER("saAmfInitialize failed");
goto done;
}
error = saAmfComponentNameGet(immd_cb->amf_hdl, &immd_cb->comp_name);
if (error != SA_AIS_OK) {
LOG_ER("saAmfComponentNameGet failed");
goto done;
}
error = saAmfSelectionObjectGet(immd_cb->amf_hdl, &immd_cb->amf_sel_obj);
if (error != SA_AIS_OK) {
LOG_ER("saAmfSelectionObjectGet failed");
goto done;
}
/* Start a thread to take care of the blocking part of initialization */
pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
if (pthread_create(&thread, &attr, amf_init_start, NULL) != 0) {
LOG_ER("pthread_create FAILED: %s", strerror(errno));
goto done;
}
pthread_attr_destroy(&attr);
res = NCSCC_RC_SUCCESS;
done:
TRACE_LEAVE2("%u, %s", res, osaf_extended_name_borrow(&immd_cb->comp_name));
return res;
}
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};
amf_callbacks.saAmfCSISetCallback = csi_set_callback;
amf_callbacks.saAmfCSIRemoveCallback = csi_remove_callback;
amf_callbacks.saAmfHealthcheckCallback = healthcheck_callback;
amf_callbacks.saAmfComponentTerminateCallback = 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;
}
done:
return rc;
}
int main(int argc, char **argv)
{
SaAisErrorT rc;
SaSelectionObjectT amf_sel_obj;
struct pollfd fds[1];
int logmask;
if (daemon(0, 0) == -1) {
syslog(LOG_ERR, "daemon failed: %s", strerror(errno));
goto done;
}
create_pid_file();
/* Cancel certain signals that would kill us */
signal(SIGTERM, SIG_IGN);
signal(SIGHUP, SIG_IGN);
signal(SIGUSR1, SIG_IGN);
signal(SIGUSR2, SIG_IGN);
openlog(basename(argv[0]), LOG_PID, LOG_USER);
// TBD: Configure logmask from args/vars
logmask = LOG_UPTO(LOG_INFO);
// setlogmask(logmask);
start_script = getenv("STARTSCRIPT");
if (start_script == NULL) {
syslog(LOG_ERR, "Variable STARTCRIPT missing");
goto done;
}
stop_script = getenv("STOPSCRIPT");
if (stop_script == NULL) {
syslog(LOG_ERR, "Variable STOPSCRIPT missing");
goto done;
}
health_script = getenv("HEALTHCHECKSCRIPT");
if (health_script == NULL) {
syslog(LOG_ERR, "Variable HEALTHCHECKSCRIPT missing");
goto done;
}
pidfile = getenv("PIDFILE");
if (amf_initialize(&amf_sel_obj) != SA_AIS_OK)
goto done;
fds[0].fd = amf_sel_obj;
fds[0].events = POLLIN;
syslog(LOG_INFO, "'%s' started", getenv("SA_AMF_COMPONENT_NAME"));
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) {
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;
}
/****************************************************************************
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;
}
/****************************************************************************
Name : avsv_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 *avsv_amf_process (void* dummy)
{
SaAmfCallbacksT reg_callback_set;
SaVersionT ver;
SaAisErrorT rc;
SaSelectionObjectT amf_sel_obj;
struct pollfd fds[1];
syslog(LOG_INFO, " AMF thread entered");
/*#########################################################################
Demonstrating the use of saAmfInitialize()
#########################################################################*/
/* Fill the callbacks that are to be registered with AMF */
memset(®_callback_set, 0, sizeof(SaAmfCallbacksT));
reg_callback_set.saAmfCSISetCallback = avsv_amf_csi_set_callback;
reg_callback_set.saAmfCSIRemoveCallback = avsv_amf_csi_remove_callback;
reg_callback_set.saAmfHealthcheckCallback = avsv_amf_healthcheck_callback;
reg_callback_set.saAmfComponentTerminateCallback = avsv_amf_comp_terminate_callback;
reg_callback_set.saAmfProtectionGroupTrackCallback = avsv_amf_protection_group_callback;
/* Fill the AMF version */
m_AMF_VER_GET(ver);
/* Initialize AMF */
rc = saAmfInitialize(&gl_amf_hdl, ®_callback_set, &ver);
if (SA_AIS_OK != rc) {
syslog(LOG_ERR, " saAmfInitialize FAILED %u", rc);
goto done;
}
syslog(LOG_INFO, "AMF Initialization Done !!!");
syslog(LOG_INFO, "\tAmfHandle: %llx ", gl_amf_hdl);
/*#########################################################################
Demonstrating the use of saAmfSelectionObjectGet()
#########################################################################*/
/* Get the selection object corresponding to this AMF handle */
rc = saAmfSelectionObjectGet(gl_amf_hdl, &amf_sel_obj);
if (SA_AIS_OK != rc) {
syslog(LOG_ERR, "saAmfSelectionObjectGet FAILED %u", rc);
saAmfFinalize(gl_amf_hdl);
goto done;
}
syslog(LOG_INFO, "AMF Selection Object Get Successful !!!");
/*#########################################################################
Demonstrating the use of saAmfCompNameGet()
#########################################################################*/
rc = saAmfComponentNameGet(gl_amf_hdl, &gl_comp_name);
if (SA_AIS_OK != rc) {
syslog(LOG_ERR, "saAmfComponentNameGet FAILED %u", rc);
saAmfFinalize(gl_amf_hdl);
goto done;
}
syslog(LOG_INFO, "Component Name Get Successful !!!");
syslog(LOG_INFO, "\tCompName: %s", gl_comp_name.value);
/*#########################################################################
Demonstrating the use of saAmfComponentRegister()
#########################################################################*/
rc = saAmfComponentRegister(gl_amf_hdl, &gl_comp_name, 0);
if (SA_AIS_OK != rc) {
syslog(LOG_ERR, "saAmfComponentRegister FAILED %u", rc);
saAmfFinalize(gl_amf_hdl);
goto done;
}
syslog(LOG_INFO, "Component Registered !!!");
fds[0].fd = amf_sel_obj;
fds[0].events = POLLIN;
/***** Now wait on the AMF selection object *****/
while (1) {
int res = poll(fds, 1, -1);
if (res == -1) {
if (errno == EINTR)
continue;
else {
syslog(LOG_ERR, "poll FAILED - %s", strerror(errno));
exit(1);
}
}
/*######################################################################
Demonstrating the use of saAmfDispatch()
######################################################################*/
if (fds[0].revents & POLLIN) {
/* There is an AMF callback waiting to be be processed. Process it */
rc = saAmfDispatch(gl_amf_hdl, SA_DISPATCH_ONE);
if (SA_AIS_OK != rc) {
syslog(LOG_ERR, "saAmfDispatch FAILED %u", rc);
saAmfComponentUnregister(gl_amf_hdl, &gl_comp_name, 0);
saAmfFinalize(gl_amf_hdl);
break;
}
}
}
syslog(LOG_INFO, "DEMO OVER !!!");
done:
return NULL;
}
int main(int argc, char *argv[])
{
SaNameT appName = {0};
SaAmfCallbacksT callbacks;
SaVersionT version;
ClIocPortT iocPort;
SaAisErrorT rc = SA_AIS_OK;
SaSelectionObjectT dispatch_fd;
fd_set read_fds;
/*
* Declare other local variables here.
*/
/*
* Get the pid for the process and store it in global variable.
*/
mypid = getpid();
/*
* Initialize and register with CPM. 'version' specifies the version of
* AMF with which this application would like to interface. 'callbacks'
* is used to register the callbacks this component expects to receive.
*/
version.releaseCode = 'B';
version.majorVersion = 01;
version.minorVersion = 01;
callbacks.saAmfHealthcheckCallback = NULL;
callbacks.saAmfComponentTerminateCallback = clCompAppTerminate;
callbacks.saAmfCSISetCallback = clCompAppAMFCSISet;
callbacks.saAmfCSIRemoveCallback = clCompAppAMFCSIRemove;
callbacks.saAmfProtectionGroupTrackCallback = NULL;
callbacks.saAmfProxiedComponentInstantiateCallback = clProxiedCompInstantiate;
callbacks.saAmfProxiedComponentCleanupCallback = clProxiedCompCleanup;
/*
* Get IOC Address, Port and Name. Register with AMF.
*/
clEoMyEoIocPortGet(&iocPort);
if ( (rc = saAmfInitialize(&amfHandle, &callbacks, &version)) != SA_AIS_OK)
goto errorexit;
FD_ZERO(&read_fds);
/*
* Get the AMF dispatch FD for the callbacks
*/
if ( (rc = saAmfSelectionObjectGet(amfHandle, &dispatch_fd)) != SA_AIS_OK)
goto errorexit;
FD_SET(dispatch_fd, &read_fds);
/*
* Do the application specific initialization here.
*/
/*
* Now register the component with AMF. At this point it is
* ready to provide service, i.e. take work assignments.
*/
if ( (rc = saAmfComponentNameGet(amfHandle, &appName)) != SA_AIS_OK)
goto errorexit;
if ( (rc = saAmfComponentRegister(amfHandle, &appName, NULL)) != SA_AIS_OK)
goto errorexit;
/*
* Print out standard information for this component.
*/
clprintf (CL_LOG_SEV_INFO, "Component [%.*s] : PID [%d]. Initializing\n", appName.length, appName.value, mypid);
clprintf (CL_LOG_SEV_INFO, " IOC Address : 0x%x\n", clIocLocalAddressGet());
clprintf (CL_LOG_SEV_INFO, " IOC Port : 0x%x\n", iocPort);
/*
* Block on AMF dispatch file descriptor for callbacks
*/
do
{
if( select(dispatch_fd + 1, &read_fds, NULL, NULL, NULL) < 0)
{
clprintf (CL_LOG_SEV_ERROR, "Error in select()");
perror("");
break;
}
saAmfDispatch(amfHandle, SA_DISPATCH_ALL);
} while(!unblockNow);
/*
* Do the application specific finalization here.
*/
if((rc = saAmfFinalize(amfHandle)) != SA_AIS_OK)
{
clprintf (CL_LOG_SEV_ERROR, "AMF finalization error[0x%X]", rc);
}
clprintf (CL_LOG_SEV_INFO, "AMF Finalized");
return 0;
errorexit:
clprintf (CL_LOG_SEV_ERROR, "Component [%.*s] : PID [%d]. Initialization error [0x%x]\n",
appName.length, appName.value, mypid, rc);
return -1;
}
int main(int argc, char *argv[])
{
SaNameT appName = {0};
SaAmfCallbacksT callbacks;
SaVersionT version;
ClIocPortT iocPort;
SaAisErrorT rc = SA_AIS_OK;
SaSelectionObjectT dispatch_fd;
fd_set read_fds;
/*
* Declare other local variables here.
*/
/*
* Get the pid for the process and store it in global variable.
*/
mypid = getpid();
/*
* Initialize and register with CPM. 'version' specifies the
* version of AMF with which this application would like to
* interface. 'callbacks' is used to register the callbacks this
* component expects to receive.
*/
version.releaseCode = 'B';
version.majorVersion = 01;
version.minorVersion = 01;
callbacks.saAmfHealthcheckCallback = NULL;
callbacks.saAmfComponentTerminateCallback = clCompAppTerminate;
callbacks.saAmfCSISetCallback = clCompAppAMFCSISet;
callbacks.saAmfCSIRemoveCallback = clCompAppAMFCSIRemove;
callbacks.saAmfProtectionGroupTrackCallback = NULL;
/*
* Initialize AMF client library.
*/
if ( (rc = saAmfInitialize(&amfHandle, &callbacks, &version)) != SA_AIS_OK)
goto errorexit;
FD_ZERO(&read_fds);
/*
* Get the AMF dispatch FD for the callbacks
*/
if ( (rc = saAmfSelectionObjectGet(amfHandle, &dispatch_fd)) != SA_AIS_OK)
goto errorexit;
FD_SET(dispatch_fd, &read_fds);
/*
* Do the application specific initialization here.
*/
/*
* Now register the component with AMF. At this point it is
* ready to provide service, i.e. take work assignments.
*/
if ( (rc = saAmfComponentNameGet(amfHandle, &appName)) != SA_AIS_OK)
goto errorexit;
if ( (rc = saAmfComponentRegister(amfHandle, &appName, NULL)) != SA_AIS_OK)
goto errorexit;
/* Open the log stream as soon as I've registered with AMF */
clEvalAppLogStreamOpen((ClCharT *)appName.value, &gEvalLogStream);
/* Handle the AMF dispatch loop by spawning a thread that does it */
rc = clOsalTaskCreateDetached("DISPATCH-THREAD", CL_OSAL_SCHED_OTHER, 0, 0, saAmfDispatchThread, NULL);
if(rc != CL_OK)
{
clprintf(CL_LOG_SEV_ERROR, "Dispatch task create failed with rc 0x%x",rc);
return rc;
}
/*
* Print out standard information for this component.
*/
clEoMyEoIocPortGet(&iocPort);
clprintf (CL_LOG_SEV_INFO, "Component [%.*s] : PID [%d]. Initializing\n", appName.length, appName.value, mypid);
clprintf (CL_LOG_SEV_INFO, " IOC Address : 0x%x\n", clIocLocalAddressGet());
clprintf (CL_LOG_SEV_INFO, " IOC Port : 0x%x\n", iocPort);
/* csa112: initialize the event client library, open the event channel and subscribe to events */
if (1)
{
const SaEvtCallbacksT evtCallbacks =
{
NULL, /* Event open callback */
csa112Comp_appEventCallback /* Event delivery callback */
};
SaVersionT evtVersion = {(ClUint8T)'B', 0x1, 0x1};
rc = saEvtInitialize(&evtLibHandle, &evtCallbacks, &evtVersion);
if (rc != SA_AIS_OK)
{
clprintf(CL_LOG_ERROR, "Failed to init event mechanism [0x%x]\n", rc);
return rc;
}
// Open an event chanel so that we can subscribe to events on that channel
rc = saEvtChannelOpen(evtLibHandle, &evtChannelName, (SA_EVT_CHANNEL_PUBLISHER | SA_EVT_CHANNEL_SUBSCRIBER | SA_EVT_CHANNEL_CREATE), (SaTimeT)SA_TIME_END, &evtChannelHandle);
if (rc != SA_AIS_OK)
{
clprintf(CL_LOG_SEV_ERROR, "Failure opening event channel [0x%x] at %ld", rc, time(0L));
goto errorexit;
}
rc = saEvtEventSubscribe(evtChannelHandle, NULL, 1);
if (rc != SA_AIS_OK)
{
clprintf(CL_LOG_SEV_ERROR, "Failed to subscribe to event channel [0x%x]",rc);
goto errorexit;
}
}
/*csa113: create an event definition to be published */
if (1)
{
SaNameT publisherName;
clNameSet((ClNameT*) &publisherName,PUBLISHER_NAME);
rc = saEvtEventAllocate(evtChannelHandle, &eventHandle);
if (rc != SA_AIS_OK)
{
clprintf(CL_LOG_SEV_ERROR, "Failed to allocate event [0x%x]\n", rc);
assert(0);
}
rc = saEvtEventAttributesSet(eventHandle, NULL, 1, 0, &publisherName);
if (rc != SA_AIS_OK)
{
clprintf(CL_LOG_ERROR, "Failed to set event attributes [0x%x]\n",rc);
assert(0);
}
}
while (!exiting)
{
/* csa112: If I am active then I'll publish an event.
Note, any application can publish and event regardless of
HA state. This tutorial simply uses HA state so only
one of the two processes are publishing.
*/
if (running && ha_state == SA_AMF_HA_ACTIVE)
{
csa113Comp_PublishEvent();
}
sleep(1); /* Keep the event publish rate reasonable for this tutorial*/
}
/*
* Do the application specific finalization here.
*/
/* csa112: close the event channel, finalize the event client library */
if ((rc = saEvtChannelClose(evtChannelHandle)) != SA_AIS_OK)
{
clprintf(CL_LOG_ERROR, "Failed [0x%x] to close event channel", rc);
}
if ((rc = saEvtFinalize(evtLibHandle)) != SA_AIS_OK)
{
clprintf(CL_LOG_ERROR, "Failed [0x%x] to finalize event library", rc);
}
if((rc = saAmfFinalize(amfHandle)) != SA_AIS_OK)
{
clprintf (CL_LOG_SEV_ERROR, "AMF finalization error[0x%X]", rc);
}
clprintf (CL_LOG_SEV_INFO, "AMF Finalized");
return 0;
errorexit:
clprintf (CL_LOG_SEV_ERROR, "Component [%.*s] : PID [%d]. Initialization error [0x%x]\n",
appName.length, appName.value, mypid, rc);
return -1;
}
