void *th_dispatch (void *arg)
{
	struct thread_data *td = (struct thread_data *)arg;
	SaCkptHandleT ckptHandle;
	SaCkptCheckpointHandleT handle;
	SaAisErrorT error;
	int i;
	SaUint32T erroroneousVectorIndex = 0;

	error = saCkptInitialize (&ckptHandle, &callbacks, &version);

	error = saCkptCheckpointOpen (ckptHandle,
		&checkpointName,
		&checkpointCreationAttributes,
		SA_CKPT_CHECKPOINT_READ|SA_CKPT_CHECKPOINT_WRITE,
		0,
		&handle);
	for (i = 0; i < 1000; i++) {
		error = saCkptCheckpointWrite (handle,
			WriteVectorElements,
			1,
			&erroroneousVectorIndex);
		printf ("Thread %d: Attempt %d: error %d\n",
			td->thread_no, i, error);
		if (error != SA_AIS_OK) {
			printf ("Thread %d: Error from write.\n", td->thread_no);
		}
	}

    error = saCkptFinalize (ckptHandle);

	return (0);
}
int main (void) {
	SaCkptHandleT ckpt_handles[CHECKPOINT_THREADS_MAX];
	SaCkptCheckpointHandleT checkpoint_handles[CHECKPOINT_THREADS_MAX];
	SaAisErrorT error;
	int size;
	int i, j;
	
	signal (SIGALRM, sigalrm_handler); 

	printf ("Creating (%d) checkpoints.\n", CHECKPOINT_THREADS_MAX);
	/*
	 * Create CHECPOINT_THREADS_MAX checkpoints
	 */
	for (i  = 0; i < CHECKPOINT_THREADS_MAX; i++) {
		sprintf ((char *)checkpointName.value, "checkpoint (%d)", i);
		checkpointName.length = strlen ((char *)checkpointName.value);
		do {
			error = saCkptInitialize (&ckpt_handles[i], &callbacks, &version);
		} while (error == SA_AIS_ERR_TRY_AGAIN);
		assert (error == SA_AIS_OK);

		do {
		error = saCkptCheckpointOpen (ckpt_handles[i],
			&checkpointName,
			&checkpointCreationAttributes,
			SA_CKPT_CHECKPOINT_CREATE|SA_CKPT_CHECKPOINT_READ|SA_CKPT_CHECKPOINT_WRITE,
			SA_TIME_END,
			&checkpoint_handles[i]);
		} while (error == SA_AIS_ERR_TRY_AGAIN);
		assert (error == SA_AIS_OK);

		do {
			error = saCkptSectionCreate (checkpoint_handles[i],
				&sectionCreationAttributes1,
				"Initial Data #0",
				strlen ("Initial Data #0") + 1);
		} while (error == SA_AIS_ERR_TRY_AGAIN);
		assert (error == SA_AIS_OK);

		do {
			error = saCkptSectionCreate (checkpoint_handles[i],
				&sectionCreationAttributes2,
				"Initial Data #0",
				strlen ("Initial Data #0") + 1);
		} while (error == SA_AIS_ERR_TRY_AGAIN);
		assert (error == SA_AIS_OK);
	}

	for (i = CHECKPOINT_THREADS_START; i < CHECKPOINT_THREADS_MAX; i++) {	/* i threads */
		printf ("Starting benchmark with (%d) threads.\n", i);
		size = 10000; /* initial size */
		for (j = 0; j < 5; j++) { /* number of runs with i threads */
			alarm (10);
			threaded_bench (ckpt_handles, checkpoint_handles, i, size);
			size += 1000;
		}
	}
	return (0);
}
SaAisErrorT checkpoint_initialize(void)
{
    SaAisErrorT      rc = SA_AIS_OK;
    SaVersionT ckpt_version = {'B', 1, 1};
    SaNameT    ckpt_name = { strlen(CKPT_NAME), CKPT_NAME };
    SaCkptCallbacksT callbacks;
    SaCkptCheckpointCreationAttributesT attrs;

    /* Set up the checkpoint configuration */
    attrs.creationFlags     = SA_CKPT_WR_ACTIVE_REPLICA_WEAK | SA_CKPT_CHECKPOINT_COLLOCATED;        
    attrs.checkpointSize    = sizeof(ClUint32T);
    attrs.retentionDuration = (ClTimeT) 10;        /* How long to keep the checkpoint around even if noone has it open */
    attrs.maxSections       = 2;                   /* Max number of 'rows' in the table */
    attrs.maxSectionSize    = sizeof(ClUint32T);   /* Max 'row' size */
    attrs.maxSectionIdSize  = (ClSizeT)64;         /* Max 'row' identifier size */

    /* These callbacks are only called when an Async style function call completes */
    callbacks.saCkptCheckpointOpenCallback        = checkpointOpenCompleted;
    callbacks.saCkptCheckpointSynchronizeCallback = checkpointSynchronizeCompleted;
        
    clprintf(CL_LOG_SEV_INFO,"Checkpoint Initialize");

        
    /* Initialize checkpointing library */
    rc = saCkptInitialize(&ckptLibraryHandle,	/* Checkpoint service handle */
                          &callbacks,			    /* Optional callbacks table */
                          &ckpt_version);   /* Required verison number */
    if (rc != SA_AIS_OK)
    {
        clprintf(CL_LOG_SEV_ERROR,"Failed to initialize checkpoint service with rc [%#x]", rc);
        return rc;
    }
    clprintf(CL_LOG_SEV_INFO,"Checkpoint service initialized (handle=0x%llx)", ckptLibraryHandle);
        
    /* Create the checkpoint table for read and write. */
    rc = saCkptCheckpointOpen(ckptLibraryHandle,      // Service handle
                              &ckpt_name,         // Checkpoint name
                              &attrs,       // Optional creation attr.
                              (SA_CKPT_CHECKPOINT_READ |
                               SA_CKPT_CHECKPOINT_WRITE |
                               SA_CKPT_CHECKPOINT_CREATE),
                              (SaTimeT)SA_TIME_MAX,        // No timeout
                              &ckpt_handle);      // Checkpoint handle

    if (rc != SA_AIS_OK)
    {
        clprintf(CL_LOG_SEV_ERROR,"Failed [0x%x] to open checkpoint",rc);
        
    }
    else
    {
        clprintf(CL_LOG_SEV_INFO,"Checkpoint opened (handle=0x%llx)", ckpt_handle);
    }
    return rc;
}
int main () {
	SaAisErrorT error;
	SaNameT* WriteCheckpointName = (SaNameT*) malloc(sizeof(SaNameT));
        char name[10];
        SaCkptHandleT ckptHandle;

        sprintf(name,"ckpt%d",1);
        int namelen = strlen(name) + 1;
        memcpy(WriteCheckpointName->value, name, namelen);
        WriteCheckpointName->length = namelen;

	error = saCkptInitialize (&ckptHandle, &callbacks, &version);

        error = saCkptCheckpointOpen (
			ckptHandle,
			WriteCheckpointName,
                        &checkpointCreationAttributes,
                        SA_CKPT_CHECKPOINT_WRITE,
                        1000000000, /* 1 Second */
                        &WriteCheckpointHandle);

        if (error != SA_AIS_OK) {
                fprintf(stderr,"saCkptCheckpointOpen result %d (should be 1)\n", error);
                return error;
        }

        error = saCkptSectionCreate (	WriteCheckpointHandle,
                                        &sectionCreationAttributes,
                                        "Initial Data #0",
                                         strlen ("Initial Data #0") + 1);
        if (error != SA_AIS_OK) {
                fprintf(stderr,"saCkptSectionCreate result = %d\n", error);
                return error;
        }
        
	struct timespec tv;
	tv.tv_sec = 0;
	tv.tv_nsec = 15000000; //15 milliseconds
	
	while(1) {
		process_message();
		nanosleep(&tv,NULL);
	}
	
	return 1;

}
int main (void) {
	SaCkptHandleT ckptHandle;
	SaCkptCheckpointHandleT checkpointHandle;
	SaAisErrorT error;
	int i;
	pthread_t dispatch_thread;

	error = saCkptInitialize (&ckptHandle, &callbacks, &version);

	error = saCkptCheckpointOpen (ckptHandle,
		&checkpointName,
		&checkpointCreationAttributes,
		SA_CKPT_CHECKPOINT_READ|SA_CKPT_CHECKPOINT_WRITE,
		0,
		&checkpointHandle);
	printf ("first open result %d (should be 1)\n", error);

	error = saCkptSectionCreate (checkpointHandle,
		&sectionCreationAttributes1,
		"Initial Data #0",
		strlen ("Initial Data #0") + 1);
printf ("create2 error is %d\n", error);

	error = saCkptSectionCreate (checkpointHandle,
		&sectionCreationAttributes2,
		"Initial Data #0",
		strlen ("Initial Data #0") + 1);
printf ("create2 error is %d\n", error);

	for (i = 0; i < 40; i++) {
		struct thread_data *td;

		td = malloc (sizeof (struct thread_data));
		td->thread_no = i;
		pthread_create (&dispatch_thread, NULL, th_dispatch, td);
	}
	pthread_join (dispatch_thread, NULL);

    error = saCkptInitialize (&ckptHandle, &callbacks, &version);

	return (0);
}
int main (void) {
	SaCkptHandleT ckptHandle;
	SaCkptCheckpointHandleT checkpointHandle;
	SaAisErrorT error;
	int size;
	int i;
	
	signal (SIGALRM, sigalrm_handler);

    error = saCkptInitialize (&ckptHandle, &callbacks, &version);
	fail_on_error(error, "saCkptInitialize");
	
	error = saCkptCheckpointOpen (ckptHandle,
		&checkpointName,
		&checkpointCreationAttributes,
		SA_CKPT_CHECKPOINT_CREATE|SA_CKPT_CHECKPOINT_READ|SA_CKPT_CHECKPOINT_WRITE,
		0,
		&checkpointHandle);
	fail_on_error(error, "saCkptCheckpointOpen");
	error = saCkptSectionCreate (checkpointHandle,
		&sectionCreationAttributes1,
		"Initial Data #0",
		strlen ("Initial Data #0") + 1);
	fail_on_error(error, "saCkptCheckpointSectionCreate");
	error = saCkptSectionCreate (checkpointHandle,
		&sectionCreationAttributes2,
		"Initial Data #0",
		strlen ("Initial Data #0") + 1);
	fail_on_error(error, "saCkptCheckpointSectionCreate");

	size = 1;

	for (i = 0; i < 50; i++) { /* number of repetitions - up to 50k */
		ckpt_benchmark (checkpointHandle, size);
		size += 1000;
	}

    error = saCkptFinalize (ckptHandle);
	return (0);
}
/****************************************************************************
 * Name          : cpsv_test_sync_app_process
 *
 * Description   : This is the function which is given as the input to the
 *                 Application task.
 *
 * Arguments     : info  - This is the information which is passed during
 *                         spawing Application task.
 *
 * Return Values : None.
 *
 * Notes         : None.
 *****************************************************************************/
