customdb_samples/customdbsample_extended/linux/perform_update_thread.cpp

/* IBM Source Code */
/* (C) Copyright IBM Corp. 2009, 2012 */
/* Licensed Materials - Property of IBM */
/* US Government Users Restricted Rights - Use duplication or disclosure restricted by GSA Schedule Contract with IBM Corp. */
 
#include "dca/dca_base.h"
 
#include "../mythreads.h"
 
#include <sys/time.h>
#include <fcntl.h>
#include <cerrno>
 
using namespace dca;
 
struct UpdateThreadData
{
        const UpdateModule* pUpdateModule;
        volatile bool shutdown;
        volatile bool *error;
 
        UpdateThreadData()
                : pUpdateModule(NULL)
                , shutdown(false)
                , error(NULL)
        {
        }
};
 
static UpdateThreadData S_updateThreadData;
 
static void* PerformUpdateThreadWorkerFunction( void* pThreadData )
{
        const UpdateThreadData* pUpdateThreadData = (UpdateThreadData*)pThreadData;
 
        try {
                bool error = false;
                while( !error && !pUpdateThreadData->shutdown ) {
                        bool force = false;
                        UpdateResults results;
                        FunctionResult fr = pUpdateThreadData->pUpdateModule->performUpdate(force, results);
                        if( !fr ) {
                                error = true;
                                break;
                        }
 
                        // sleep for 1 minute - avoid busy loop
                        for (size_t k=0; k<60 && !pUpdateThreadData->shutdown; ++k)
                                mySleep( 1000 );
                }
        }
        catch(...) {}
        
        pthread_exit(0);
}
 
static pthread_t  S_hUpdateThread = 0;
 
void createPerformUpdateThread( const UpdateModule& aUpdateModule, volatile bool *errorSignal )
{
        S_updateThreadData.pUpdateModule = &aUpdateModule;
        S_updateThreadData.error = errorSignal;
 
        pthread_create(&S_hUpdateThread , NULL, PerformUpdateThreadWorkerFunction, (void*)&S_updateThreadData);
}
 
void shutdownPerformUpdateThread()
{
        S_updateThreadData.shutdown = true;
        pthread_join(S_hUpdateThread, NULL);
}
 
void mySleep( unsigned nTimeMs )
{
        timespec sleeptime;
        sleeptime.tv_sec = nTimeMs / 1000;
        sleeptime.tv_nsec = 1000*1000*(nTimeMs % 1000);
 
        // nanosleep will fail, if we receive any signal, so we have to loop until it is successful
        timespec remaintime;
        while( nanosleep( &sleeptime, &remaintime ) == -1 )
        {
                int tmp_errno = errno;
                if( tmp_errno != EINTR ) {
                        // nanosleep failed / tmp_errno
                        break;
                }
                // call again with remaining time
                sleeptime.tv_sec = remaintime.tv_sec;
                sleeptime.tv_nsec = remaintime.tv_nsec;
        }
}