SaAisErrorT saAmfInitialize(SaAmfHandleT *amfHandle,
                            const SaAmfCallbacksT *amfCallbacks,
                            SaVersionT *version)
{
    ClRcT rc;
    
    CL_AMF_TEST_HOOK_INITIALIZE(amfHandle, amfCallbacks, version);

    rc = clASPInitialize();
    if(CL_OK != rc)
    {
        return clClovisToSafError(rc);
    }
    
    rc = clCpmClientInitialize((ClCpmHandleT *)amfHandle,
                               (ClCpmCallbacksT *)amfCallbacks,
                               (ClVersionT *)version);
    
    if(rc == CL_OK)
    {
        ClSelectionObjectT dispatchFd = 0;
        rc = clCpmSelectionObjectGet(*amfHandle, &dispatchFd);
    }

    return clClovisToSafError(rc);
}
コード例 #2
0
/*
 * To all the application we need to pass 1. Component Name 2. Ioc Address So
 * as of now we have decided that these will be passed as environment variable 
 */
ClRcT clEoInitialize(ClInt32T argc, ClCharT *argv[])
{
    ClRcT rc = CL_OK;

    ClEoExecutionObjT *pThis = NULL;

    ClTimerTimeOutT waitForExit = { 0,  0 };

    clEoProgName = argv[0];
   
    clLog(CL_LOG_SEV_INFO, CL_LOG_AREA, CL_LOG_CTXT_INI, "Process [%s] started. PID [%d]", clEoProgName, (int)getpid());
    
    clEoStaticQueueInit();

    clASPInitialize();
    
    rc = clEoMyEoObjectGet(&pThis);
    if(rc != CL_OK)
    {
        clLog(CL_LOG_SEV_CRITICAL, CL_LOG_AREA, CL_LOG_CTXT_INI, "Exiting : EO my object get failed. error [%x0x].\n", rc);
        exit(1);
    }
        
    /*
     * This should keep track of blocking APP initialize.
     */

    clEoRefInc(pThis);

    /* Call the application's initialize function */
    rc = eoConfig.clEoCreateCallout(argc, argv);
    if (rc != CL_OK)
    {
        clLog(CL_LOG_SEV_CRITICAL, CL_LOG_AREA, CL_LOG_CTXT_INI, "Application initialization failed, error [0x%x]", rc);
        exit(1);
    }

    if(eoConfig.appType == CL_EO_USE_THREAD_FOR_APP)
    {
        clEoUnblock(pThis);
    }

    /*
     * We block on the exit path waiting for a terminate.
     */
    clOsalMutexLock(&pThis->eoMutex);

    while (pThis->refCnt > 0)
    {
        clOsalCondWait(&pThis->eoCond, &pThis->eoMutex, waitForExit);
    }
    clOsalMutexUnlock(&pThis->eoMutex);

    clEoTearDown();
    clLog(CL_LOG_SEV_INFO, CL_LOG_AREA, CL_LOG_CTXT_FIN, "Process [%s] exited normally", argv[0]);

    if (clDbgNoKillComponents)
    {
      clLog(CL_LOG_SEV_CRITICAL, CL_LOG_AREA, CL_LOG_CTXT_FIN,
            "In debug mode and 'clDbgNoKillComponents' is set, so this process will pause, not exit.");
      while(1) sleep(10000); /* Using sleep here instead of Osal because Osal is likely shutdown */
    }
    
    return CL_OK;
}
SaAisErrorT
saClmInitialize (
        SaClmHandleT*const clmHandle,
        const SaClmCallbacksT*const clmCallbacks,
        SaVersionT*const version
        )
{
    ClRcT rc = CL_OK;
    ClGmsCallbacksT gmsCallbacks = {0};
    ClGmsHandleT gmsHandle = CL_HANDLE_INVALID_VALUE;
    /* 
     * Use a 32 bit handle type to create a handle. Dont
     * use the 64 bit clmHandle directly as it would create issues
     * in mixed mode operations.
     */
    ClHandleT   localHandle = CL_HANDLE_INVALID_VALUE;
    SaClmInstanceT      *clmInstance = NULL;
    ClHandleT   dispatchHandle = CL_HANDLE_INVALID_VALUE;

    if (clmHandle == (const void*)NULL)
    {
        return _aspErrToAisErr(CL_ERR_NULL_POINTER);
    }

    rc = clASPInitialize();
    if(CL_OK != rc)
    {
        clLogCritical("CLM", "INI",
                      "ASP initialize failed, rc[0x%X]", rc);
        return SA_AIS_ERR_LIBRARY;
    }
    
    /* 
     * Create the handle database for clm first, if it is 
     * not already created
     */
    saClmLibInitialize();

    if (clmCallbacks != (const void*)NULL)
    {
        /*Set GMS callbacks to callback wrappers*/
        if (clmCallbacks->saClmClusterNodeGetCallback != NULL)
        {
            gmsCallbacks.clGmsClusterMemberGetCallback =
                clGmsClusterMemberGetCallbackWrapper;
        }

        if (clmCallbacks->saClmClusterTrackCallback != NULL)
        {
            gmsCallbacks.clGmsClusterTrackCallback =
                clGmsClusterTrackCallbackWrapper;
    }
    }

    /* Initialize GMS */
    rc = clGmsInitialize(&gmsHandle,
            &gmsCallbacks, 
                         (ClVersionT*)version);
    if(rc != CL_OK)
    {
        clLogError("CLM","INI",
                   "clGmsInitialize failed with rc 0x%x\n",rc);
        return _aspErrToAisErr(rc);
    }

    localHandle = gmsHandle;
    /*
     * Create a local handle to be returned as clmHandle
     * Here we will create the handle value same as that of
     * gmsHandle so that we can keep the reference during
     * callback invocation through thread specific data
     */
    rc = clHandleCreateSpecifiedHandle(databaseHandle,
                                       sizeof(SaClmInstanceT),
                                       localHandle);
    if (rc != CL_OK)
    {
        clLogError("CLM","INI",
                   "clHandleCreateSpecifiedHandle failed with rc 0x%x\n",rc);
        return _aspErrToAisErr(rc);
    }

    /*
     * Assign localHandle to clmHandle, but keep using localHandle,
     * as it is compliant with ASP APIs.
     */
    *clmHandle = localHandle;
    SA_GMS_INIT_COUNT_INC();

    /* Checkout the handle */
    rc = clHandleCheckout(databaseHandle, localHandle, (void**)&clmInstance);
    CL_ASSERT((rc == CL_OK) && (clmInstance != NULL));


    if (clmCallbacks != (const void*)NULL)
    {
        /*Save the saf callbacks in the handle*/
        memcpy(&clmInstance->callbacks, clmCallbacks, sizeof(SaClmCallbacksT));
    }

    /* Initialize dispatch */
    rc = clDispatchRegister(&dispatchHandle,
                            localHandle,
                            dispatchWrapperCallback,
                            dispatchQDestroyCallback);
    if (rc != CL_OK)
    {
        clLogError("CLM","INI",
                   "clDispatchRegister failed with rc 0x%x\n",rc);
        goto error_return;
    }
    /* Store dispatchHandle in the clmHandle */
    clmInstance->dispatchHandle = dispatchHandle;

error_return:
    if ((clHandleCheckin(databaseHandle, localHandle)) != CL_OK)
    {
        clLogError(CL_LOG_AREA_UNSPECIFIED,CL_LOG_CONTEXT_UNSPECIFIED,
                   "clHandleCheckin failed");
}

    return _aspErrToAisErr(rc);
}
SaAisErrorT saCkptInitialize(SaCkptHandleT           *saCkptHandle,
                             const SaCkptCallbacksT  *callbacks,
                             SaVersionT              *version)
{
    ClRcT            rc            = CL_OK;
    SaAisErrorT      safRc         = SA_AIS_OK;
    ClCkptCallbacksT ckptCallbacks = {0};
    ClCkptSvcHdlT    ckptHandle    = CL_CKPT_INVALID_HDL;

    /*
     * Validate the input parameters.
     */
    if(saCkptHandle == NULL)
    {
        return SA_AIS_ERR_INVALID_PARAM;
    }

    rc = clASPInitialize();
    if(CL_OK != rc)
    {
        clLogCritical("CKP", "INI",
                      "ASP initialize failed, rc[0x%X]", rc);
        return SA_AIS_ERR_LIBRARY;
    }
    
    /*
     * Copy the callbacks in a global varible and register clovis specific
     * callback functions. These function will inturn call the user 
     * registered callback functions.
     */
    if(callbacks != NULL)
    {
        gSafCallback.saCkptCheckpointOpenCallback = 
            callbacks->saCkptCheckpointOpenCallback; 
        gSafCallback.saCkptCheckpointSynchronizeCallback = 
            callbacks->saCkptCheckpointSynchronizeCallback; 

        if(callbacks->saCkptCheckpointOpenCallback != NULL)
            ckptCallbacks.checkpointOpenCallback = ckptWrapOpenCallback; 
        else
            ckptCallbacks.checkpointOpenCallback = NULL;

        if(callbacks->saCkptCheckpointSynchronizeCallback != NULL)     
            ckptCallbacks.checkpointSynchronizeCallback = 
                ckptWrapSynchronizeCallback; 
        else
            ckptCallbacks.checkpointSynchronizeCallback = NULL;

        /*
         * Call the ckpt client library callback function.
         */
        rc = clCkptInitialize( &ckptHandle,
                &ckptCallbacks, 
                (ClVersionT *) version);
    }    
    else
    {
        /*
         * Call the ckpt client library callback function.
         */
        rc = clCkptInitialize( &ckptHandle,
                NULL, 
                (ClVersionT *) version);

    }

    /*
     * Copy th ckpt handle back to output buffer.
     */
    *saCkptHandle = ckptHandle;                       

    /*
     * Translate the clovis error type to SAF error type.
     */
    clErrorTxlate(rc, &safRc);
    
    return safRc;
}