void cpsv_test_sync_app_process(void *info)
{
   SaCkptHandleT ckptHandle;
   SaCkptCheckpointHandleT  checkpointHandle;
   SaCkptCallbacksT callbk;
   SaVersionT version;
   SaNameT ckptName;
   SaAisErrorT rc;
   SaCkptCheckpointCreationAttributesT ckptCreateAttr;
   SaCkptCheckpointOpenFlagsT ckptOpenFlags;
   SaCkptSectionCreationAttributesT sectionCreationAttributes;
   SaCkptIOVectorElementT writeVector, readVector;
   SaUint32T erroneousVectorIndex;
   void *initialData = "Default data in the section";
   unsigned char read_buff[100] = {0};
   SaTimeT timeout = 1000000000;
   unsigned int  temp_var = (unsigned int)(long)info; 


   memset(&ckptName, 0, 255);
   ckptName.length = strlen(DEMO_CKPT_NAME);
   memcpy(ckptName.value,DEMO_CKPT_NAME,strlen(DEMO_CKPT_NAME));

   callbk.saCkptCheckpointOpenCallback = AppCkptOpenCallback;
   callbk.saCkptCheckpointSynchronizeCallback = AppCkptSyncCallback;
   version.releaseCode= 'B';
   version.majorVersion = 2;
   version.minorVersion = 2;
   
   printf("*******************************************************************\n");
   printf("Demonstrating Checkpoint Service Usage with a collocated Checkpoint \n");
   printf("*******************************************************************\n");
   sleep(2);

   printf("Initialising With Checkpoint Service....\n");
   rc = saCkptInitialize(&ckptHandle,&callbk,&version);
   if(rc == SA_AIS_OK)
      printf("PASSED \n");
   else
      printf("Failed \n");

   ckptCreateAttr.creationFlags = SA_CKPT_CHECKPOINT_COLLOCATED|SA_CKPT_WR_ACTIVE_REPLICA;
   ckptCreateAttr.checkpointSize = 1024;
   ckptCreateAttr.retentionDuration= 100000;
   ckptCreateAttr.maxSections= 2;
   ckptCreateAttr.maxSectionSize = 700;
   ckptCreateAttr.maxSectionIdSize = 4;

   ckptOpenFlags = SA_CKPT_CHECKPOINT_CREATE|SA_CKPT_CHECKPOINT_READ|SA_CKPT_CHECKPOINT_WRITE;
   printf("Opening Collocated Checkpoint = %s with create flags....\n",ckptName.value);
   rc = saCkptCheckpointOpen(ckptHandle,&ckptName,&ckptCreateAttr,ckptOpenFlags,timeout,&checkpointHandle);
   if(rc == SA_AIS_OK)
      printf("PASSED \n");
   else
      printf("Failed \n");


   
   if(temp_var == 1)
   {
 
      printf("Setting the Active Replica for my checkpoint ....\t");
      rc = saCkptActiveReplicaSet(checkpointHandle);
      if(rc == SA_AIS_OK)
         printf("PASSED \n");
      else
         printf("Failed \n");
    

   sectionCreationAttributes.sectionId = (SaCkptSectionIdT*) malloc(sizeof \
                                (SaCkptSectionIdT));
   sectionCreationAttributes.sectionId->id = (unsigned char *)"11";
   sectionCreationAttributes.sectionId->idLen = 2;
   sectionCreationAttributes.expirationTime = 3600000000000ll;   /* One Hour */

   printf("Created Section ....\t");
   rc = saCkptSectionCreate(checkpointHandle,&sectionCreationAttributes,initialData,28);
   if(rc == SA_AIS_OK)
      printf("PASSED \n");
   else
      printf("Failed \n");

  
      writeVector.sectionId.id = (unsigned char *)"11";
      writeVector.sectionId.idLen = 2;
      writeVector.dataBuffer = "The Checkpoint Service provides a facility for processes to store checkpoint data";
      writeVector.dataSize = strlen(writeVector.dataBuffer);
      writeVector.dataOffset = 0;
      writeVector.readSize = 0;

      printf("Writing to Checkpoint %s ....\n",DEMO_CKPT_NAME);
      printf("Section-Id = %s ....\n",writeVector.sectionId.id);
      printf("CheckpointData being written = \"%s\"\n",(char *)writeVector.dataBuffer);
      printf("DataOffset = %llu ....\n",writeVector.dataOffset);
      rc = saCkptCheckpointWrite(checkpointHandle,&writeVector,1,&erroneousVectorIndex);
      if(rc == SA_AIS_OK)
         printf("PASSED \n");
      else
         printf("Failed \n");
      sleep(1); 

      printf("Press <Enter> key to continue...\n");
      getchar();
    }
    else
    {  
       sleep(4);
       readVector.sectionId.id = (unsigned char *)"11";
       readVector.sectionId.idLen = 2;
       readVector.dataBuffer = read_buff;
       readVector.dataSize = 90;
       readVector.dataOffset = 0;                                                                                                                                                                 
       printf("Waiting to Read from Checkpoint %s....\n",DEMO_CKPT_NAME);
       printf("Press <Enter> key to continue...\n");
       getchar();	
       rc = saCkptCheckpointRead(checkpointHandle,&readVector,1,&erroneousVectorIndex);
       printf("Checkpoint Data Read = \"%s\"\n",(char *)readVector.dataBuffer);
       if(rc == SA_AIS_OK)
          printf("PASSED \n");
       else
          printf("Failed \n");   
   }
   printf("Synchronizing My Checkpoint being called ....\n");
   rc = saCkptCheckpointSynchronize(checkpointHandle,timeout);
   if(rc == SA_AIS_OK)
      printf("PASSED \n");
   else
      printf("Failed \n");
                                             
   if(temp_var==1)
   {
      printf("Unlink My Checkpoint ....\t");
      rc = saCkptCheckpointUnlink(ckptHandle,&ckptName);
      if(rc == SA_AIS_OK)
         printf("PASSED \n");
      else
         printf("Failed \n");
   }
   printf("Ckpt Closed ....\t");
   rc = saCkptCheckpointClose(checkpointHandle);
   if(rc == SA_AIS_OK)
      printf("PASSED \n");
   else
      printf("Failed \n");
                                                                                                                                                                      

   printf("Ckpt Finalize being called ....\t");
   rc = saCkptFinalize(ckptHandle);
   if(rc == SA_AIS_OK)
      printf("PASSED \n");
   else
      printf("Failed \n");
                                                                                                                                                                      
   sleep(2);
  return;
}
/*******************************************************************************
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 = CL_CKPT_DISTRIBUTED | CL_CKPT_PEER_TO_PEER_REPLICA;

    /* Maximum checkpoint size = size of all checkpoints combined
     */
    ckpt_cr_attr.checkpointSize = 0;

    /* 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 = 0;
    ckpt_cr_attr.maxSectionIdSize = 256;

    /*  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;        
    }

    alarmClockLogWrite(CL_LOG_SEV_DEBUG, "alarmClockCkptCreate: Successful creation ckpt [%llx]\n", 
                       *ckpt_hdl);    
    return SA_AIS_OK;    
}
Exemple #9
0
static int 
ckpt_open(ckpt_handle *h, const char *ckpt_name, int maxsize,
	  int maxsec, int maxsecsize, int timeout)
{
	SaCkptCheckpointCreationAttributesT attrs;
	SaCkptCheckpointOpenFlagsT flags;
	SaNameT cpname;
#if 0
	SaCkptCheckpointDescriptorT status;
#endif
	SaAisErrorT err = SA_AIS_OK;

	VALIDATE(h);

	flags = SA_CKPT_CHECKPOINT_READ |
		SA_CKPT_CHECKPOINT_WRITE;

	snprintf((char *)cpname.value, SA_MAX_NAME_LENGTH-1,
		 "%s", ckpt_name);
	cpname.length = strlen(ckpt_name);

	h->ck_timeout = timeout;

	err = saCkptCheckpointOpen(h->ck_handle,
				   &cpname,
				   NULL,	
				   flags,
				   timeout,
				   &h->ck_checkpoint);

	if (err == SA_AIS_OK) {
#if 0
		saCkptCheckpointStatusGet(h->ck_handle,
					  &status);

		printf("Checkpoint Size = %d bytes\n", (int)
			status.checkpointCreationAttributes.checkpointSize);
		printf("Flags = ");
		if (status.checkpointCreationAttributes.creationFlags &
			SA_CKPT_WR_ALL_REPLICAS) {
			printf("%s ", "SA_CKPT_WR_ALL_REPLICAS");
		}
		if (status.checkpointCreationAttributes.creationFlags &
			SA_CKPT_WR_ACTIVE_REPLICA) {
			printf("%s ", "SA_CKPT_WR_ACTIVE_REPLICA");
		}
		if (status.checkpointCreationAttributes.creationFlags &
			SA_CKPT_WR_ACTIVE_REPLICA_WEAK) {
			printf("%s ", "SA_CKPT_WR_ACTIVE_REPLICA_WEAK");
		}
		if (status.checkpointCreationAttributes.creationFlags &
			SA_CKPT_CHECKPOINT_COLLOCATED) {
			printf("%s ", "SA_CKPT_CHECKPOINT_COLLOCATED");
		}
		printf("\nMax sections = %d\n",
			(int)status.checkpointCreationAttributes.maxSections);
		printf("Max section size = %d\n",
			(int)status.checkpointCreationAttributes.maxSectionSize);
		printf("Max section ID size = %d\n",
			(int)status.checkpointCreationAttributes.maxSectionIdSize);
		printf("Section count = %d\n", status.numberOfSections);
		printf("\n");
#endif
		goto good;
	}

	attrs.creationFlags = SA_CKPT_WR_ALL_REPLICAS;
	attrs.checkpointSize = (SaSizeT)maxsize;
	attrs.retentionDuration = SA_TIME_ONE_HOUR;
	attrs.maxSections = maxsec;
	attrs.maxSectionSize = (SaSizeT)maxsecsize;
	attrs.maxSectionIdSize = (SaSizeT)32;

	flags = SA_CKPT_CHECKPOINT_READ |
		SA_CKPT_CHECKPOINT_WRITE |
		SA_CKPT_CHECKPOINT_CREATE;

	err = saCkptCheckpointOpen(h->ck_handle,
				   &cpname,
				   &attrs,
				   flags,
				   timeout,
				   &h->ck_checkpoint);
	if (err == SA_AIS_OK)
		goto good;

	/* No checkpoint */
	errno = ais_to_posix(err);
	return (errno == 0 ? 0 : -1);
