void
AbstractReplicatorStateMachine::reinitialize()
{
dprintf( D_ALWAYS, "AbstractReplicatorStateMachine::reinitialize "
"started\n" );
char* buffer = NULL;
buffer = param( "REPLICATION_LIST" );
if ( buffer ) {
initializeReplicationList( buffer );
free( buffer );
} else {
utilCrucialError( utilNoParameterError("REPLICATION_LIST",
"REPLICATION").Value( ) );
}
m_connectionTimeout = param_integer("HAD_CONNECTION_TIMEOUT",
DEFAULT_SEND_COMMAND_TIMEOUT,
0); // min value
buffer = param( "TRANSFERER" );
if (!buffer) {
utilCrucialError(utilConfigurationError("TRANSFERER",
"REPLICATION").Value());
}
m_transfererPath = buffer;
free( buffer );
char* spoolDirectory = param( "SPOOL" );
if( spoolDirectory ) {
m_versionFilePath = spoolDirectory;
m_versionFilePath += "/";
m_versionFilePath += VERSION_FILE_NAME;
buffer = param( "STATE_FILE" );
if ( !buffer ) {
buffer = param( "NEGOTIATOR_STATE_FILE" );
}
if( buffer ) {
m_stateFilePath = buffer;
free( buffer );
} else {
m_stateFilePath = spoolDirectory;
m_stateFilePath += "/";
m_stateFilePath += "Accountantnew.log";
}
free( spoolDirectory );
} else {
utilCrucialError( utilNoParameterError("SPOOL", "REPLICATION").
Value( ) );
}
printDataMembers( );
}
// passing over REPLICATION_LIST configuration parameter, turning all the
// addresses into canonical <ip:port> form and inserting them all, except for
// the address of local replication daemon, into 'm_replicationDaemonsList'.
void
AbstractReplicatorStateMachine::initializeReplicationList( char* buffer )
{
StringList replicationAddressList;
char* replicationAddress = NULL;
bool isMyAddressPresent = false;
Sinful my_addr( daemonCore->InfoCommandSinfulString( ) );
replicationAddressList.initializeFromString( buffer );
// initializing a list unrolls it, that's why the rewind is needed to bring
// it to the beginning
replicationAddressList.rewind( );
/* Passing through the REPLICATION_LIST configuration parameter, stripping
* the optional <> brackets off, and extracting the host name out of
* either ip:port or hostName:port entries
*/
while( (replicationAddress = replicationAddressList.next( )) ) {
char* sinfulAddress = utilToSinful( replicationAddress );
if( sinfulAddress == NULL ) {
char bufArray[BUFSIZ];
sprintf( bufArray,
"AbstractReplicatorStateMachine::initializeReplicationList"
" invalid address %s\n", replicationAddress );
utilCrucialError( bufArray );
continue;
}
if( my_addr.addressPointsToMe( Sinful(sinfulAddress) ) ) {
isMyAddressPresent = true;
}
else {
m_replicationDaemonsList.insert( sinfulAddress );
}
// pay attention to release memory allocated by malloc with free and by
// new with delete here utilToSinful returns memory allocated by malloc
free( sinfulAddress );
}
if( !isMyAddressPresent ) {
utilCrucialError( "ReplicatorStateMachine::initializeReplicationList "
"my address is not present in REPLICATION_LIST" );
}
}
// clears all the inner structures and loads the configuration parameters'
// values again
void
ReplicatorStateMachine::reinitialize()
{
// delete all configurations and start everything over from the scratch
finalize( );
AbstractReplicatorStateMachine::reinitialize( );
m_myVersion.initialize( m_stateFilePath, m_versionFilePath );
m_replicationInterval =
param_integer("REPLICATION_INTERVAL",
5 * MINUTE,
0); // min value, must be positive
// deduce HAD alive tolerance
int hadConnectionTimeout =
param_integer("HAD_CONNECTION_TIMEOUT",
DEFAULT_SEND_COMMAND_TIMEOUT,
0); // min value, must be positive
m_maxTransfererLifeTime =
param_integer("MAX_TRANSFER_LIFETIME",
5 * MINUTE,
0); // min value, must be positive
m_newlyJoinedWaitingVersionInterval =
param_integer("NEWLY_JOINED_WAITING_VERSION_INTERVAL",
NEWLY_JOINED_TOLERANCE_FACTOR * (hadConnectionTimeout + 1),
0); // min value, must be positive
char* buffer = param( "HAD_LIST" );
if ( buffer ) {
StringList hadList;
hadList.initializeFromString( buffer );
free( buffer );
m_hadAliveTolerance = HAD_ALIVE_TOLERANCE_FACTOR *
( 2 * hadConnectionTimeout * hadList.number() + 1 );
dprintf( D_FULLDEBUG, "ReplicatorStateMachine::reinitialize %s=%d\n",
"HAD_LIST", m_hadAliveTolerance );
} else {
utilCrucialError( utilNoParameterError( "HAD_LIST", "HAD" ).Value( ));
}
initializeClassAd();
int updateInterval = param_integer ( "REPLICATION_UPDATE_INTERVAL", 300 );
if ( m_updateInterval != updateInterval ) {
m_updateInterval = updateInterval;
utilCancelTimer(m_updateCollectorTimerId);
m_updateCollectorTimerId = daemonCore->Register_Timer ( 0,
m_updateInterval,
(TimerHandlercpp) &ReplicatorStateMachine::updateCollectors,
"ReplicatorStateMachine::updateCollectors", this );
}
// set a timer to replication routine
dprintf( D_ALWAYS, "ReplicatorStateMachine::reinitialize setting "
"replication timer\n" );
m_replicationTimerId = daemonCore->Register_Timer( m_replicationInterval,
(TimerHandlercpp) &ReplicatorStateMachine::replicationTimer,
"Time to replicate file", this );
// register the download/upload reaper for the transferer process
if( m_downloadReaperId == -1 ) {
m_downloadReaperId = daemonCore->Register_Reaper(
"downloadReplicaTransfererReaper",
(ReaperHandler)&ReplicatorStateMachine::downloadReplicaTransfererReaper,
"downloadReplicaTransfererReaper", this );
}
if( m_uploadReaperId == -1 ) {
m_uploadReaperId = daemonCore->Register_Reaper(
"uploadReplicaTransfererReaper",
(ReaperHandler) &ReplicatorStateMachine::uploadReplicaTransfererReaper,
"uploadReplicaTransfererReaper", this );
}
// for debugging purposes only
printDataMembers( );
beforePassiveStateHandler( );
}
