SaAisErrorT alarmClockCkptHotStandbyDeregister(SaCkptCheckpointHandleT ckpt_hdl)
{
ClRcT ret_code = CL_OK;
g_hot_standby = HOT_STANDBY_IDLE;
sessionBufferStop();
ret_code = clCkptImmediateConsumptionRegister(ckpt_hdl, NULL, NULL);
return (ret_code == CL_OK) ? SA_AIS_OK : SA_AIS_ERR_BAD_OPERATION;
}
/*
* Register checkpoint for immediate consumption, all components that
* register using this API for a checkpoint will be notified through
* the callback function provided when a checkpoint update occurs
* All components except the one that actually updates the checkpoint.
*/
SaAisErrorT alarmClockCkptHotStandbyRegister(SaCkptCheckpointHandleT ckpt_hdl)
{
ClRcT ret_code = CL_OK;
/* When the standby becomes Active it checks this flag to see whether
* it needs to perform a checkpoint read or not. If TRUE then the
* assumption is that the checkpoint updates on standby have happened
* via the callback
*/
g_hot_standby = HOT_STANDBY_IDLE;
ret_code = clCkptImmediateConsumptionRegister(ckpt_hdl, alarmClockCkptCallback, NULL);
if (ret_code != CL_OK)
{
alarmClockLogWrite( CL_LOG_SEV_ERROR,
"alarmClockCkptCreate(pid=%d): Failed to register ckpt callback rc[0x%x]\n",
getpid(), ret_code);
alarmClockLogWrite(CL_LOG_SEV_WARNING,
"alarmClockCkptCreate(pid=%d): Falling back to warm standby mode\n", getpid());
return SA_AIS_ERR_BAD_OPERATION;
}
alarmClockLogWrite(CL_LOG_SEV_DEBUG, "alarmClockCkptCreate: Successfully registered for callbacks");
return SA_AIS_OK;
}
/*******************************************************************************
Feature API: alarmClockCkptCreate
Description : Create a checkpoint given a name and the number of sections. In
addition the nature of the checkpoint needs to be specified, synchronous versus
asynchronous. If asynchronous collocated versus non collocated.
Arguments In:
1. Checkpoint Name
2. Number of Sections
3. Size of section
*******************************************************************************/
SaAisErrorT
alarmClockCkptCreate (
const SaStringT ckpt_name,
SaUint32T num_sections,
SaSizeT section_size,
SaCkptCheckpointHandleT *ckpt_hdl )
{
SaAisErrorT ret_code = SA_AIS_OK;
SaNameT ckpt_name_t;
SaCkptCheckpointCreationAttributesT ckpt_cr_attr;
SaCkptCheckpointOpenFlagsT ckpt_open_flags;
SaTimeT timeout;
/* Initiailze name struct for ckpt
*/
ckpt_name_t.length = strlen(ckpt_name);
strcpy( ( SaStringT )ckpt_name_t.value,ckpt_name);
/* Initialize check point creation flags
*/
ckpt_cr_attr.creationFlags = SA_CKPT_CHECKPOINT_COLLOCATED | CL_CKPT_DISTRIBUTED;
/* Maximum checkpoint size = size of all checkpoints combined
*/
ckpt_cr_attr.checkpointSize = num_sections * section_size;
/* Retention time: forever
*/
ckpt_cr_attr.retentionDuration = (SaTimeT)-1;
if ( num_sections == 1 )
{
/* use a named section instead of the default section */
ckpt_cr_attr.maxSections = num_sections + 1;
}
else
{
ckpt_cr_attr.maxSections = num_sections;
}
ckpt_cr_attr.maxSectionSize = section_size;
ckpt_cr_attr.maxSectionIdSize = sizeof(SaUint32T);
/* forever
*/
timeout = (SaTimeT)-1;
/* Initialize the checkpoint open flags
*/
ckpt_open_flags = (SA_CKPT_CHECKPOINT_READ |
SA_CKPT_CHECKPOINT_WRITE |
SA_CKPT_CHECKPOINT_CREATE);
/* forever
*/
timeout = (SaTimeT)-1;
ret_code = saCkptCheckpointOpen(ckpt_svc_hdl,
&ckpt_name_t,
&ckpt_cr_attr,
ckpt_open_flags,
timeout,
ckpt_hdl);
if ((ret_code != SA_AIS_OK)||(*ckpt_hdl == 0))
{
alarmClockLogWrite(CL_LOG_SEV_ERROR, "alarmClockCkptCreate: Failed to create ckpt:0x%x\n", ret_code);
return ret_code;
}
if (1) // *ckpt_hot_standby == CL_TRUE)
{
/*
* Register checkpoint for immediate consumption, all components that
* register using this API for a checkpoint will be notified through
* the callback function provided when a checkpoint update occurs
* All components except the one that actually updates the checkpoint.
*/
/* When the standby becomes Active it checks this flag to see whether
* it needs to perform a checkpoint read or not. If TRUE then the
* assumption is that the checkpoint updates on standby have happened
* via the callback
*/
g_hot_standby = HOT_STANDBY_IDLE;
ret_code = clCkptImmediateConsumptionRegister(*ckpt_hdl, alarmClockCkptCallback, NULL);
if (ret_code != CL_OK)
{
alarmClockLogWrite( CL_LOG_SEV_ERROR,
"alarmClockCkptCreate(pid=%d): Failed to register ckpt callback rc[0x%x]\n",
getpid(), ret_code);
alarmClockLogWrite(CL_LOG_SEV_WARNING,
"alarmClockCkptCreate(pid=%d): Falling back to warm standby mode\n", getpid());
//*ckpt_hot_standby = CL_FALSE;
return ret_code;
}
alarmClockLogWrite(CL_LOG_SEV_ERROR, "alarmClockCkptCreate: Successfully registered for callbacks");
}
alarmClockLogWrite(CL_LOG_SEV_ERROR, "alarmClockCkptCreate: Successful creation ckpt [%llx]\n",
*ckpt_hdl);
return SA_AIS_OK;
}
/*******************************************************************************
Feature API: alarmClockCkptCreate
Description : Create a checkpoint given a name and the number of sections. In
addition the nature of the checkpoint needs to be specified, synchronous versus
asynchronous. If asynchronous collocated versus non collocated.
Arguments In:
1. Checkpoint Name
2. Number of Sections
3. Size of section
4. ckpt_hot_standby: If set to true then hot standby turned on
Arguments Out:
1. : returns ckpt_handle
2. ckpt_hot_standby: If set to true then hot standby was successful
Return Value:
ClInt32Teger 0 if success, non zero if failure
*******************************************************************************/
ClRcT
alarmClockCkptCreate (
const ClCharT *ckpt_name,
ClInt32T num_sections,
ClInt32T section_size,
ClCkptHdlT *ckpt_hdl,
ClBoolT *ckpt_hot_standby )
{
ClRcT ret_code = CL_OK;
SaNameT ckpt_name_t;
ClCkptCheckpointCreationAttributesT ckpt_cr_attr;
ClCkptOpenFlagsT ckpt_open_flags;
ClTimeT timeout;
ClCharT section_id_name[ CL_MAX_NAME_LENGTH ];
/* First ensure that the Initialize function is called
*/
ret_code = alarmClockCkptInitialize();
if (ret_code != CL_OK)
{
alarmClockLogWrite(CL_LOG_SEV_ERROR,
"alarmClockCkptCreate(pid=%d): failed initialze service\n",
getpid());
return ret_code;
}
/* Initiailze name struct for ckpt
*/
ckpt_name_t.length = strlen(ckpt_name);
strcpy(ckpt_name_t.value, ckpt_name);
/* Get the max size for a name of sectionId
*/
sprintf(section_id_name, "s%05d", num_sections);
if (*ckpt_hot_standby == CL_TRUE)
{
/* Initialize check point creation flags (includes hot standby flag)
*/
ckpt_cr_attr.creationFlags = CL_CKPT_CHECKPOINT_COLLOCATED | CL_CKPT_DISTRIBUTED;
}
else
{
/* Initialize check point creation flags
*/
ckpt_cr_attr.creationFlags = CL_CKPT_CHECKPOINT_COLLOCATED;
}
/* Maximum checkpoint size = size of all checkpoints combined
*/
ckpt_cr_attr.checkpointSize = num_sections * section_size;
/* Retention time: forever
*/
ckpt_cr_attr.retentionDuration = (ClTimeT)-1;
if ( num_sections == 1 )
{
/* use a named section instead of the default section */
ckpt_cr_attr.maxSections = num_sections + 1;
}
else
{
ckpt_cr_attr.maxSections = num_sections;
}
ckpt_cr_attr.maxSectionSize = section_size;
ckpt_cr_attr.maxSectionIdSize = (ClSizeT)(strlen(section_id_name)+1);
/* forever
*/
timeout = (ClTimeT)-1;
/* Initialize the checkpoint open flags
*/
ckpt_open_flags = (CL_CKPT_CHECKPOINT_READ |
CL_CKPT_CHECKPOINT_WRITE |
CL_CKPT_CHECKPOINT_CREATE);
/* forever
*/
timeout = (ClTimeT)-1;
ret_code = clCkptCheckpointOpen(ckpt_svc_hdl,
&ckpt_name_t,
&ckpt_cr_attr,
ckpt_open_flags,
timeout,
(ClCkptHdlT *)ckpt_hdl);
if (ret_code != CL_OK)
{
alarmClockLogWrite(CL_LOG_SEV_ERROR,
"alarmClockCkptCreate(pid=%d): Failed to create ckpt:0x%x\n",
getpid(), ret_code);
return ret_code;
}
if (*ckpt_hot_standby == CL_TRUE)
{
/*
* Register checkpoint for immediate consumption, all components that
* register using this API for a checkpoint will be notified through
* the callback function provided when a checkpoint update occurs
* All components except the one that actually updates the checkpoint.
*/
/* When the standby becomes Active it checks this flag to see whether
* it needs to perform a checkpoint read or not. If TRUE then the
* assumption is that the checkpoint updates on standby have happened
* via the callback
*/
g_hot_standby = __HOT_STANDBY_IDLE;
ret_code = clCkptImmediateConsumptionRegister(*ckpt_hdl, alarmClockCkptCallback, NULL);
if (ret_code != CL_OK)
{
alarmClockLogWrite( CL_LOG_SEV_ERROR,
"alarmClockCkptCreate(pid=%d): Failed to register ckpt callback rc[0x%x]\n",
getpid(), ret_code);
alarmClockLogWrite(CL_LOG_SEV_WARNING,
"alarmClockCkptCreate(pid=%d): Falling back to warm standby mode\n", getpid());
*ckpt_hot_standby = CL_FALSE;
}
}
alarmClockLogWrite(CL_LOG_SEV_INFO, "alarmClockCkptCreate: Ckpt [%s] created successfully",
ckpt_name);
return ret_code;
}