good:
	printf("Opened ckpt %s\n", ckpt_name);
	h->ck_name = strdup(ckpt_name);

	errno = ais_to_posix(err);
	return (errno == 0 ? 0 : -1);
}
static ClRcT checkpoint_initialize()
{
	SaAisErrorT rc = SA_AIS_OK;
	SaVersionT  ckpt_version = {'B', 1, 1};
	SaNameT     ckpt_name = { strlen(CKPT_NAME), CKPT_NAME };
	SaUint32T   seq_no;
	SaCkptCheckpointCreationAttributesT create_atts = {
		.creationFlags     = SA_CKPT_WR_ACTIVE_REPLICA_WEAK | SA_CKPT_CHECKPOINT_COLLOCATED,
		.checkpointSize    = sizeof(SaUint32T),
		.retentionDuration = (SaTimeT)0, 
		.maxSections       = 2, // default section, plus section we create
		.maxSectionSize    = sizeof(SaSizeT),
		.maxSectionIdSize  = (SaSizeT)64
	};

	SaCkptSectionCreationAttributesT section_atts = {
		.sectionId = &ckpt_sid,
		.expirationTime = SA_TIME_END
	};

	clprintf(CL_LOG_SEV_INFO,"%s: checkpoint_initialize\n", appname);
	/* Initialize checkpointing service instance */
	rc = saCkptInitialize(&ckpt_svc_handle, /* Checkpoint service handle */
			NULL,		    /* Optional callbacks table */
			&ckpt_version);   /* Required verison number */
	if (rc != SA_AIS_OK)
	{
		clprintf(CL_LOG_SEV_ERROR,"%s: ERROR: Failed to initialize checkpoint service\n", appname);
		return rc;
	}
	clprintf(CL_LOG_SEV_INFO,"%s: Checkpoint service initialized (handle=0x%x)\n", appname,(unsigned int) ckpt_svc_handle);

	//
	// Create the checkpoint for read and write.  If we fail to open it
	// then open it without CREATE.  The retry loop is to deal with the
	// possibility that multiple processes might all come along here
	// and fail to open the checkpoint because it hasn't been created
	// yet and then they all try to create the checkpoint.  All but
	// the first would fail.  This retry allows all the rest of the
	// processes to come through and open without CREATE
	// TODO: change it to a straight retry loop where we start off with
	// mode = (CL_CKPT_CHECKPOINT_READ | CL_CKPT_CHECKPOINT_WRITE)
	// and on each iteration of the loop we xor in
	// CL_CKPT_CHECKPOINT_CREATE.  That should let us do the same thing
	// but without the duplication of the clCkptCheckpointOpen call
	rc = saCkptCheckpointOpen(ckpt_svc_handle,      // Service handle
			&ckpt_name,         // Checkpoint name
			&create_atts,       // Optional creation attr.
			(SA_CKPT_CHECKPOINT_READ |
			 SA_CKPT_CHECKPOINT_WRITE |
			 SA_CKPT_CHECKPOINT_CREATE),
			(SaTimeT)-1,        // No timeout
			&ckpt_handle);      // Checkpoint handle
	if (rc != SA_AIS_OK)
	{
		clprintf(CL_LOG_SEV_ERROR,"%s: ERROR: Failed [0x%x] to open checkpoint\n", appname, rc);
		(void)saCkptFinalize(ckpt_svc_handle);
		return rc;
	}
	clprintf(CL_LOG_SEV_INFO,"%s: Checkpoint opened (handle=0x%x)\n", appname, (unsigned int) ckpt_handle);

	/*
	 * Try to create a section so that updates can operate by overwriting
	 * the section over and over again.
	 * If subsequent processes come through here, they will fail to create
	 * the section.  That is OK, even though it will cause an error message
	 * If the section create fails because the section is already there, then
	 * read the sequence number
	 */
	// Put data in network byte order
	seq_no = htonl(seq);

	// Creating the section
	checkpoint_replica_activate();
	rc = saCkptSectionCreate(ckpt_handle,           // Checkpoint handle
			&section_atts,         // Section attributes
			(SaUint8T*)&seq_no,    // Initial data
			(SaSizeT)sizeof(seq_no)); // Size of data
	if (rc != SA_AIS_OK && rc != SA_AIS_ERR_EXIST)
	{
		clprintf(CL_LOG_SEV_ERROR,"%s: ERROR: Failed [0x %x] to create checkpoint section\n", appname, rc);
		(void)saCkptCheckpointClose(ckpt_handle);
		(void)saCkptFinalize(ckpt_svc_handle);
		return rc;
	}
	else if (rc != SA_AIS_OK && rc == SA_AIS_ERR_EXIST)
	{
		rc = checkpoint_read_seq(&seq);
		if (rc != SA_AIS_OK)
		{
			clprintf(CL_LOG_SEV_ERROR,"%s: ERROR: Failed [0x%x] to read checkpoint section\n", appname, rc);
			(void)saCkptCheckpointClose(ckpt_handle);
			(void)saCkptFinalize(ckpt_svc_handle);
			return rc;
		}
	}
	else
	{
		clprintf(CL_LOG_SEV_INFO,"%s: Section created\n", appname);
	}
	/* Open checkpoint for read to write depending on input argument */

	return rc;
}

