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( ); }
// 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( ); }