ClRcT clPubsAppInitialize(ClUint32T argc, ClCharT *argv[])
{
ClRcT rc = CL_OK;
ClEoExecutionObjT* pEvtPubsEoObj;
rc = clEoMyEoObjectGet(&pEvtPubsEoObj);
if( rc != CL_OK )
{
clOsalPrintf("EO Object Get failed [%#X]\n",rc);
}
rc = clEoClientInstall(pEvtPubsEoObj, CL_EO_NATIVE_COMPONENT_TABLE_ID,gClEvtPubsTestFuncList, 0,
(int)(sizeof(gClEvtPubsTestFuncList)/sizeof (ClEoPayloadWithReplyCallbackT)));
if( rc != CL_OK )
{
clOsalPrintf("Installing Native table failed [%#X]\n",rc);
}
clEvtPubsCpmInit();
clPubsEventLibrayInitialize();
return CL_OK;
}
void clEvtContTestDbInit()
{
ClRcT rc = CL_OK;
ClUint32T noOfApp;
rc = clCntLlistCreate(clEvtContSubKeyCompare, clEvtContSubDataDelete,
clEvtContSubDataDelete, CL_CNT_NON_UNIQUE_KEY,
&gEvtContSubInfo);
if (CL_OK != rc)
{
clOsalPrintf("Creating linked list failed for sub \r\n");
exit(-1);
}
rc = clCntLlistCreate(clEvtContPubKeyCompare, clEvtContPubDataDelete,
clEvtContPubDataDelete, CL_CNT_UNIQUE_KEY,
&gEvtContPubInfo);
if (CL_OK != rc)
{
clOsalPrintf("Creating linked list failed for pub \r\n");
exit(-1);
}
clEvtContGetApp(&noOfApp);
clHeapAllocate(noOfApp * sizeof(ClEvtContSubInfoStorageT));
return;
}
ClRcT clCpmEventPayLoadExtract(ClEventHandleT eventHandle,
ClSizeT eventDataSize,
ClCpmEventTypeT cpmEventType,
void *payLoad)
{
ClRcT rc = CL_OK;
ClBufferHandleT payLoadMsg = 0;
void *eventData = NULL;
eventData = clHeapAllocate(eventDataSize);
if (eventData == NULL)
{
clLogWrite(CL_LOG_HANDLE_APP, CL_LOG_SEV_DEBUG, CL_CPM_CLIENT_LIB,
CL_LOG_MESSAGE_0_MEMORY_ALLOCATION_FAILED);
CPM_CLIENT_CHECK(CL_LOG_SEV_ERROR, ("Unable to malloc \n"),
CL_CPM_RC(CL_ERR_NO_MEMORY));
}
rc = clEventDataGet (eventHandle, eventData, &eventDataSize);
if (rc != CL_OK)
{
clOsalPrintf("Event Data Get failed. rc=[0x%x]\n", rc);
goto failure;
}
rc = clBufferCreate(&payLoadMsg);
CL_CPM_CHECK_1(CL_LOG_SEV_ERROR, CL_CPM_LOG_1_BUF_CREATE_ERR, rc, rc,
CL_LOG_HANDLE_APP);
rc = clBufferNBytesWrite(payLoadMsg, (ClUint8T *)eventData,
eventDataSize);
CL_CPM_CHECK_1(CL_LOG_SEV_ERROR, CL_CPM_LOG_1_BUF_WRITE_ERR, rc, rc,
CL_LOG_HANDLE_APP);
switch(cpmEventType)
{
case CL_CPM_COMP_EVENT:
rc = VDECL_VER(clXdrUnmarshallClCpmEventPayLoadT, 4, 0, 0)(payLoadMsg, payLoad);
CL_CPM_CHECK_0(CL_LOG_SEV_ERROR, CL_LOG_MESSAGE_0_INVALID_BUFFER, rc,
CL_LOG_HANDLE_APP);
break;
case CL_CPM_NODE_EVENT:
rc = VDECL_VER(clXdrUnmarshallClCpmEventNodePayLoadT, 4, 0, 0)(payLoadMsg, payLoad);
CL_CPM_CHECK_0(CL_LOG_SEV_ERROR, CL_LOG_MESSAGE_0_INVALID_BUFFER, rc,
CL_LOG_HANDLE_APP);
break;
default:
clOsalPrintf("Invalid event type received.\n");
goto failure;
break;
}
failure:
clBufferDelete(&payLoadMsg);
clHeapFree(eventData);
return rc;
}
ClRcT
clDataTapInit(ClUint32T initFlags, ClUint32T appNum)
{
char *env = 0;
char buf[200];
in_addr_t addr_val;
if (gDataTapObj.inited)
{
return CL_ERR_INITIALIZED;
}
// Should we have some consistency checking on the initFlags?
// Probably, but I don't know yet what checking to do.
gDataTapObj.package.version = CL_INST_VERSION;
gDataTapObj.package.magic = htonl(DATA_TAP_MAGIC_NUMBER);
gDataTapObj.package.flags = htonl(initFlags);
gDataTapObj.package.data = 0;
gDataTapObj.broked = 0;
gDataTapObj.inited = 1;
memset(&gDataTapObj.tapaddr, 0, sizeof gDataTapObj.tapaddr);
// Get the port number from the environment
sprintf(buf, "CSA%d_DEST_PORT", appNum);
env = getenv(buf);
if (env == 0)
{
clOsalPrintf("NO value for %s environment variable\n", buf);
gDataTapObj.broked = 1;
return CL_ERR_INVALID_PARAMETER;
}
gDataTapObj.tapaddr.sin_port = htons(atoi(env));
printf("sin_port = %u (%u)\n", gDataTapObj.tapaddr.sin_port, (unsigned)atoi(env));
// Now get the IP address fromthe environment
sprintf(buf, "CSA%d_DEST_ADDR", appNum);
env = getenv(buf);
if (env == 0)
{
clOsalPrintf("NO value for %s environment variable\n", buf);
gDataTapObj.broked = 1;
return CL_ERR_INVALID_PARAMETER;
}
addr_val = inet_addr(env);
gDataTapObj.tapaddr.sin_addr.s_addr = addr_val;
gDataTapObj.sock = socket(PF_INET, SOCK_DGRAM, 0);
if (gDataTapObj.sock == -1)
{
clOsalPrintf("Failed to open socket");
return CL_OSAL_ERR_OS_ERROR;
}
return CL_OK;
}
ClRcT clEvtTestAppInitialize(ClUint32T argc, ClCharT *argv[])
{
ClRcT rc = CL_OK;
ClEoExecutionObjT *pEoObj;
#if 0
ClSvcHandleT svcHandle = { 0 };
ClOsalTaskIdT taskId = 0;
#endif
/*
* Create the list to hold the mapping b/n Init Name & evtHandle
*/
rc = clCntLlistCreate(clEvtContInitKeyCompare, clEvtContInitDataDelete,
clEvtContInitDataDelete, CL_CNT_UNIQUE_KEY,
&gEvtTestInitInfo);
if (CL_OK != rc)
{
clOsalPrintf("Creating linked list for Init Failed, rc[0x%X]\r\n", rc);
return rc;
}
rc = clCntLlistCreate(clChanContainerKeyCompare, clChanContainerDataDelete,
clChanContainerDataDelete, CL_CNT_UNIQUE_KEY,
&gChanHandleInitInfo);
if(rc!=CL_OK)
{
clOsalPrintf("Creating Linked List for Channel handles failed\n\r");
return rc;
}
/*
* Create a Mutex to lock the containers before accessing them
*/
rc = clOsalMutexCreate(&gEvtTestInitMutex);
if (CL_OK != rc)
{
clOsalPrintf("Creating Mutex for Init Failed, rc[0x%X]\r\n", rc);
return rc;
}
rc = clEoMyEoObjectGet(&pEoObj);
rc = clEoClientInstall(pEoObj, CL_EO_NATIVE_COMPONENT_TABLE_ID,
gClEvtTestAppFuncList, (ClEoDataT) NULL,
(int) sizeof(gClEvtTestAppFuncList) /
(int) sizeof(ClEoPayloadWithReplyCallbackT));
rc = clEvtCpmInit();
#if 0
svcHandle.cpmHandle = &gEvtTestAppCpmHandle;
rc = clDispatchThreadCreate(pEoObj, &taskId, svcHandle);
#endif
return CL_OK;
}
/******************************************************************************
* Application Life Cycle Management Functions
*****************************************************************************/
ClRcT clCompAlarmEvtCallbackFunc(const ClAlarmHandleInfoT* pAlarmInfo)
{
ClRcT rc = CL_OK;
ClNameT moIdName = {0};
ClCorMOIdT moId ;
ClIocAddressT iocAddress = {{0}};
memcpy(&moId, &pAlarmInfo->alarmInfo.moId, sizeof(ClCorMOIdT));
rc = clCorMoIdToMoIdNameGet(&moId, &moIdName);
if(CL_OK == rc)
clOsalPrintf(" The MSO for which the alarm is raised [%s]. ", moIdName.value);
clOsalPrintf(" The component which has raised the alarm [%s] ", pAlarmInfo->alarmInfo.compName.value);
clOsalPrintf("Probable Cause:%d\n",pAlarmInfo->alarmInfo.probCause);
clOsalPrintf("Alarm Handle :%d\n",pAlarmInfo->alarmHandle);
clOsalPrintf("Alarm State:%d\n",pAlarmInfo->alarmInfo.alarmState);
if(pAlarmInfo->alarmInfo.len != 0)
clOsalPrintf("Alarm payload :%s\n",pAlarmInfo->alarmInfo.buff);
iocAddress.iocPhyAddress.nodeAddress = 2;
clEoMyEoIocPortGet(&iocAddress.iocPhyAddress.portId);
rc = clFaultRepairAction(iocAddress, pAlarmInfo->alarmHandle, SA_AMF_COMPONENT_RESTART);
if (CL_OK != rc)
{
clOsalPrintf("Failed while reporting the alarm to the fault..... . rc[0x%x] \n", rc);
return rc;
}
clOsalPrintf("################ Successfully reported the alarm to the fault. ..... \n");
return rc;
}
static ClRcT
initSocket()
{
char *ipaddr;
in_addr_t addr_val;
char *port;
uint16_t port_num;
CL_FUNC_ENTER();
//
// We'll want to get the address where we'll send instrumentation
// information out of the environment. Initialize the sockaddr
// so after we create the socket we can connect it to the address.
if ((ipaddr = getenv("CL_LOGGING_ADDR")) == 0)
{
clOsalPrintf("No value for CL_LOGGING_ADDR\n");
CL_FUNC_EXIT();
return CL_RC(0, CL_ERR_INVALID_PARAMETER);
}
if ((port = getenv("CL_LOGGING_PORT")) == 0)
{
clOsalPrintf("No value for CL_LOGGING_PORT\n");
CL_FUNC_EXIT();
return CL_RC(0, CL_ERR_INVALID_PARAMETER);
}
addr_val = inet_addr(ipaddr);
port_num = atoi(port);
memset(&instaddr, 0, sizeof instaddr);
instaddr.sin_port = htons(port_num);
instaddr.sin_addr.s_addr = addr_val;
sock = socket(PF_INET, SOCK_DGRAM, 0);
if (sock == -1)
{
clOsalPrintf("Failed to open socket");
return CL_OSAL_ERR_OS_ERROR;
}
// if (connect(sock, &instaddr, sizeof addr) != 0)
// {
// clOsalPrintf("Failed to connect socket to %s/%s\n", ipaddr, port);
// close(sock);
// sock = -1;
// CL_FUNC_EXIT();
// return CL_OSAL_ERR_OS_ERROR;
// }
CL_FUNC_EXIT();
return CL_OK;
}
static ClRcT clSubsEventLibrayInitialize(void)
{
ClRcT rc = CL_OK;
ClVersionT version = CL_EVENT_VERSION;
ClNameT channelName = {sizeof(CL_EO_EVENT_CHANNEL_NAME)-1, CL_EO_EVENT_CHANNEL_NAME};
const ClEventCallbacksT evtCallbacks =
{
NULL, // clSubsAsyncChannelOpenCb for Async Channel Open
clSubEoEventWaterMarkCb, // Event Delivery Callback
};
ClEventChannelOpenFlagsT evtFlags = CL_EVENT_CHANNEL_SUBSCRIBER | CL_EVENT_LOCAL_CHANNEL;
rc = clEventInitialize(&gSubsEventInfo.initHandle, &evtCallbacks, &version);
if(CL_OK != rc)
{
clOsalPrintf("clEventInitialize() failed [%#X]\n",rc);
goto failure;
}
rc = clEventChannelOpen(gSubsEventInfo.initHandle, &channelName,
evtFlags, CL_RMD_DEFAULT_TIMEOUT,
&gSubsEventInfo.channelHandle);
if(CL_OK != rc)
{
clOsalPrintf("clEventChannelOpen() failed [%#X]\n",rc);
goto init_done;
}
rc = clEventSubscribe(gSubsEventInfo.channelHandle, CL_EVENT_DEFAULT_SUBS_FILTER, UNIQUE_SUBSCRIPTION_ID,
"User Specified Argument (cookie) for the event delivery callback");
if(CL_OK != rc)
{
clOsalPrintf("clEventSubscribe() failed [%#X]\n",rc);
goto channel_opened;
}
return CL_OK;
channel_opened:
clEventChannelClose(gSubsEventInfo.channelHandle);
init_done:
clEventFinalize(gSubsEventInfo.initHandle);
failure:
return rc;
}
ClRcT
clComponentEventInit()
{
ClRcT rc = CL_OK;
rc = clAlarmEventSubscribe(clCompAlarmEvtCallbackFunc);
if(CL_OK != rc)
{
clLogError("UT1","INT", "Subscribing for the event failed. rc[0x%x]", rc);
return rc;
}
clOsalPrintf("################ Successfully subscribed for the alarm events ############## \n");
#if 0
rc = clAlarmEventUnsubscribe();
if(CL_OK != rc)
{
clLogError("UT1", "INT", "Unsubscribing the event failed. rc[0x%x]", rc);
return rc;
}
rc = clAlarmEventSubscribe(clCompAlarmEvtCallbackFunc);
if(CL_OK != rc)
{
clLogError("UT1","INT", "Subscribing for the event failed. rc[0x%x]", rc);
return rc;
}
#endif
return rc;
}
void
tsAllActiveTimersPrint (void)
{
ClRcT returnCode = CL_ERR_INVALID_HANDLE;
ClUint32T count = 0;
TsTimer_t* pUserTimer = NULL;
returnCode = clOsalMutexLock (gActiveTimerQueue.timerMutex);
if (returnCode != CL_OK) {
return;
}
if (gActiveTimerQueue.pFirstTimer == NULL) {
/* no elements to display */
returnCode = clOsalMutexUnlock (gActiveTimerQueue.timerMutex);
return;
}
for (pUserTimer = gActiveTimerQueue.pFirstTimer, count = 0;
pUserTimer != NULL;
pUserTimer = pUserTimer->pNextActiveTimer, count++) {
clOsalPrintf ("(%d) Timer timeout = %us, timestamp->sec = %ld, timestamp->Microsec = %ld.\n",
(ClInt32T)count,
pUserTimer->timeOut.tsSec,
pUserTimer->timestamp/1000000ULL,
pUserTimer->timestamp%1000000ULL);
}
returnCode = clOsalMutexUnlock (gActiveTimerQueue.timerMutex);
}
void clSubsAsyncChannelOpenCb(ClInvocationT invocation,
ClEventChannelHandleT channelHandle, ClRcT retCode)
{
ClRcT rc = CL_OK;
clOsalPrintf("*******************************************************\n");
clOsalPrintf("************* Async Channel Open Callback *************\n");
clOsalPrintf("*******************************************************\n");
clOsalPrintf(" Invocation : %#X\n", invocation);
clOsalPrintf(" Channel Handle : %#llX\n", channelHandle);
clOsalPrintf(" API Return Code : %#X\n", retCode);
clOsalPrintf("*******************************************************\n");
/*
* Check if the Channel Open Asyn was successful
*/
if(CL_OK != retCode)
{
goto failure;
}
rc = clEventSubscribe(channelHandle, CL_EVENT_DEFAULT_SUBS_FILTER, UNIQUE_SUBSCRIPTION_ID,
"User Specified Argument (cookie) for the event delivery callback");
if(CL_OK != rc)
{
goto failure;
}
failure:
return;
}
static ClRcT clPubsEventLibrayFinalize(void)
{
ClRcT rc = CL_OK;
rc = clEventChannelClose(gPubsEventInfo.channelHandle);
if(CL_OK != rc)
{
clOsalPrintf("clEventChannelClose() failed [%#X]\n",rc);
}
rc = clEventFinalize(gPubsEventInfo.initHandle);
if(CL_OK != rc)
{
clOsalPrintf("clEventFinalize() failed [%#X]\n",rc);
}
return CL_OK;
}
void
clOsalMemoryChecker(void) {
if (CLIST_SIZE(_memory_logger_element)(g_memory_logger) != 0) {
CLIST_ITER_TYPE(_memory_logger_element) iter =
CLIST_BEGIN(_memory_logger_element)(g_memory_logger);
while (iter != CLIST_END(_memory_logger_element)(g_memory_logger)) {
_memory_logger_element *e = CLIST_ITER_GET_DATA(_memory_logger_element)(iter);
clOsalPrintf("0x%p, at \"%s\":%d\n", e->ptr, e->filename, e->lineno);
iter = CLIST_ITER_INCREMENT(_memory_logger_element)(iter);
}
}
}
ClRcT clDataTapSend(ClUint32T data)
{
struct DataTapPackage package = gDataTapObj.package;
package.data = htonl(data);
if (!gDataTapObj.inited)
{
clOsalPrintf("Data Tap uninitialized\n");
return CL_ERR_INITIALIZED;
}
if (gDataTapObj.broked)
{
return CL_ERR_INVALID_PARAMETER;
}
if (sendto(gDataTapObj.sock, &package, sizeof package, 0, &gDataTapObj.tapaddr, sizeof gDataTapObj.tapaddr) < 0)
{
clOsalPrintf("Failed to send message, sock = %d, errno = %d\n", sock, errno);
return CL_OSAL_ERR_OS_ERROR;
}
return CL_OK;
}
static ClRcT clPubsEventLibrayInitialize(void)
{
ClRcT rc = CL_OK;
ClVersionT version = CL_EVENT_VERSION;
SaNameT channelName = {sizeof(CL_EO_EVENT_CHANNEL_NAME)-1, CL_EO_EVENT_CHANNEL_NAME};
const ClEventCallbacksT evtCallbacks =
{
clPubsAsyncChannelOpenCb, // Can be NULL if sync call is used
NULL, // Since it is not a subscriber
};
ClEventChannelOpenFlagsT evtFlags = CL_EVENT_CHANNEL_PUBLISHER | CL_EVENT_LOCAL_CHANNEL;
ClInvocationT invocation = UNIQUE_INVOCATION_ID; // To identify the callback
rc = clEventInitialize(&gPubsEventInfo.initHandle, &evtCallbacks, &version);
if(CL_OK != rc)
{
clOsalPrintf("clEventInitialize() failed [%#X]\n",rc);
goto failure;
}
rc = clEventChannelOpenAsync(gPubsEventInfo.initHandle, invocation,
&channelName, evtFlags);
if(CL_OK != rc)
{
clOsalPrintf("clEventChannelOpen() failed [%#X]\n",rc);
goto init_done;
}
return CL_OK;
init_done:
clEventFinalize(gPubsEventInfo.initHandle);
failure:
return rc;
}
ClRcT clPubsAppFinalize()
{
ClRcT rc = CL_OK;
ClEoExecutionObjT* pEvtPubsEoObj;
rc = clEoMyEoObjectGet(&pEvtPubsEoObj);
{
clOsalPrintf("EO Object Get failed [%#X]\n",rc);
}
rc = clEoClientUninstall(pEvtPubsEoObj,CL_EO_NATIVE_COMPONENT_TABLE_ID);
if(CL_OK != rc)
{
clOsalPrintf("EO Client Uninstall failed [%#X]\n",rc);
}
rc = clPubsEventLibrayFinalize();
if(CL_OK != rc)
{
clOsalPrintf("Event Library Finalize failed [%#X]\n",rc);
}
return CL_OK;
}
static ClRcT clSubsEventLibrayFinalize(void)
{
ClRcT rc = CL_OK;
rc = clEventUnsubscribe(gSubsEventInfo.channelHandle, UNIQUE_SUBSCRIPTION_ID);
if(CL_OK != rc)
{
clOsalPrintf("clEventUnsubscribe() failed [%#X]\n",rc);
}
rc = clEventChannelClose(gSubsEventInfo.channelHandle);
if(CL_OK != rc)
{
clOsalPrintf("clEventChannelClose() failed [%#X]\n",rc);
}
rc = clEventFinalize(gSubsEventInfo.initHandle);
if(CL_OK != rc)
{
clOsalPrintf("clEventFinalize() failed [%#X]\n",rc);
}
return CL_OK;
}
/**
* Show Instance Details.
*
* API to print the instance details.
*
* @param smThis State Machine Object
*
* @returns
* void
*
* @see #clEsmInstanceLogShow
*/
void
clEsmInstanceShow(ClExSmInstancePtrT smThis
)
{
if(smThis)
{
ClUint32T sz;
SMQ_SIZE(smThis->q, sz);
clOsalPrintf("\n[ESM] Instance: Lock [%d] Pause [%d] Q-Items [%d]",
smThis->lock,
smThis->pause,
sz);
smInstanceShow(smThis->fsm);
}
}
void clPubsAsyncChannelOpenCb(ClInvocationT invocation,
ClEventChannelHandleT channelHandle, ClRcT retCode)
{
ClRcT rc = CL_OK;
clOsalPrintf("*******************************************************\n");
clOsalPrintf("************* Async Channel Open Callback *************\n");
clOsalPrintf("*******************************************************\n");
clOsalPrintf(" Invocation : %#X\n", invocation);
clOsalPrintf(" Channel Handle : %#llX\n", channelHandle);
clOsalPrintf(" API Return Code : %#X\n", retCode);
clOsalPrintf("*******************************************************\n");
/*
* Check if the Channel Open Asyn was successful
*/
if(CL_OK != retCode)
{
clOsalPrintf("clEventChannelOpenAsync() failed [%#X]\n",rc);
goto failure;
}
gPubsEventInfo.channelHandle = channelHandle;
rc = clPubsTriggerEvent(CL_EO_LIB_ID_HEAP, CL_WM_HIGH, CL_WM_HIGH_LIMIT, CL_WM_LOW_LIMIT);
if(CL_OK != rc)
{
clOsalPrintf("Publish trigger failed [%#X]\n",rc);
goto channel_opened;
}
channel_opened:
clEventChannelClose(gPubsEventInfo.channelHandle);
failure:
return;
}
/**
* Show Log Details.
*
* API to print the history of the state machine instance..
*
* @param smThis State Machine Object
*
* @returns
* void
*
* @see #clEsmInstanceLogShow
*/
void
clEsmInstanceLogShow(ClExSmInstancePtrT smThis,
ClUint16T items
)
{
if(smThis)
{
int i;
ClSmLogInfoPtrT logBuf;
#ifdef DEBUG
clOsalPrintf("\n[ESM] Instance: %s Last [%d] entries:",
smThis->fsm->name,
items);
#else
clOsalPrintf("\n[ESM] Instance: Last [%d] entries:",
(int)items);
#endif
clOsalPrintf("\n------------------------------------------");
clOsalPrintf("\n Event From-State To-State");
clOsalPrintf("\n------------------------------------------");
/* show last 'items' log information */
for(i=1;i<= (int)items && i<=ESM_LOG_ENTRIES;i++)
{
logBuf = ESM_LOG_BACK_GET(smThis->log, i);
if(logBuf && logBuf->from && logBuf->to)
{
clOsalPrintf("\n %02d %02d/%-15s %02d/%s",
logBuf->eventId,
#ifdef DEBUG
logBuf->from->type,
logBuf->from->name,
logBuf->to->type,
logBuf->to->name);
#else
logBuf->from->type,
"",
logBuf->to->type,
"");
#endif
}
}
clOsalPrintf("\n------------------------------------------\n");
}
ClRcT clEvtCpmReplyCb(ClUint32T data, ClBufferHandleT inMsgHandle,
ClBufferHandleT outMsgHandle)
{
ClUint32T rc = CL_OK;
#if 0
ClCpmLcmResponseT response = { {0, 0}, 0 };
ClUint32T msgLength = 0;
ClCharT logmsg[CL_MAX_NAME_LENGTH] = { 0 };
ClCharT requesttype[CL_MAX_NAME_LENGTH] = { 0 };
CL_FUNC_ENTER();
rc = clBufferLengthGet(inMsgHandle, &msgLength);
if (msgLength == sizeof(ClCpmLcmResponseT))
{
rc = clBufferNBytesRead(inMsgHandle, (ClUint8T *) &response,
&msgLength);
if (rc != CL_OK)
{
clOsalPrintf("Unable to read the message. \n");
goto failure;
}
}
else
{
clOsalPrintf("Buffer read failure !\n");
goto failure;
}
printf("Received reply for %s...\n", response.name);
switch (response.requestType)
{
case CL_CPM_HEALTHCHECK:
strcpy(requesttype, "CL_CPM_HEALTHCHECK");
break;
case CL_CPM_TERMINATE:
strcpy(requesttype, "CL_CPM_TERMINATE");
break;
case CL_CPM_PROXIED_INSTANTIATE:
strcpy(requesttype, "CL_CPM_PROXIED_INSTANTIATE");
break;
case CL_CPM_PROXIED_CLEANUP:
strcpy(requesttype, "CL_CPM_PROXIED_CLEANUP");
break;
case CL_CPM_EXTN_HEALTHCHECK:
strcpy(requesttype, "CL_CPM_EXTN_HEALTHCHECK");
break;
case CL_CPM_INSTANTIATE:
strcpy(requesttype, "CL_CPM_INSTANTIATE");
break;
case CL_CPM_CLEANUP:
strcpy(requesttype, "CL_CPM_CLEANUP");
break;
case CL_CPM_RESTART:
strcpy(requesttype, "CL_CPM_RESTART");
break;
default:
strcpy(requesttype, "Invalid request");
break;
}
sprintf(logmsg, "%s %s request %s.\n", response.name, requesttype,
response.returnCode == CL_OK ? "success" : "failure");
printf(logmsg);
CL_FUNC_EXIT();
return CL_OK;
failure:
CL_FUNC_EXIT();
#endif
printf("Invoked the Callback for CPM API succesfully\n\r\n");
return rc;
}
/**
* This function is called by the provisioning library whenever the object
* modification operation is done on the resource being managed. For a single job
* request, this function is called if the validate function is failed. For a
* multiple job request, on encountering a validate failure, this function is
* called to rollback all the jobs before the one (including) on which the
* validation failure is reported.
*
* The pThis is a pointer to the provisioning class.
* The txnHandle is the unique handle for all the jobs which are part of same session. So for
* a session containing multiple jobs, then it is unique of all the jobs and it can be used
* to identify them.
*
* The pProvTxnData is a pointer to the ClProvTxnDataT structure which contains
* the information about the job being performed on the managed resource.
* The pProvTxnData->provCmd stores the operation type which can be
* CL_COR_OP_CREATE_AND_SET, CL_COR_OP_CREATE, CL_COR_OP_SET or CL_COR_OP_DELETE
* based on what is the operation happening on the resource.
* In the case of set operation, the various fields of pProvTxnData provide the
* the details about the operation which is happening on the resource. It contain
* MOID of the managed resource and information about the attribute on which set
* operation is done. For a create, create-set and delete operation, the pProvTxnData
* contains the MOID of the resource on which the given operation is done.
*
* ** Note : This function is being deprecated, if clProvObjectRollback() callback
* is filled in the constructor, then that callback function will be called
* instead of this to group rollback all the requests.
*/
ClRcT clProvisioningTIMESETTABLEProvRollback(CL_OM_PROV_CLASS* pThis, ClHandleT txnHandle, ClProvTxnDataT* pProvTxnData)
{
ClRcT rc = CL_OK;
/*
* ---BEGIN_APPLICATION_CODE---
*/
ClNameT moIdName = {0};
clprintf(CL_LOG_SEV_INFO, "Inside the function %s", __FUNCTION__);
if (pProvTxnData == NULL)
{
clOsalPrintf("[%s]: Null pointer detected for pProvTxnData. \n", appname);
return CL_ERR_NULL_POINTER;
}
rc = clCorMoIdToMoIdNameGet((ClCorMOIdPtrT)pProvTxnData->pMoId, &moIdName);
if (CL_OK != rc)
{
clOsalPrintf("[%s]: Failed while getting the name of the MO. rc[0x%x]", appname, rc);
return rc;
}
switch (pProvTxnData->provCmd)
{
case CL_COR_OP_CREATE :
case CL_COR_OP_CREATE_AND_SET:
break;
case CL_COR_OP_SET:
if (pProvTxnData->pProvData == NULL)
{
clOsalPrintf("[%s]: The value for the AttrId [0x%x], MO [%s] \n",
appname, pProvTxnData->attrId, moIdName.value);
return CL_ERR_NULL_POINTER;
}
switch (pProvTxnData->attrId)
{
case TIMESETTABLE_TIMESETHOUR :
{
clOsalPrintf("[%s]: Rolling back AttrId [TIMESETTABLE_TIMESETHOUR: 0x%x] of MO [%s] \n",
appname, pProvTxnData->attrId, moIdName.value);
}
break;
case TIMESETTABLE_TIMESETMINUTE:
{
clOsalPrintf("[%s]: Rolling back AttrId [TIMESETTABLE_TIMESETMINUTE: 0x%x] of MO [%s] \n",
appname, pProvTxnData->attrId, moIdName.value);
}
break;
case TIMESETTABLE_TIMESETSECOND:
{
clOsalPrintf("[%s]: Rolling back AttrId [TIMESETTABLE_TIMESETSECOND: 0x%x] of MO [%s] \n",
appname, pProvTxnData->attrId, moIdName.value);
}
break;
default:
clOsalPrintf("[%s]: Do nothing. \n", appname);
}
break;
default:
clprintf (CL_LOG_SEV_ERROR, "Prov command is not proper");
}
/*
* ---END_APPLICATION_CODE---
*/
return rc;
}
ClRcT
clInstInitId()
{
ClRcT rc = CL_OK;
InstrumentedId *tmpPtr = 0;
CL_FUNC_ENTER();
// check whether the id has been initialized
if (myInstId != 0)
{
CL_FUNC_EXIT();
return CL_OK;
}
if (sock == -1)
{
rc = initSocket();
if (rc != CL_OK)
{
clOsalPrintf("failed to initialize instrumentation socket\n");
return rc;
}
}
// Nope, not initialized, so try to initialize it here.
// First, try to lock a mutex so that only one thread
// will be creating the id.
// Then, try to get our component name, our local node name
// and then allocate the id and set it from the component
// and local node name.
// Finally, unlock and delete the mutex.
if (!id_mutex)
{
if ((rc = clOsalMutexCreateAndLock(&id_mutex)) != CL_OK)
{
clOsalPrintf("Failed [0x%x] to create and lock mutex\n", rc);
CL_FUNC_EXIT();
return rc;
}
}
else
{
// Some other thread must have come through here and set
// the mutex before us. We're done.
CL_FUNC_EXIT();
return CL_OK;
}
if ((tmpPtr = clHeapCalloc(1, sizeof (InstrumentedId))) == 0)
{
clOsalPrintf("failed to allocate InstrumentedID\n");
rc = CL_RC(0, CL_ERR_NO_MEMORY);
goto breakdown;
}
memset(&tmpPtr->compName, 0, sizeof tmpPtr->compName);
memset(&tmpPtr->nodeName, 0, sizeof tmpPtr->nodeName);
rc = CL_OK;
myInstId = tmpPtr;
tmpPtr = 0;
breakdown:
clOsalMutexUnlock(id_mutex);
clOsalMutexDelete(id_mutex);
id_mutex = 0;
CL_FUNC_EXIT();
return rc;
}
static void clSubEoEventWaterMarkCb( ClEventSubscriptionIdT subscriptionId,
ClEventHandleT eventHandle, ClSizeT eventDataSize )
{
ClRcT rc = CL_OK;
ClEventPriorityT priority = 0;
ClTimeT retentionTime = 0;
ClNameT publisherName = { 0 };
ClEventIdT eventId = 0;
ClEventPatternArrayT patternArray = { 0 };
ClTimeT publishTime = 0;
ClPtrT pCookie = NULL;
ClPtrT pEventData = NULL;
ClUint8T *pEventPayload = NULL;
/*
* Allocate memory for the event payload.
*/
pEventData = clHeapAllocate(eventDataSize);
if (pEventData == NULL)
{
clOsalPrintf("Allocation for event data failed. rc[%#X]\n", rc);
goto failure;
}
/*
* Fetch the event payload. NOTE that there is a bug in the SAF spec B.01.01
* allowing the application to pass a pointer and expecting the
* clEventDataGet() to return the allocated memory. This is not possible as
* the parameter pEventData is a single pointer so the memory allocated by
* the callee can't be returned to the caller.
*/
rc = clEventDataGet (eventHandle, pEventData, &eventDataSize);
if (rc != CL_OK)
{
clOsalPrintf("Event Data Get failed. rc[%#X]\n", rc);
goto failure;
}
pEventPayload = pEventData;
/*
* Fetch the cookie specified during subscribe.
*/
rc = clEventCookieGet(eventHandle, &pCookie);
if (rc != CL_OK)
{
clOsalPrintf("Event Cookie Get failed. rc[%#X]\n", rc);
goto failure;
}
/*
* Fetch the attributes of the event.
*/
rc = clEventAttributesGet(eventHandle, &patternArray, &priority,
&retentionTime, &publisherName, &publishTime,
&eventId);
if (rc != CL_OK)
{
clOsalPrintf("Event Attributes Get failed. rc[%#X]\n", rc);
goto failure;
}
/*
* Free the allocated Event
*/
rc = clEventFree(eventHandle);
clOsalPrintf("-------------------------------------------------------\n");
clOsalPrintf("!!!!!!!!!!!!!!! Event Delivery Callback !!!!!!!!!!!!!!!\n");
clOsalPrintf("-------------------------------------------------------\n");
clOsalPrintf(" Subscription ID : %#X\n", subscriptionId);
clOsalPrintf(" Event Priority : %#X\n", priority);
clOsalPrintf(" Publish Time : 0x%llX\n",
publishTime);
clOsalPrintf(" Retention Time : 0x%llX\n",
retentionTime);
clOsalPrintf(" Publisher Name : %.*s\n",
publisherName.length, publisherName.value);
clOsalPrintf(" EventID : %#X\n", eventId);
clOsalPrintf(" Event Payload : %s\n", pEventPayload);
clOsalPrintf(" Event Cookie : %s\n", (ClUint8T*)pCookie);
clHeapFree(pEventPayload); // Release the memory allocated for the payload.
/*
* Display the Water Mark Details and Free the patterns.
* Note that each pattern needs to be freed and then the
* pattern array in that order.
*/
clOsalPrintf(" EO Name : %.*s\n",
(ClInt32T)patternArray.pPatterns[0].patternSize,
(ClCharT *)patternArray.pPatterns[0].pPattern);
clHeapFree(patternArray.pPatterns[0].pPattern);
clOsalPrintf(" Library ID : %#X\n",
*(ClEoLibIdT *)patternArray.pPatterns[1].pPattern);
clHeapFree(patternArray.pPatterns[1].pPattern);
clOsalPrintf(" Water Mark ID : %#X\n",
*(ClWaterMarkIdT *)patternArray.pPatterns[2].pPattern);
clHeapFree(patternArray.pPatterns[2].pPattern);
clOsalPrintf(" Water Mark Type : %s\n",
(*(ClEoWaterMarkFlagT *)patternArray.pPatterns[3].pPattern == CL_WM_HIGH_LIMIT)? "HIGH" : "LOW");
clHeapFree(patternArray.pPatterns[3].pPattern);
clOsalPrintf(" Water Mark Value : %u\n",
*(ClUint32T *)patternArray.pPatterns[4].pPattern);
clHeapFree(patternArray.pPatterns[4].pPattern);
clHeapFree(patternArray.pPatterns);
clOsalPrintf("-------------------------------------------------------\n");
failure:
return;
}
static ClRcT clPubsTriggerEvent(ClEoLibIdT libId, ClWaterMarkIdT wmId, ClUint32T wmValue, ClEoWaterMarkFlagT wmFlag)
{
ClRcT rc = CL_OK;
ClEventIdT eventId = 0;
SaNameT publisherName = {sizeof(CL_EVENT_PUBLISHER_NAME)-1, CL_EVENT_PUBLISHER_NAME};
ClEventPatternT patterns[5] = {{0}};
ClEventPatternArrayT patternArray = {
0,
CL_SIZEOF_ARRAY(patterns),
patterns
};
rc = clEventAllocate(gPubsEventInfo.channelHandle, &gPubsEventInfo.eventHandle);
if(CL_OK != rc)
{
clOsalPrintf("clEventAllocate() failed [%#X]\n",rc);
goto failure;
}
patterns[0].patternSize = strlen(CL_EO_NAME);
patterns[0].pPattern = (ClUint8T *)CL_EO_NAME;
patterns[1].patternSize = sizeof(libId);
patterns[1].pPattern = (ClUint8T *)&libId;
patterns[2].patternSize = sizeof(wmId);
patterns[2].pPattern = (ClUint8T *)&wmId;
patterns[3].patternSize = sizeof(wmFlag);
patterns[3].pPattern = (ClUint8T *)&wmFlag;
patterns[4].patternSize = sizeof(wmValue);
patterns[4].pPattern = (ClUint8T *)(&wmValue);
rc = clEventAttributesSet(gPubsEventInfo.eventHandle, &patternArray,
CL_EVENT_HIGHEST_PRIORITY, 0, &publisherName);
if(CL_OK != rc)
{
clOsalPrintf("clEventAttributesSet() failed [%#X]\n",rc);
goto event_allocated;
}
rc = clEventPublish(gPubsEventInfo.eventHandle, "Event Payload passed in endian neutral way",
sizeof("Event Payload passed in endian neutral way."), &eventId);
if(CL_OK != rc)
{
clOsalPrintf("clEventPublish() failed [%#X]\n",rc);
goto event_allocated;
}
event_allocated:
rc = clEventFree(gPubsEventInfo.eventHandle);
if(CL_OK != rc)
{
clOsalPrintf("clEventFree() failed [%#X]\n",rc);
}
failure:
return rc;
}
ClRcT
clInstSendMessage(int msgType, const char *msg)
{
char msgBuf[INST_BUF_SIZE];
ClRcT rc = CL_OK;
int space;
char *ptr = msgBuf;
CL_FUNC_ENTER();
if ((rc = clInstInitId()) != CL_OK)
{
clOsalPrintf("Failed [0x%x] to initialize Instrumentation id\n", rc);
CL_FUNC_EXIT();
return rc;
}
//
// Fill in the msgBuf: msgType,nodeName,compName,msg
// Check that we have room for the message, formatting it
// as we go. Finally, send it over the socket which should
// already been connected in clInstInitId
sprintf(msgBuf, "%d", CL_INST_VERSION);
space = sizeof msgBuf - 1;
sprintf(msgBuf+1, "%d,", msgType);
space = sizeof msgBuf - 2;
ptr += strlen(ptr);
space = (sizeof msgBuf) - (ptr - msgBuf);
if (myInstId->nodeName.length == 0)
{
strcpy(ptr, "unknown_node,");
}
else
{
if ((myInstId->nodeName.length + 1) >= space)
{
clOsalPrintf("nodeName (%s) too long for remaining space (%d)\n",
myInstId->nodeName.value, space);
}
else
{
strcpy(ptr, myInstId->nodeName.value);
strcat(ptr, ",");
}
}
ptr += strlen(ptr);
space = (sizeof msgBuf) - (ptr - msgBuf);
if (myInstId->compName.length == 0)
{
strcat(ptr, "unknown_component,");
}
else
{
if ((myInstId->compName.length + 1) >= space)
{
clOsalPrintf("compName (%s) too long for remaining space (%d)\n",
myInstId->compName.value, space);
return CL_RC(0, CL_ERR_BUFFER_OVERRUN);
}
else
{
strcpy(ptr, myInstId->compName.value);
strcat(ptr, ",");
}
}
ptr += strlen(ptr);
space = (sizeof msgBuf) - (ptr - msgBuf);
// check that there's enough room for the message in our buffer
// and if there is then copy it in.
if (strlen(msg) >= space)
{
strncpy(ptr, msg, space - 4); // room for "..."
ptr += (space - 4);
strcpy(ptr, "...");
}
else
{
strcpy(ptr, msg);
}
ptr += strlen(ptr);
space = (sizeof msgBuf) - (ptr - msgBuf);
if (sendto(sock, msgBuf, ptr - msgBuf, 0, &instaddr, sizeof instaddr) == -1)
{
clOsalPrintf("Failed to send message, sock = %d, errno = %d\n", sock, errno);
return CL_OSAL_ERR_OS_ERROR;
}
CL_FUNC_EXIT();
return rc;
}
ClRcT _cpmClusterConfigList(ClInt32T argc, ClCharT **retStr)
{
ClCpmLT *cpmL = NULL;
ClRcT rc = CL_OK;
ClCntNodeHandleT hNode = 0;
ClUint32T cpmLCount = 0;
ClCharT tempStr[256];
ClCharT *tmpStr = NULL;
ClBufferHandleT message;
rc = clBufferCreate(&message);
CL_CPM_CHECK(CL_DEBUG_ERROR, ("\n Unable to create message \n"), rc);
if (argc != ONE_ARGUMENT)
{
sprintf(tempStr, "Usage: clusterList");
rc = clBufferNBytesWrite(message, (ClUint8T *) tempStr,
strlen(tempStr));
CL_CPM_CHECK(CL_DEBUG_ERROR, ("Unable to write message %x\n", rc), rc);
goto done;
}
/*
* Print the local stuff first
*/
sprintf(tempStr, "%s\n", "nodeName | status | iocAddress | iocPort ");
rc = clBufferNBytesWrite(message, (ClUint8T *) tempStr,
strlen(tempStr));
CL_CPM_CHECK(CL_DEBUG_ERROR, ("\n Unable to write message \n"), rc);
sprintf(tempStr, "%s\n",
"-----------------------------------------------------------------------");
rc = clBufferNBytesWrite(message, (ClUint8T *) tempStr,
strlen(tempStr));
CL_CPM_CHECK(CL_DEBUG_ERROR, ("\n Unable to write message \n"), rc);
/*
* Now even the CPM/G information is stored in the list.
* So no need of printing the above information.
*/
#if 0
if (gpClCpm->pCpmLocalInfo->status == CL_CPM_EO_DEAD)
sprintf(tempStr, "%10s | DEAD | %8d | 0x%x\n",
gpClCpm->pCpmLocalInfo->nodeName,
gpClCpm->pCpmLocalInfo->cpmAddress.nodeAddress,
gpClCpm->pCpmLocalInfo->cpmAddress.portId);
else
sprintf(tempStr, "%10s | ALIVE | %8d | 0x%x\n",
gpClCpm->pCpmLocalInfo->nodeName,
gpClCpm->pCpmLocalInfo->cpmAddress.nodeAddress,
gpClCpm->pCpmLocalInfo->cpmAddress.portId);
rc = clBufferNBytesWrite(message, (ClUint8T *) tempStr,
strlen(tempStr));
CL_CPM_CHECK(CL_DEBUG_ERROR, ("\n Unable to write message \n"), rc);
#endif
/*_cpmListAllSU();*/
/*
* Get all the CPMs one by one and delete the stuff.
*/
rc = clCntFirstNodeGet(gpClCpm->cpmTable, &hNode);
CL_CPM_CHECK(CL_DEBUG_ERROR, ("Unable to get first cpmTable Node %x\n", rc),
rc);
rc = clCntNodeUserDataGet(gpClCpm->cpmTable, hNode,
(ClCntDataHandleT *) &cpmL);
CL_CPM_CHECK(CL_DEBUG_ERROR, ("Unable to get container Node data %x\n", rc),
rc);
cpmLCount = gpClCpm->noOfCpm;
while (cpmLCount)
{
if (cpmL->pCpmLocalInfo != NULL)
{
if (cpmL->pCpmLocalInfo->status == CL_CPM_EO_DEAD)
{
sprintf(tempStr, "%10s | DEAD | %8d | 0x%x\n",
cpmL->nodeName,
cpmL->pCpmLocalInfo->cpmAddress.nodeAddress,
cpmL->pCpmLocalInfo->cpmAddress.portId);
}
else
{
sprintf(tempStr, "%10s | ALIVE | %8d | 0x%x\n",
cpmL->nodeName,
cpmL->pCpmLocalInfo->cpmAddress.nodeAddress,
cpmL->pCpmLocalInfo->cpmAddress.portId);
}
rc = clBufferNBytesWrite(message, (ClUint8T *) tempStr,
strlen(tempStr));
CL_CPM_CHECK(CL_DEBUG_ERROR, ("\n Unable to write message \n"), rc);
}
else
{
sprintf(tempStr, "%10s \n", cpmL->nodeName);
rc = clBufferNBytesWrite(message, (ClUint8T *) tempStr,
strlen(tempStr));
CL_CPM_CHECK(CL_DEBUG_ERROR, ("\n Unable to write message \n"), rc);
}
#if 0
rc = clCntFirstNodeGet(cpmL->suTable, &hSU);
CL_CPM_CHECK(CL_DEBUG_ERROR,
("Unable to get first su Node in cpmL %x\n", rc), rc);
if (cpmL->pCpmLocalInfo != NULL)
clOsalPrintf("%10s | %8d | %8d | 0x%8x| 0x%8x \n",
cpmL->pCpmLocalInfo->nodeName,
cpmL->pCpmLocalInfo->status,
cpmL->pCpmLocalInfo->nodeId,
cpmL->pCpmLocalInfo->cpmAddress.nodeAddress,
cpmL->pCpmLocalInfo->cpmAddress.portId);
else
clOsalPrintf("%10s \n", cpmL->nodeName);
suCount = cpmL->noOfsu;
while (suCount)
{
rc = clCntNodeUserDataGet(cpmL->suTable, hSU,
(ClCntDataHandleT *) &su);
CL_CPM_CHECK(CL_DEBUG_ERROR,
("Unable to get first container su Node data %x\n",
rc), rc);
clOsalPrintf("\t %10s |%15s |%11s |%16s \n", su->suName,
_cpmPresenceStateNameGet(su->suPresenceState),
_cpmOperStateNameGet(su->suOperState),
_cpmReadinessStateNameGet(su->suReadinessState));
tempCompRef = su->suCompList;
while (tempCompRef != NULL)
{
clOsalPrintf
("-----------------------------------------------------------------------\n");
clOsalPrintf("\t\t%10s %14d |%15s |%11s |%16s \n",
tempCompRef->ref->compConfig->compName,
tempCompRef->ref->compRestartCount,
_cpmPresenceStateNameGet(tempCompRef->ref->
compPresenceState),
_cpmOperStateNameGet(tempCompRef->ref->
compOperState),
_cpmReadinessStateNameGet(tempCompRef->ref->
compReadinessState));
tempCompRef = tempCompRef->pNext;
}
suCount--;
if (suCount)
{
rc = clCntNextNodeGet(cpmL->suTable, hSU, &hSU);
CL_CPM_CHECK(CL_DEBUG_ERROR, ("\n Unable to Get Node Data \n"),
rc);
}
}
#endif
sprintf(tempStr, "%s",
"-----------------------------------------------------------------------\n");
rc = clBufferNBytesWrite(message, (ClUint8T *) tempStr,
strlen(tempStr));
CL_CPM_CHECK(CL_DEBUG_ERROR, ("\n Unable to write message \n"), rc);
cpmLCount--;
if (cpmLCount)
{
rc = clCntNextNodeGet(gpClCpm->cpmTable, hNode, &hNode);
CL_CPM_CHECK(CL_DEBUG_ERROR, ("\n Unable to Get Node Data \n"),
rc);
rc = clCntNodeUserDataGet(gpClCpm->cpmTable, hNode,
(ClCntDataHandleT *) &cpmL);
CL_CPM_CHECK(CL_DEBUG_ERROR,
("Unable to get container Node data %d\n", rc), rc);
}
}
/*
* Bug 4986 :
* Moved the code to NULL terminate the string
* below the done: label, so that the usage string
* written to the buffer is also NULL terminated.
*/
done:
/*
* NULL terminate the string
*/
sprintf(tempStr, "%s", "\0");
rc = clBufferNBytesWrite(message, (ClUint8T *) tempStr, 1);
CL_CPM_CHECK(CL_DEBUG_ERROR, ("\n Unable to write message \n"), rc);
rc = clBufferFlatten(message, (ClUint8T **) &tmpStr);
CL_CPM_CHECK(CL_DEBUG_ERROR, ("\n Unable to flatten message \n"), rc);
*retStr = tmpStr;
clBufferDelete(&message);
return rc;
failure:
clBufferDelete(&message);
return rc;
}
ClRcT clComponentCallBack(void *arg)
{
ClRcT rc = CL_OK;
struct timeval alarmTime;
ClAlarmHandleT alarmHandle;
ClNameT moidName = {strlen("\\Chassis:0\\GigeBlade:0"),
"\\Chassis:0\\GigeBlade:0"};
ClNameT moidName2 = {strlen("\\Chassis:0\\GigeBlade:0\\GigePort:0"),
"\\Chassis:0\\GigeBlade:0\\GigePort:0"};
ClAlarmInfoT *pAlarmInfo;
ClCorMOIdT moId;
ClNameT moIdName = {0};
pAlarmInfo = clHeapAllocate(sizeof(ClAlarmInfoT)+strlen("HelloHelloHelloHelloHelloHelloHelloHello")+1);
if(pAlarmInfo == NULL)
{
clOsalPrintf("Failed while allocating the memory for the alamr information.");
return CL_ALARM_RC(CL_ERR_NO_MEMORY);
}
clCpmComponentNameGet(0,&(pAlarmInfo->compName));
CL_DEBUG_PRINT(CL_DEBUG_ERROR, (" CompName : %s\n", pAlarmInfo->compName.value));
clCorMoIdNameToMoIdGet(&moidName,&(pAlarmInfo->moId));
pAlarmInfo->alarmState = CL_ALARM_STATE_ASSERT;
pAlarmInfo->category = CL_ALARM_CATEGORY_QUALITY_OF_SERVICE;
pAlarmInfo->specificProblem = 0;
pAlarmInfo->severity = CL_ALARM_SEVERITY_CRITICAL;
gettimeofday(&alarmTime,NULL);
pAlarmInfo->eventTime = alarmTime.tv_sec;
pAlarmInfo->len = strlen("HelloHelloHelloHelloHelloHelloHelloHello")+1;
memcpy(pAlarmInfo->buff,"HelloHelloHelloHelloHelloHelloHelloHello",pAlarmInfo->len);
ClEoExecutionObjT* peoObj=(ClEoExecutionObjT *)arg;
if ( (rc = clEoMyEoObjectSet(peoObj)) != CL_OK)
{
CL_DEBUG_PRINT(CL_DEBUG_ERROR, (" clEoMyEoObjectSet failed, rc:0x%x \n", rc));
return rc;
}
/**
* Raising alarm for :
* MOId - /Chassis:0/GigeBlade:0
* Category - CL_ALARM_CATEGORY_QUALITY_OF_SERVICE
* Probable Cause - CL_ALARM_PROB_CAUSE_BANDWIDTH_REDUCED
*/
CL_DEBUG_PRINT(CL_DEBUG_ERROR,("Raising alarm for [%s] and the probable cause\
[%d]", moidName.value, CL_ALARM_PROB_CAUSE_LOSS_OF_FRAME));
pAlarmInfo->probCause = CL_ALARM_PROB_CAUSE_BANDWIDTH_REDUCED;
rc = clAlarmRaise(pAlarmInfo,&alarmHandle);
/**
* Raising alarm for :
* MOId - /Chassis:0/GigeBlade:0
* Category - CL_ALARM_CATEGORY_QUALITY_OF_SERVICE
* Probable Cause - CL_ALARM_PROB_CAUSE_RESPONSE_TIME_EXCESSIVE
*/
pAlarmInfo->probCause = CL_ALARM_PROB_CAUSE_RESPONSE_TIME_EXCESSIVE;
CL_DEBUG_PRINT(CL_DEBUG_ERROR,("Raising alarm for [%s] and the probable \
cause [%d]", moidName.value, CL_ALARM_PROB_CAUSE_RESPONSE_TIME_EXCESSIVE));
rc = clAlarmRaise(pAlarmInfo,&alarmHandle);
CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("Alarm Category : %d \n",pAlarmInfo->category ));
CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("Alarm severity: %d \n",pAlarmInfo->severity));
rc = clAlarmClientResourceInfoGet(alarmHandle, &moId);
if ( CL_OK != rc)
{
clOsalPrintf("Failed while asking the moid for the alarm handle [%d]. rc[0x%x] \n", alarmHandle, rc);
return rc;
}
rc = clCorMoIdToMoIdNameGet(&moId, &moIdName);
if(CL_OK != rc)
{
clOsalPrintf("Failed while getting the mOId name from moid . rc[0x%x]", rc) ;
return rc;
}
clOsalPrintf("The MOID for the alarm handle is [%d] is [%s]\n", alarmHandle, moIdName.value);
/**
* Raising alarm for :
* MOId - /Chassis:0/GigeBlade:0/GigePort:0
* Category - CL_ALARM_CATEGORY_QUALITY_OF_SERVICE
* Probable Cause - CL_ALARM_PROB_CAUSE_LOSS_OF_FRAME
*/
CL_DEBUG_PRINT(CL_DEBUG_ERROR,("Raising alarm for [%s] and the probable \
cause [%d]", moidName2.value, CL_ALARM_PROB_CAUSE_LOSS_OF_FRAME));
pAlarmInfo->probCause = CL_ALARM_PROB_CAUSE_LOSS_OF_FRAME;
clCorMoIdNameToMoIdGet(&moidName2,&(pAlarmInfo->moId));
rc = clAlarmRaise(pAlarmInfo,&alarmHandle);
CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("Alarm Category : %d \n",pAlarmInfo->category ));
CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("Alarm severity: %d \n",pAlarmInfo->severity));
rc = clAlarmClientResourceInfoGet(alarmHandle, &moId);
if ( CL_OK != rc)
{
clOsalPrintf("Failed while asking the moid for the alarm handle [%d]. rc[0x%x] \n", alarmHandle, rc);
return rc;
}
rc = clCorMoIdToMoIdNameGet(&moId, &moIdName);
if(CL_OK != rc)
{
clOsalPrintf("Failed while getting the mOId name from moid . rc[0x%x]", rc) ;
return rc;
}
clOsalPrintf("The MOID for the alarm handle is [%d] is [%s]\n", alarmHandle, moIdName.value);
/**
* Raising alarm for :
* MOId - /Chassis:0/GigeBlade:0/GigePort:0
* Category - CL_ALARM_CATEGORY_QUALITY_OF_SERVICE
* Probable Cause - CL_ALARM_PROB_CAUSE_MULTIPLEXER_PROBLEM
*/
CL_DEBUG_PRINT(CL_DEBUG_ERROR,("Raising alarm for [%s] and the probable \
cause [%d]", moidName2.value, CL_ALARM_PROB_CAUSE_MULTIPLEXER_PROBLEM));
pAlarmInfo->probCause = CL_ALARM_PROB_CAUSE_MULTIPLEXER_PROBLEM;
clCorMoIdNameToMoIdGet(&moidName2,&(pAlarmInfo->moId));
rc = clAlarmRaise(pAlarmInfo,&alarmHandle);
CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("Alarm Category : %d \n",pAlarmInfo->category ));
CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("Alarm severity: %d \n",pAlarmInfo->severity));
/**
* Clearing alarm for :
* MOId - /Chassis:0/GigeBlade:0/GigePort:0
* Category - CL_ALARM_CATEGORY_QUALITY_OF_SERVICE
* Probable Cause - CL_ALARM_PROB_CAUSE_MULTIPLEXER_PROBLEM
*/
CL_DEBUG_PRINT(CL_DEBUG_ERROR,("Clearing alarm for [%s] and the probable \
cause [%d]", moidName.value, CL_ALARM_PROB_CAUSE_MULTIPLEXER_PROBLEM));
pAlarmInfo->alarmState = CL_ALARM_STATE_CLEAR;
clCorMoIdNameToMoIdGet(&moidName2,&(pAlarmInfo->moId));
rc = clAlarmRaise(pAlarmInfo,&alarmHandle);
CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("Alarm Category : %d \n",pAlarmInfo->category ));
CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("Alarm severity: %d \n",pAlarmInfo->severity));
/**
* Clearing alarm for :
* MOId - /Chassis:0/GigeBlade:0/GigePort:0
* Category - CL_ALARM_CATEGORY_QUALITY_OF_SERVICE
* Probable Cause - CL_ALARM_PROB_CAUSE_LOSS_OF_FRAME
*/
CL_DEBUG_PRINT(CL_DEBUG_ERROR,("Raising alarm for [%s] and the probable \
cause [%d]", moidName.value, CL_ALARM_PROB_CAUSE_LOSS_OF_FRAME));
pAlarmInfo->probCause = CL_ALARM_PROB_CAUSE_LOSS_OF_FRAME;
rc = clAlarmRaise(pAlarmInfo,&alarmHandle);
CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("Alarm Category : %d \n",pAlarmInfo->category ));
CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("Alarm severity: %d \n",pAlarmInfo->severity));
return rc;
}
ClParserPtrT clParserGet(ClParserPtrT xml, ...)
{
/*return ezxml_get(xml, ...);*/
clOsalPrintf("Not Implemanted ............\n");
return NULL;
}
ClRcT
clCompAppInitialize(
ClUint32T argc,
ClCharT *argv[])
{
ClNameT appName;
ClCpmCallbacksT callbacks;
ClVersionT version;
ClIocPortT iocPort;
ClRcT rc = CL_OK;
/*
* 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.appHealthCheck = NULL;
callbacks.appTerminate = clCompAppTerminate;
callbacks.appCSISet = clCompAppAMFCSISet;
callbacks.appCSIRmv = clCompAppAMFCSIRemove;
callbacks.appProtectionGroupTrack = NULL;
/*
* Get IOC Address, Port and Name. Register with AMF.
*/
clEoMyEoIocPortGet(&iocPort);
if ( (rc = clCpmClientInitialize(&cpmHandle, &callbacks, &version)) )
goto errorexit;
/*
* If this component will provide a service, register it now.
*/
#if HAS_EO_SERVICES
idlClientInstall();
#endif
/*
* Do the application specific initialization here.
*/
/*
* ---BEGIN_APPLICATION_CODE---
*/
// ...
/*
* ---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 = clCpmComponentNameGet(cpmHandle, &appName)) )
goto errorexit;
if ( (rc = clCpmComponentRegister(cpmHandle, &appName, NULL)) )
goto errorexit;
if ( (rc = clComponentEventInit()) )
goto errorexit;
/*
* Print out standard information for this component.
*/
clprintf ("Component [%s] : PID [%d]. Initializing\n", appName.value, mypid);
clprintf (" IOC Address : 0x%x\n", clIocLocalAddressGet());
clprintf (" IOC Port : 0x%x\n", iocPort);
/*
* This is where the application code starts. If the main thread usage
* policy is CL_EO_USE_THREAD_FOR_APP, then return from this fn only
* after the application terminates. If the main thread usage policy is
* CL_EO_USE_THREAD_FOR_RECV, then return from this fn after doing the
* application specific initialization and registration.
*/
/*
* ---BEGIN_APPLICATION_CODE---
*/
clOsalPrintf("Inside the Alarm Test App 1.............. ############### \n");
/*
* ---END_APPLICATION_CODE---
*/
return rc;
errorexit:
clprintf ("Component [%s] : PID [%d]. Initialization error [0x%x]\n",
appName.value, mypid, rc);
return rc;
}