static SaAisErrorT checkpoint_finalize(void)
{
    SaAisErrorT rc;

    rc = saCkptCheckpointClose(ckpt_handle);
    if (rc != SA_AIS_OK)
    {
        clprintf(CL_LOG_SEV_ERROR,"%s: failed: [0x%x] to close checkpoint handle %d\n", appname, rc, (unsigned int) ckpt_handle);
    }
    rc = saCkptFinalize(ckpt_svc_handle);
    if (rc != SA_AIS_OK)
    {
        clprintf(CL_LOG_SEV_ERROR,"%s: failed: [0x%x] to finalize checkpoint\n", appname, rc);
    }
    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;    
}
Exemple #12
0
int main (void) {
	SaCkptHandleT ckptHandle;
	SaCkptCheckpointHandleT checkpointHandle;
	SaAisErrorT error;
	char data[MAX_DATA_SIZE];
	struct timespec delay;
	struct timespec delay2;
	SaCkptIOVectorElementT writeElement;
	long count = 0;
	SaUint32T erroroneousVectorIndex = 0;

	delay.tv_sec = 1;
	delay.tv_nsec = 0;

	error = saCkptInitialize (&ckptHandle, &callbacks, &version);

	error = saCkptCheckpointOpen (ckptHandle,
			&checkpointName,
			&checkpointCreationAttributes,
			SA_CKPT_CHECKPOINT_CREATE|SA_CKPT_CHECKPOINT_READ|SA_CKPT_CHECKPOINT_WRITE,
			0,
			&checkpointHandle);
	printf ("%s: initial open of checkpoint\n",
		get_test_output (error, SA_AIS_OK));


    do{
			error = saCkptCheckpointRead (checkpointHandle,
				ReadVectorElements,
				1,
				&erroroneousVectorIndex);
			if (error != SA_AIS_OK) {
				if (error == SA_AIS_ERR_TRY_AGAIN) {
					continue;
				}
printf ("error is %d\n", error);
				return (0);
			}

			if (ReadVectorElements->dataBuffer == 0) {
				printf ("Default Checkpoint has no data\n");
			} else {
				count = atol((char *)ReadVectorElements->dataBuffer);
			}

			count++;
			sprintf((char*)&data, "%d",(int)count);
			writeElement.sectionId = (SaCkptSectionIdT)SA_CKPT_DEFAULT_SECTION_ID;
			writeElement.dataBuffer = data;
			writeElement.dataSize = strlen (data) + 1;
			writeElement.dataOffset = 0;
			writeElement.readSize = 0;

			do {
				error = saCkptCheckpointWrite (checkpointHandle,
					&writeElement,
					1,
					&erroroneousVectorIndex);

				printf ("%s: checkpoint write with data %s\n",
							get_test_output (error, SA_AIS_OK), (char*)data);
			}while (error == SA_AIS_ERR_TRY_AGAIN);

			nanosleep(&delay,&delay2);
	}while (1);

	return (0);

}