void
JobInfoCommunicator::startUpdateTimer( void )
{
if( m_periodic_job_update_tid >= 0 ) {
// already registered the timer...
return;
}
Timeslice interval;
// default interval is 5 minutes, with 8 seconds as the initial value.
interval.setDefaultInterval( param_integer( "STARTER_UPDATE_INTERVAL", 300, 0 ) );
interval.setTimeslice( param_double( "STARTER_UPDATE_INTERVAL_TIMESLICE", 0.1, 0, 1 ) );
interval.setInitialInterval( param_integer( "STARTER_INITIAL_UPDATE_INTERVAL", 8 ) );
if( interval.getDefaultInterval() < interval.getInitialInterval() ) {
interval.setInitialInterval( interval.getDefaultInterval() );
}
m_periodic_job_update_tid = daemonCore->
Register_Timer(interval,
(TimerHandlercpp)&JobInfoCommunicator::periodicJobUpdateTimerHandler,
"JobInfoCommunicator::periodicJobUpdateTimerHandler", this);
if( m_periodic_job_update_tid < 0 ) {
EXCEPT( "Can't register DC Timer!" );
}
}
void
AvailStats::compute( amask_t how_much )
{
if( !compute_avail_stats ) return;
if( IS_STATIC(how_much) && IS_SHARED(how_much) ) {
as_avail_confidence = param_double("STARTD_AVAIL_CONFIDENCE", as_avail_confidence, 0, 1);
as_max_avail_periods = param_integer("STARTD_MAX_AVAIL_PERIOD_SAMPLES", as_max_avail_periods);
}
if( IS_UPDATE(how_much) && IS_SHARED(how_much) ) {
time_t current_time = time(0);
// only compute avail time estimate if we're in non-owner state
if( as_start_avail ) {
// first, skip over intervals less than our idle time so far
int current_idle_time = current_time - as_start_avail;
int num_intervals = as_num_avail_periods;
as_avail_periods.Rewind();
int item = 0;
as_avail_periods.Next(item);
while( num_intervals && item < current_idle_time ) {
as_avail_periods.Next(item);
num_intervals--;
}
if( !num_intervals ) {
// If this is the longest we've ever been idle, our
// historical data isn't too useful to us, so give an
// estimate based on how long we've been idle so far.
as_avail_estimate =
(int)floor(current_idle_time*(2.0-as_avail_confidence));
} else {
// Otherwise, find the record in our history at the
// requested confidence level.
int idx = (int)floor(num_intervals*(1.0-as_avail_confidence));
while( idx ) {
as_avail_periods.Next(item);
idx--;
}
as_avail_estimate = item;
}
as_avail_time =
float(as_tot_avail_time + current_idle_time) /
float(current_time - as_birthdate);
} else {
as_avail_time = float(as_tot_avail_time) /
float(current_time - as_birthdate);
}
}
}
void BaseShadow::config()
{
reconnect_ceiling = param_integer( "RECONNECT_BACKOFF_CEILING", 300 );
reconnect_e_factor = 0.0;
reconnect_e_factor = param_double( "RECONNECT_BACKOFF_FACTOR", 2.0, 0.0 );
if( reconnect_e_factor < -1e-4 || reconnect_e_factor > 1e-4) {
reconnect_e_factor = 2.0;
}
m_cleanup_retry_tid = -1;
m_num_cleanup_retries = 0;
// NOTE: these config knobs are very similar to
// LOCAL_UNIVERSE_MAX_JOB_CLEANUP_RETRIES and
// LOCAL_UNIVERSE_JOB_CLEANUP_RETRY_DELAY in the local starter.
m_max_cleanup_retries = param_integer("SHADOW_MAX_JOB_CLEANUP_RETRIES", 5);
m_cleanup_retry_delay = param_integer("SHADOW_JOB_CLEANUP_RETRY_DELAY", 30);
m_lazy_queue_update = param_boolean("SHADOW_LAZY_QUEUE_UPDATE", true);
}
void BaseShadow::config()
{
if (spool) free(spool);
spool = param("SPOOL");
if (!spool) {
EXCEPT("SPOOL not specified in config file.");
}
if (fsDomain) free(fsDomain);
fsDomain = param( "FILESYSTEM_DOMAIN" );
if (!fsDomain) {
EXCEPT("FILESYSTEM_DOMAIN not specified in config file.");
}
if (uidDomain) free(uidDomain);
uidDomain = param( "UID_DOMAIN" );
if (!uidDomain) {
EXCEPT("UID_DOMAIN not specified in config file.");
}
reconnect_ceiling = param_integer( "RECONNECT_BACKOFF_CEILING", 300 );
reconnect_e_factor = 0.0;
reconnect_e_factor = param_double( "RECONNECT_BACKOFF_FACTOR", 2.0, 0.0 );
if( reconnect_e_factor < -1e-4 || reconnect_e_factor > 1e-4) {
reconnect_e_factor = 2.0;
}
m_cleanup_retry_tid = -1;
m_num_cleanup_retries = 0;
// NOTE: these config knobs are very similar to
// LOCAL_UNIVERSE_MAX_JOB_CLEANUP_RETRIES and
// LOCAL_UNIVERSE_JOB_CLEANUP_RETRY_DELAY in the local starter.
m_max_cleanup_retries = param_integer("SHADOW_MAX_JOB_CLEANUP_RETRIES", 5);
m_cleanup_retry_delay = param_integer("SHADOW_JOB_CLEANUP_RETRY_DELAY", 30);
m_lazy_queue_update = param_boolean("SHADOW_LAZY_QUEUE_UPDATE", true);
}
void Defrag::config()
{
ASSERT( param(m_state_file,"DEFRAG_STATE_FILE") );
if( m_last_poll==0 ) {
loadState();
}
int old_polling_interval = m_polling_interval;
m_polling_interval = param_integer("DEFRAG_INTERVAL",600);
if( m_polling_interval <= 0 ) {
dprintf(D_ALWAYS,
"DEFRAG_INTERVAL=%d, so no pool defragmentation "
"will be done.\n", m_polling_interval);
if( m_polling_timer != -1 ) {
daemonCore->Cancel_Timer(m_polling_timer);
m_polling_timer = -1;
}
}
else if( m_polling_timer >= 0 ) {
if( old_polling_interval != m_polling_interval ) {
daemonCore->Reset_Timer_Period(
m_polling_timer,
m_polling_interval);
}
}
else {
time_t now = time(NULL);
int first_time = 0;
if( m_last_poll != 0 && now-m_last_poll < m_polling_interval && m_last_poll <= now ) {
first_time = m_polling_interval - (now-m_last_poll);
}
m_polling_timer = daemonCore->Register_Timer(
first_time,
m_polling_interval,
(TimerHandlercpp)&Defrag::poll,
"Defrag::poll",
this );
}
if( old_polling_interval != m_polling_interval && m_polling_interval > 0 )
{
dprintf(D_ALWAYS,
"Will evaluate defragmentation policy every DEFRAG_INTERVAL="
"%d seconds.\n", m_polling_interval);
}
m_draining_per_hour = param_double("DEFRAG_DRAINING_MACHINES_PER_HOUR",0,0);
double rate = m_draining_per_hour/3600.0*m_polling_interval;
m_draining_per_poll = (int)floor(rate + 0.00001);
if( m_draining_per_poll < 0 ) m_draining_per_poll = 0;
double error_per_hour = (rate - m_draining_per_poll)/m_polling_interval*3600.0;
m_draining_per_poll_hour = (int)floor(error_per_hour + 0.00001);
if( m_draining_per_hour < 0 || m_polling_interval > 3600 ) {
m_draining_per_hour = 0;
}
double error_per_day = (error_per_hour - m_draining_per_poll_hour)*24.0;
m_draining_per_poll_day = (int)floor(error_per_day + 0.5);
if( m_draining_per_poll_day < 0 || m_polling_interval > 3600*24 ) {
m_draining_per_poll_day = 0;
}
dprintf(D_ALWAYS,"polling interval %ds, DEFRAG_DRAINING_MACHINES_PER_HOUR = %f/hour = %d/interval + %d/hour + %d/day\n",
m_polling_interval,m_draining_per_hour,m_draining_per_poll,
m_draining_per_poll_hour,m_draining_per_poll_day);
m_max_draining = param_integer("DEFRAG_MAX_CONCURRENT_DRAINING",-1,-1);
m_max_whole_machines = param_integer("DEFRAG_MAX_WHOLE_MACHINES",-1,-1);
ASSERT( param(m_defrag_requirements,"DEFRAG_REQUIREMENTS") );
validateExpr( m_defrag_requirements.c_str(), "DEFRAG_REQUIREMENTS" );
ASSERT( param(m_whole_machine_expr,"DEFRAG_WHOLE_MACHINE_EXPR") );
validateExpr( m_whole_machine_expr.c_str(), "DEFRAG_WHOLE_MACHINE_EXPR" );
ASSERT( param(m_draining_schedule_str,"DEFRAG_DRAINING_SCHEDULE") );
if( m_draining_schedule_str.empty() ) {
m_draining_schedule = DRAIN_GRACEFUL;
m_draining_schedule_str = "graceful";
}
else {
m_draining_schedule = getDrainingScheduleNum(m_draining_schedule_str.c_str());
if( m_draining_schedule < 0 ) {
EXCEPT("Invalid draining schedule: %s\n",m_draining_schedule_str.c_str());
}
}
MyString rank;
param(rank,"DEFRAG_RANK");
if( rank.IsEmpty() ) {
m_rank_ad.Delete(ATTR_RANK);
}
else {
if( !m_rank_ad.AssignExpr(ATTR_RANK,rank.Value()) ) {
EXCEPT("Invalid expression for DEFRAG_RANK: %s\n",
rank.Value());
}
}
int update_interval = param_integer("DEFRAG_UPDATE_INTERVAL", 600);
if(m_public_ad_update_interval != update_interval) {
m_public_ad_update_interval = update_interval;
dprintf(D_FULLDEBUG, "Setting update interval to %d\n",
m_public_ad_update_interval);
if(m_public_ad_update_timer >= 0) {
daemonCore->Reset_Timer_Period(
m_public_ad_update_timer,
m_public_ad_update_interval);
}
else {
m_public_ad_update_timer = daemonCore->Register_Timer(
0,
m_public_ad_update_interval,
(TimerHandlercpp)&Defrag::updateCollector,
"Defrag::updateCollector",
this);
}
}
if (param(m_cancel_requirements, "DEFRAG_CANCEL_REQUIREMENTS")) {
validateExpr( m_cancel_requirements.c_str(), "DEFRAG_CANCEL_REQUIREMENTS" );
} else {
m_cancel_requirements = "";
}
param(m_defrag_name,"DEFRAG_NAME");
int stats_quantum = m_polling_interval;
int stats_window = 10*stats_quantum;
m_stats.SetWindowSize(stats_window,stats_quantum);
}
void
init_params()
{
char *tmp;
static int master_name_in_config = 0;
if( ! master_name_in_config ) {
// First time, or we know it's not in the config file.
if( ! MasterName ) {
// Not set on command line
tmp = param( "MASTER_NAME" );
if( tmp ) {
MasterName = build_valid_daemon_name( tmp );
master_name_in_config = 1;
free( tmp );
}
}
} else {
delete [] MasterName;
tmp = param( "MASTER_NAME" );
MasterName = build_valid_daemon_name( tmp );
free( tmp );
}
if( MasterName ) {
dprintf( D_FULLDEBUG, "Using name: %s\n", MasterName );
}
if (!param_boolean_crufty("START_MASTER", true)) {
dprintf( D_ALWAYS, "START_MASTER was set to FALSE, shutting down.\n" );
StartDaemons = FALSE;
main_shutdown_graceful();
}
StartDaemons = TRUE;
if (!param_boolean_crufty("START_DAEMONS", true)) {
dprintf( D_ALWAYS,
"START_DAEMONS flag was set to FALSE. Not starting daemons.\n" );
StartDaemons = FALSE;
}
// If we were sent the daemons_off command, don't forget that
// here.
if( GotDaemonsOff ) {
StartDaemons = FALSE;
}
PublishObituaries = param_boolean_crufty("PUBLISH_OBITUARIES", true) ? TRUE : FALSE;
Lines = param_integer("OBITUARY_LOG_LENGTH",20);
master_backoff_constant = param_integer( "MASTER_BACKOFF_CONSTANT", 9, 1 );
master_backoff_ceiling = param_integer( "MASTER_BACKOFF_CEILING", 3600,1 );
master_backoff_factor = param_double( "MASTER_BACKOFF_FACTOR", 2.0, 0 );
if( master_backoff_factor <= 0.0 ) {
master_backoff_factor = 2.0;
}
master_recover_time = param_integer( "MASTER_RECOVER_FACTOR", 300, 1 );
update_interval = param_integer( "MASTER_UPDATE_INTERVAL", 5 * MINUTE, 1 );
check_new_exec_interval = param_integer( "MASTER_CHECK_NEW_EXEC_INTERVAL", 5*MINUTE );
new_bin_delay = param_integer( "MASTER_NEW_BINARY_DELAY", 2*MINUTE, 1 );
new_bin_restart_mode = GRACEFUL;
char * restart_mode = param("MASTER_NEW_BINARY_RESTART");
if (restart_mode) {
#if 1
StopStateT mode = StringToStopState(restart_mode);
#else
static const struct {
const char * text;
StopStateT mode;
} modes[] = {
{ "GRACEFUL", GRACEFUL },
{ "PEACEFUL", PEACEFUL },
{ "NEVER", NONE }, { "NONE", NONE }, { "NO", NONE },
// { "FAST", FAST },
// { "KILL", KILL },
};
StopStateT mode = (StopStateT)-1; // prime with -1 so we can detect bad input.
for (int ii = 0; ii < (int)COUNTOF(modes); ++ii) {
if (MATCH == strcasecmp(restart_mode, modes[ii].text)) {
mode = modes[ii].mode;
break;
}
}
#endif
if (mode == (StopStateT)-1) {
dprintf(D_ALWAYS, "%s is not a valid value for MASTER_NEW_BINARY_RESTART. using GRACEFUL\n", restart_mode);
}
if (mode >= 0 && mode <= NONE)
new_bin_restart_mode = mode;
free(restart_mode);
}
preen_interval = param_integer( "PREEN_INTERVAL", 24*HOUR, 0 );
if(preen_interval == 0) {
EXCEPT("PREEN_INTERVAL in the condor configuration is too low (0). Please set it to an integer in the range 1 to %d (default %d). To disable condor_preen entirely, comment out PREEN.", INT_MAX, 24*HOUR);
}
shutdown_fast_timeout = param_integer( "SHUTDOWN_FAST_TIMEOUT", 5*MINUTE, 1 );
shutdown_graceful_timeout = param_integer( "SHUTDOWN_GRACEFUL_TIMEOUT", 30*MINUTE, 1 );
AllowAdminCommands = param_boolean( "ALLOW_ADMIN_COMMANDS", true );
if( FS_Preen ) {
free( FS_Preen );
}
FS_Preen = param( "PREEN" );
}
void
CCBServer::InitAndReconfig()
{
// construct the CCB address to be advertised by CCB listeners
Sinful sinful(daemonCore->publicNetworkIpAddr());
// strip out <>'s, private address, and CCB listener info
sinful.setPrivateAddr(NULL);
sinful.setCCBContact(NULL);
ASSERT( sinful.getSinful() && sinful.getSinful()[0] == '<' );
m_address.formatstr("%s",sinful.getSinful()+1);
if( m_address[m_address.Length()-1] == '>' ) {
m_address.setChar(m_address.Length()-1,'\0');
}
m_read_buffer_size = param_integer("CCB_SERVER_READ_BUFFER",2*1024);
m_write_buffer_size = param_integer("CCB_SERVER_WRITE_BUFFER",2*1024);
m_last_reconnect_info_sweep = time(NULL);
m_reconnect_info_sweep_interval = param_integer("CCB_SWEEP_INTERVAL",1200);
CloseReconnectFile();
MyString old_reconnect_fname = m_reconnect_fname;
char *fname = param("CCB_RECONNECT_FILE");
if( fname ) {
m_reconnect_fname = fname;
if( m_reconnect_fname.find(".ccb_reconnect") == -1 ) {
// required for preen to ignore this file
m_reconnect_fname += ".ccb_reconnect";
}
free( fname );
}
else {
char *spool = param("SPOOL");
ASSERT( spool );
Sinful my_addr( daemonCore->publicNetworkIpAddr() );
m_reconnect_fname.formatstr("%s%c%s-%s.ccb_reconnect",
spool,
DIR_DELIM_CHAR,
my_addr.getHost() ? my_addr.getHost() : "localhost",
my_addr.getPort() ? my_addr.getPort() : "0");
free( spool );
}
if( old_reconnect_fname != m_reconnect_fname &&
!old_reconnect_fname.IsEmpty() &&
!m_reconnect_fname.IsEmpty() )
{
// reconnect filename changed
// not worth freaking out on error here
remove( m_reconnect_fname.Value() );
rename( old_reconnect_fname.Value(), m_reconnect_fname.Value() );
}
if( old_reconnect_fname.IsEmpty() &&
!m_reconnect_fname.IsEmpty() &&
m_reconnect_info.getNumElements() == 0 )
{
// we are starting up from scratch, so load saved info
LoadReconnectInfo();
}
Timeslice poll_slice;
poll_slice.setTimeslice( // do not run more than this fraction of the time
param_double("CCB_POLLING_TIMESLICE",0.05) );
poll_slice.setDefaultInterval( // try to run this often
param_integer("CCB_POLLING_INTERVAL",20,0) );
poll_slice.setMaxInterval( // run at least this often
param_integer("CCB_POLLING_MAX_INTERVAL",600) );
if( m_polling_timer != -1 ) {
daemonCore->Cancel_Timer(m_polling_timer);
}
m_polling_timer = daemonCore->Register_Timer(
poll_slice,
(TimerHandlercpp)&CCBServer::PollSockets,
"CCBServer::PollSockets",
this);
RegisterHandlers();
}
/*
* Beginning-of-function code:
*
* 'sp' is an array of indices in symtab for the arguments
* 'cnt' is the number of arguments
*/
void
bfcode(struct symtab **sp, int cnt)
{
union arglist *usym;
int saveallargs = 0;
int i, argofs = 0;
/*
* Detect if this function has ellipses and save all
* argument registers onto stack.
*/
usym = cftnsp->sdf->dfun;
while (usym && usym->type != TNULL) {
if (usym->type == TELLIPSIS) {
saveallargs = 1;
break;
}
++usym;
}
/* if returning a structure, move the hidden argument into a TEMP */
if (cftnsp->stype == STRTY+FTN || cftnsp->stype == UNIONTY+FTN) {
param_retstruct();
++argofs;
}
/* recalculate the arg offset and create TEMP moves */
for (i = 0; i < cnt; i++) {
if (sp[i] == NULL)
continue;
if ((argofs >= NARGREGS) && !xtemps)
break;
if (argofs > NARGREGS) {
putintemp(sp[i]);
} else if (sp[i]->stype == STRTY || sp[i]->stype == UNIONTY) {
param_struct(sp[i], &argofs);
} else if (DEUNSIGN(sp[i]->stype) == LONGLONG) {
param_64bit(sp[i], &argofs, xtemps && !saveallargs);
} else if (sp[i]->stype == DOUBLE || sp[i]->stype == LDOUBLE) {
if (features(FEATURE_HARDFLOAT))
param_double(sp[i], &argofs,
xtemps && !saveallargs);
else
param_64bit(sp[i], &argofs,
xtemps && !saveallargs);
} else if (sp[i]->stype == FLOAT) {
if (features(FEATURE_HARDFLOAT))
param_float(sp[i], &argofs,
xtemps && !saveallargs);
else
param_32bit(sp[i], &argofs,
xtemps && !saveallargs);
} else {
param_32bit(sp[i], &argofs, xtemps && !saveallargs);
}
}
/* if saveallargs, save the rest of the args onto the stack */
while (saveallargs && argofs < NARGREGS) {
NODE *p, *q;
int off = ARGINIT/SZINT + argofs;
q = block(REG, NIL, NIL, INT, 0, 0);
regno(q) = R0 + argofs++;
p = block(REG, NIL, NIL, INT, 0, 0);
regno(p) = FPREG;
p = block(PLUS, p, bcon(4*off), INT, 0, 0);
p = block(UMUL, p, NIL, INT, 0, 0);
p = buildtree(ASSIGN, p, q);
ecomp(p);
}
}
/*
* code for the beginning of a function; a is an array of
* indices in symtab for the arguments; n is the number
*/
void
bfcode(struct symtab **sp, int cnt)
{
union arglist *usym;
int lastreg = A0 + nargregs - 1;
int saveallargs = 0;
int i, reg;
/*
* Detect if this function has ellipses and save all
* argument register onto stack.
*/
usym = cftnsp->sdf->dfun;
while (usym && usym->type != TNULL) {
if (usym->type == TELLIPSIS) {
saveallargs = 1;
break;
}
++usym;
}
reg = A0;
/* assign hidden return structure to temporary */
if (cftnsp->stype == STRTY+FTN || cftnsp->stype == UNIONTY+FTN) {
param_retptr();
++reg;
}
/* recalculate the arg offset and create TEMP moves */
for (i = 0; i < cnt; i++) {
if ((reg > lastreg) && !xtemps)
break;
else if (reg > lastreg)
putintemp(sp[i]);
else if (sp[i]->stype == STRTY || sp[i]->stype == UNIONTY)
param_struct(sp[i], ®);
else if (DEUNSIGN(sp[i]->stype) == LONGLONG)
param_64bit(sp[i], ®, xtemps && !saveallargs);
else if (sp[i]->stype == DOUBLE || sp[i]->stype == LDOUBLE)
param_double(sp[i], ®, xtemps && !saveallargs);
else if (sp[i]->stype == FLOAT)
param_float(sp[i], ®, xtemps && !saveallargs);
else
param_32bit(sp[i], ®, xtemps && !saveallargs);
}
/* if saveallargs, save the rest of the args onto the stack */
if (!saveallargs)
return;
while (reg <= lastreg) {
NODE *p, *q;
int off = ARGINIT/SZINT + (reg - A0);
q = block(REG, NIL, NIL, INT, 0, 0);
q->n_rval = reg++;
p = block(REG, NIL, NIL, INT, 0, 0);
p->n_rval = FP;
p = block(PLUS, p, bcon(4*off), INT, 0, 0);
p = block(UMUL, p, NIL, INT, 0, 0);
p = buildtree(ASSIGN, p, q);
ecomp(p);
}
}
