void
DaemonList::init( daemon_t type, const char* host_list, const char* pool_list )
{
Daemon* tmp;
char* host;
char const *pool = NULL;
StringList foo;
StringList pools;
if( host_list ) {
foo.initializeFromString( host_list );
foo.rewind();
}
if( pool_list ) {
pools.initializeFromString( pool_list );
pools.rewind();
}
while( true ) {
host = foo.next();
pool = pools.next();
if( !host && !pool ) {
break;
}
tmp = buildDaemon( type, host, pool );
append( tmp );
}
}
// 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" );
}
}
void
ReplicatorStateMachine::initializeClassAd()
{
if( m_classAd != NULL) {
delete m_classAd;
m_classAd = NULL;
}
m_classAd = new ClassAd();
SetMyTypeName(*m_classAd, "Replication");
SetTargetTypeName(*m_classAd, "");
m_name.formatstr( "replication@%s -p %d", get_local_fqdn().Value(),
daemonCore->InfoCommandPort( ) );
m_classAd->Assign( ATTR_NAME, m_name.Value( ) );
m_classAd->Assign( ATTR_MY_ADDRESS,
daemonCore->InfoCommandSinfulString( ) );
// publish list of replication nodes
char* buffer = param( "REPLICATION_LIST" );
if ( NULL == buffer ) {
EXCEPT( "ReplicatorStateMachine: No replication list!!" );
}
char* replAddress = NULL;
StringList replList;
MyString attrReplList;
MyString comma;
replList.initializeFromString( buffer );
replList.rewind( );
while( ( replAddress = replList.next() ) ) {
attrReplList += comma;
attrReplList += replAddress;
comma = ",";
}
m_classAd->Assign( ATTR_REPLICATION_LIST, attrReplList.Value( ) );
// publish DC attributes
daemonCore->publish(m_classAd);
free(buffer);
}
// parse a configuration string in the form "ALL:opt, CAT:opt, ALT:opt"
// where opt can be one or more of
// 0-3 verbosity level, 0 is least and 3 is most. default is usually 1
// NONE disable all
// ALL enable all
// R enable Recent (default)
// !R disable Recent
// D enable Debug
// !D disable Debug (default)
// Z don't publish values markerd IF_NONZERO when their value is 0
// !Z ignore IF_NONZERO publishing flag
//
// return value is the PublishFlags that should be passed in to StatisticsPool::Publish
// for this category.
//
int generic_stats_ParseConfigString(
const char * config, // name of the string parameter to read from the config file
const char * pool_name, // name of the stats pool/category of stats to look for
const char * pool_alt, // alternate name of the category to look for
int flags_def) // default value for publish flags for this pool
{
// special case, if there is no string, or the string is just "default", then
// return the default flags
if ( ! config || MATCH == strcasecmp(config,"DEFAULT"))
return flags_def;
// special case, if the string is empty, or the string is just "none", then
// return 0 (disable all)
if ( ! config[0] || MATCH == strcasecmp(config,"NONE"))
return 0;
// tokenize the list on , or space
StringList items;
items.initializeFromString(config);
// if the config string is non-trivial, then it must contain either our pool_name
// or pool_alt or "DEFAULT" or "ALL" or we do not publish this pool.
int PublishFlags = 0;
// walk the list, looking for items that match our pool name or the keyword DEFAULT or ALL
//
items.rewind();
while (const char * p = items.next()) {
int flags = PublishFlags;
const char * psep = strchr(p,':');
if (psep) {
size_t cch = psep - p;
char sz[64];
if (cch >= COUNTOF(sz))
continue;
strncpy(sz, p, cch);
sz[cch] = 0;
if (strcasecmp(sz,pool_name) && strcasecmp(sz,pool_alt) && strcasecmp(sz,"DEFAULT") && strcasecmp(sz,"ALL"))
continue;
} else {
if (strcasecmp(p,pool_name) && strcasecmp(p,pool_alt) && strcasecmp(p,"DEFAULT") && strcasecmp(p,"ALL"))
continue;
}
// if we get to here, we found our pool name or "DEFAULT" or "ALL"
// so we begin with our default flags
flags = flags_def;
// if there are any options, then parse them and modify the flags
if (psep) {
const char * popt = psep+1;
if (MATCH == strcasecmp(popt,"NONE")) {
flags = 0;
} else {
bool bang = false;
const char * parse_error = NULL;
while (popt[0]) {
char ch = popt[0];
if (ch >= '0' && ch <= '3') {
int level = (atoi(popt) * IF_BASICPUB) & IF_PUBLEVEL;
flags = (flags & ~IF_PUBLEVEL) | level;
} else if (ch == '!') {
bang = true;
} else if (ch == 'd' || ch == 'D') {
flags = bang ? (flags & ~IF_DEBUGPUB) : (flags | IF_DEBUGPUB);
} else if (ch == 'r' || ch == 'R') {
flags = bang ? (flags & ~IF_RECENTPUB) : (flags | IF_RECENTPUB);
} else if (ch == 'z' || ch == 'Z') {
flags = bang ? (flags & ~IF_NONZERO) : (flags | IF_NONZERO);
} else if (ch == 'l' || ch == 'L') {
flags = bang ? (flags | IF_NOLIFETIME) : (flags & ~IF_NOLIFETIME);
} else {
if ( ! parse_error) parse_error = popt;
}
++popt;
}
if (parse_error) {
dprintf(D_ALWAYS, "Option '%s' invalid in '%s' when parsing statistics to publish. effect is %08X\n",
parse_error, p, flags);
}
}
}
PublishFlags = flags;
dprintf(D_FULLDEBUG, "'%s' gives flags %08X for %s statistics\n", p, PublishFlags, pool_name);
}
return PublishFlags;
}
void
Init() {
char * tmp = param( "CRED_SUPER_USERS" );
if( tmp ) {
super_users.initializeFromString( tmp );
free( tmp );
} else {
#if defined(WIN32)
super_users.initializeFromString("Administrator");
#else
super_users.initializeFromString("root");
#endif
}
char * spool = param ("SPOOL");
tmp = param ( "CRED_STORE_DIR" );
if ( tmp ) {
cred_store_dir = tmp;
} else {
cred_store_dir = dircat (spool, "cred");
}
if ( spool != NULL ) {
free (spool);
}
tmp = param ( "CRED_INDEX_FILE" );
if (tmp ) {
cred_index_file = tmp;
} else {
cred_index_file = dircat (cred_store_dir, "cred-index");
}
// default 1 hr
default_cred_expire_threshold = param_integer ("DEFAULT_CRED_EXPIRE_THRESHOLD", 3600);
// default 1 minute
CheckCredentials_interval =
param_integer (
"CRED_CHECK_INTERVAL", // param name
DEF_CRED_CHECK_INTERVAL // default value, seconds
);
struct stat stat_buff;
if (stat (cred_store_dir, &stat_buff)) {
dprintf (D_ALWAYS, "ERROR: Cred store directory %s does not exist\n", cred_store_dir);
DC_Exit (1 );
}
if (stat (cred_index_file, &stat_buff)) {
dprintf (D_ALWAYS, "Creating credential index file %s\n", cred_index_file);
priv_state priv = set_root_priv();
int fd = safe_open_wrapper_follow(cred_index_file, O_WRONLY | O_CREAT | O_TRUNC, 0600);
if (fd != -1) {
close (fd);
set_priv (priv);
} else {
dprintf (D_ALWAYS, "ERROR: Unable to create credential index file %s\n", cred_index_file);
set_priv (priv);
DC_Exit (1 );
}
} else {
if ((stat_buff.st_mode & (S_IRWXG | S_IRWXO)) ||
(stat_buff.st_uid != getuid())) {
dprintf (D_ALWAYS, "ERROR: Invalid ownership / permissions on credential index file %s\n",
cred_index_file);
DC_Exit (1 );
}
}
}
// 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( );
}
