void
CpuAttributes::compute( amask_t how_much )
{
double val;
if( IS_UPDATE(how_much) && IS_SHARED(how_much) ) {
// Shared attributes that we only get a fraction of
val = map->virt_mem();
if (!IS_AUTO_SHARE(c_virt_mem_fraction)) {
val *= c_virt_mem_fraction;
}
c_virt_mem = (unsigned long)floor( val );
}
if( IS_TIMEOUT(how_much) && !IS_SHARED(how_much) ) {
// Dynamic, non-shared attributes we need to actually compute
c_condor_load = rip->compute_condor_load();
c_total_disk = sysapi_disk_space(rip->executeDir());
if (IS_UPDATE(how_much)) {
dprintf(D_FULLDEBUG, "Total execute space: %lu\n", c_total_disk);
}
val = c_total_disk * c_disk_fraction;
c_disk = (int)floor( val );
if (0 == (int)c_slot_disk)
{
// only use the 1st compute ignore subsequent.
c_slot_disk = c_disk;
}
}
}
void
CpuAttributes::display( amask_t how_much )
{
if( IS_UPDATE(how_much) ) {
dprintf( D_KEYBOARD,
"Idle time: %s %-8d %s %d\n",
"Keyboard:", (int)c_idle,
"Console:", (int)c_console_idle );
dprintf( D_LOAD,
"%s %.2f %s %.2f %s %.2f\n",
"SystemLoad:", c_condor_load + c_owner_load,
"CondorLoad:", c_condor_load,
"OwnerLoad:", c_owner_load );
} else {
if( IsDebugLevel( D_LOAD ) ) {
dprintf( D_FULLDEBUG,
"%s %.2f %s %.2f %s %.2f\n",
"SystemLoad:", c_condor_load + c_owner_load,
"CondorLoad:", c_condor_load,
"OwnerLoad:", c_owner_load );
}
if( IsDebugLevel( D_KEYBOARD ) ) {
dprintf( D_FULLDEBUG,
"Idle time: %s %-8d %s %d\n",
"Keyboard:", (int)c_idle,
"Console:", (int)c_console_idle );
}
}
}
/************************************************************
* int UD_ack() *
*
* Sends an acknowledgement to DBupdate and receives a reply * *
* *
* Return codes: *
* *
* 0 - OK
* -1 -
************************************************************/
int UD_ack(Transaction_t* tr) {
GString *g_buff;
int res, error;
/* if we are not in update/server mode - no ack is needed - just return */
if (IS_STANDALONE(tr->mode))
return (0);
if (!IS_UPDATE(tr->mode))
return (0);
g_buff = g_string_sized_new(STR_L);
if (tr->succeeded == 0) { /* update failed */
error = tr->error;
} else
error = 0;
g_string_sprintf(g_buff, "%%ERROR %d\n%s\n", error, (tr->error_script)->str);
res = SK_puts(tr->socket, g_buff->str, NULL );
g_string_free(g_buff, TRUE);
/* close the connection */
/* Let DBupdate close the connection */
/* close(tr->socket); */
return (res);
}
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
CpuAttributes::publish( ClassAd* cp, amask_t how_much )
{
if( IS_UPDATE(how_much) || IS_PUBLIC(how_much) ) {
cp->Assign( ATTR_VIRTUAL_MEMORY, (int)c_virt_mem );
cp->Assign( ATTR_TOTAL_DISK, (int)c_total_disk );
cp->Assign( ATTR_DISK, (int)c_disk );
}
if( IS_TIMEOUT(how_much) || IS_PUBLIC(how_much) ) {
cp->Assign( ATTR_CONDOR_LOAD_AVG, rint(c_condor_load * 100) / 100.0 );
cp->Assign( ATTR_LOAD_AVG, rint((c_owner_load + c_condor_load) * 100) / 100.0 );
cp->Assign( ATTR_KEYBOARD_IDLE, (int)c_idle );
// ConsoleIdle cannot be determined on all platforms; thus, only
// advertise if it is not -1.
if( c_console_idle != -1 ) {
cp->Assign( ATTR_CONSOLE_IDLE, (int)c_console_idle );
}
}
if( IS_STATIC(how_much) || IS_PUBLIC(how_much) ) {
cp->Assign( ATTR_MEMORY, c_phys_mem );
cp->Assign( ATTR_CPUS, c_num_cpus );
cp->Assign( ATTR_TOTAL_SLOT_MEMORY, c_slot_mem );
cp->Assign( ATTR_TOTAL_SLOT_DISK, (int)c_slot_disk );
cp->Assign( ATTR_TOTAL_SLOT_CPUS, c_num_slot_cpus );
// publish local resource quantities for this slot
for (slotres_map_t::iterator j(c_slotres_map.begin()); j != c_slotres_map.end(); ++j) {
string rname(j->first.c_str());
*(rname.begin()) = toupper(*(rname.begin()));
string attr;
formatstr(attr, "%s%s", "", rname.c_str());
cp->Assign(attr.c_str(), int(j->second));
formatstr(attr, "%s%s", ATTR_TOTAL_SLOT_PREFIX, rname.c_str());
cp->Assign(attr.c_str(), int(c_slottot_map[j->first]));
}
}
}
void
AvailStats::publish( ClassAd* cp, amask_t how_much )
{
char line[100];
if( !compute_avail_stats ) return;
if( IS_UPDATE(how_much) || IS_PUBLIC(how_much) ) {
snprintf( line, 100, "%s=%0.2f", ATTR_AVAIL_TIME, avail_time() );
cp->Insert(line);
cp->Assign( ATTR_LAST_AVAIL_INTERVAL, last_avail_interval() );
if( as_start_avail ) {
// only insert these attributes when in non-owner state
cp->Assign( ATTR_AVAIL_SINCE, (int)avail_since() );
cp->Assign( ATTR_AVAIL_TIME_ESTIMATE, avail_estimate() );
}
}
}
void
MachAttributes::publish( ClassAd* cp, amask_t how_much)
{
if( IS_STATIC(how_much) || IS_PUBLIC(how_much) ) {
// STARTD_IP_ADDR
cp->Assign( ATTR_STARTD_IP_ADDR,
daemonCore->InfoCommandSinfulString() );
cp->Assign( ATTR_ARCH, m_arch );
cp->Assign( ATTR_OPSYS, m_opsys );
if (m_opsysver) {
cp->Assign( ATTR_OPSYSVER, m_opsysver );
}
cp->Assign( ATTR_OPSYS_AND_VER, m_opsys_and_ver );
if (m_opsys_major_ver) {
cp->Assign( ATTR_OPSYS_MAJOR_VER, m_opsys_major_ver );
}
if (m_opsys_name) {
cp->Assign( ATTR_OPSYS_NAME, m_opsys_name );
}
if (m_opsys_long_name) {
cp->Assign( ATTR_OPSYS_LONG_NAME, m_opsys_long_name );
}
if (m_opsys_short_name) {
cp->Assign( ATTR_OPSYS_SHORT_NAME, m_opsys_short_name );
}
if (m_opsys_legacy) {
cp->Assign( ATTR_OPSYS_LEGACY, m_opsys_legacy );
}
cp->Assign( ATTR_UID_DOMAIN, m_uid_domain );
cp->Assign( ATTR_FILE_SYSTEM_DOMAIN, m_filesystem_domain );
cp->Assign( ATTR_HAS_IO_PROXY, true );
cp->Assign( ATTR_CHECKPOINT_PLATFORM, m_ckptpltfrm );
#if defined ( WIN32 )
// publish the Windows version information
if ( m_got_windows_version_info ) {
cp->Assign( ATTR_WINDOWS_MAJOR_VERSION,
(int)m_window_version_info.dwMajorVersion );
cp->Assign( ATTR_WINDOWS_MINOR_VERSION,
(int)m_window_version_info.dwMinorVersion );
cp->Assign( ATTR_WINDOWS_BUILD_NUMBER,
(int)m_window_version_info.dwBuildNumber );
// publish the extended Windows version information if we
// have it at our disposal
if ( sizeof ( OSVERSIONINFOEX ) ==
m_window_version_info.dwOSVersionInfoSize ) {
cp->Assign( ATTR_WINDOWS_SERVICE_PACK_MAJOR,
(int)m_window_version_info.wServicePackMajor );
cp->Assign( ATTR_WINDOWS_SERVICE_PACK_MINOR,
(int)m_window_version_info.wServicePackMinor );
cp->Assign( ATTR_WINDOWS_PRODUCT_TYPE,
(int)m_window_version_info.wProductType );
}
}
/*
Publish .Net versions installed on current machine assuming
the option is turned on..
*/
if(param_boolean("STARTD_PUBLISH_DOTNET", true))
{
if(m_dot_Net_Versions)
cp->Assign(ATTR_DOTNET_VERSIONS, m_dot_Net_Versions);
}
// publish values from the window's registry as specified
// in the STARTD_PUBLISH_WINREG param.
//
m_lst_static.Rewind();
while (AttribValue *pav = m_lst_static.Next()) {
if (pav) pav->AssignToClassAd(cp);
}
/*
char * pubreg_param = param("STARTD_PUBLISH_WINREG");
if (pubreg_param) {
StringList reg_list(pubreg_param, ";");
reg_list.rewind();
while(char * reg_item = reg_list.next()) {
// if the reg_item is of the form attr_name=reg_path;
// then skip over the attr_name and '=' and trailing
// whitespace. But if the = is after the first \, then
// it's a part of the reg_path, so ignore it.
//
const char * pkey = strchr(reg_item, '=');
const char * pbs = strchr(reg_item, '\\');
if (pkey && ( ! pbs || pkey < pbs)) {
++pkey; // skip the '='
} else {
pkey = reg_item;
}
// skip any leading whitespace in the reg_path
while (isspace(pkey[0]))
++pkey;
// if the keyname begins with 32 or 64, use that to designate either
// the WOW64 or WOW32 view of the registry, but don't pass the
// leading number on to the lower level code.
int options = 0;
if (isdigit(pkey[0])) {
options = atoi(pkey);
while (isdigit(pkey[0])) {
++pkey;
}
}
// get the registry value of the given key, and assign it
// to the given attribute name, or a generated name.
//
char * value = get_windows_reg_value(pkey, NULL, options);
if (value) {
char * attr_name = generate_reg_key_attr_name("WINREG_", reg_item);
if (attr_name) {
cp->Assign(attr_name, value);
free (attr_name);
}
free(value);
}
}
free (pubreg_param);
}
*/
#endif // defined ( WIN32 )
}
if( IS_UPDATE(how_much) || IS_PUBLIC(how_much) ) {
cp->Assign( ATTR_TOTAL_VIRTUAL_MEMORY, (int)m_virt_mem );
cp->Assign( ATTR_TOTAL_CPUS, m_num_cpus );
cp->Assign( ATTR_TOTAL_MEMORY, m_phys_mem );
// KFLOPS and MIPS are only conditionally computed; thus, only
// advertise them if we computed them.
if ( m_kflops > 0 ) {
cp->Assign( ATTR_KFLOPS, m_kflops );
}
if ( m_mips > 0 ) {
cp->Assign( ATTR_MIPS, m_mips );
}
#if defined(WIN32)
if ( m_local_credd != NULL ) {
cp->Assign(ATTR_LOCAL_CREDD, m_local_credd);
}
#endif
string machine_resources = "cpus memory disk swap";
// publish any local resources
for (slotres_map_t::iterator j(m_machres_map.begin()); j != m_machres_map.end(); ++j) {
string rname(j->first.c_str());
*(rname.begin()) = toupper(*(rname.begin()));
string attr;
formatstr(attr, "%s%s", ATTR_DETECTED_PREFIX, rname.c_str());
cp->Assign(attr.c_str(), int(j->second));
formatstr(attr, "%s%s", ATTR_TOTAL_PREFIX, rname.c_str());
cp->Assign(attr.c_str(), int(j->second));
machine_resources += " ";
machine_resources += j->first;
}
cp->Assign(ATTR_MACHINE_RESOURCES, machine_resources.c_str());
}
// We don't want this inserted into the public ad automatically
if( IS_UPDATE(how_much) || IS_TIMEOUT(how_much) ) {
cp->Assign( ATTR_LAST_BENCHMARK, (unsigned)m_last_benchmark );
}
if( IS_TIMEOUT(how_much) || IS_PUBLIC(how_much) ) {
cp->Assign( ATTR_TOTAL_LOAD_AVG, rint(m_load * 100) / 100.0);
cp->Assign( ATTR_TOTAL_CONDOR_LOAD_AVG,
rint(m_condor_load * 100) / 100.0);
cp->Assign( ATTR_CLOCK_MIN, m_clock_min );
cp->Assign( ATTR_CLOCK_DAY, m_clock_day );
m_lst_dynamic.Rewind();
while (AttribValue *pav = m_lst_dynamic.Next() ) {
if (pav) pav->AssignToClassAd(cp);
}
}
// temporary attributes for raw utsname info
cp->Assign( ATTR_UTSNAME_SYSNAME, m_utsname_sysname );
cp->Assign( ATTR_UTSNAME_NODENAME, m_utsname_nodename );
cp->Assign( ATTR_UTSNAME_RELEASE, m_utsname_release );
cp->Assign( ATTR_UTSNAME_VERSION, m_utsname_version );
cp->Assign( ATTR_UTSNAME_MACHINE, m_utsname_machine );
// Advertise chroot information
if ( m_named_chroot.size() > 0 ) {
cp->Assign( "NamedChroot", m_named_chroot.c_str() );
}
}
void
MachAttributes::compute( amask_t how_much )
{
// the startd doesn't normally call the init() method (bug?),
// it just starts calling compute, so in order to gurantee that
// init happens, we put check here to see if user settings have been initialized
if ( ! m_user_settings_init)
init_user_settings();
if( IS_STATIC(how_much) && IS_SHARED(how_much) ) {
// Since we need real values for them as soon as a
// MachAttributes object is instantiated, we handle number
// of CPUs and physical memory in the constructor, not
// here. -Derek Wright 2/5/99
// Arch, OpSys, FileSystemDomain and UidDomain. Note:
// these will always return something, since config() will
// insert values if we don't have them in the config file.
if( m_arch ) {
free( m_arch );
}
m_arch = param( "ARCH" );
if( m_opsys ) {
free( m_opsys );
}
m_opsys = param( "OPSYS" );
m_opsysver = param_integer( "OPSYSVER", 0 );
if( m_opsys_and_ver ) {
free( m_opsys_and_ver );
}
m_opsys_and_ver = param( "OPSYSANDVER" );
m_opsys_major_ver = param_integer( "OPSYSMAJORVER", 0 );
if( m_opsys_name ) {
free( m_opsys_name );
}
m_opsys_name = param( "OPSYSNAME" );
if( m_opsys_long_name ) {
free( m_opsys_long_name );
}
m_opsys_long_name = param( "OPSYSLONGNAME" );
if( m_opsys_short_name ) {
free( m_opsys_short_name );
}
m_opsys_short_name = param( "OPSYSSHORTNAME" );
if( m_opsys_legacy ) {
free( m_opsys_legacy );
}
m_opsys_legacy = param( "OPSYSLEGACY" );
// temporary attributes for raw utsname info
if( m_utsname_sysname ) {
free( m_utsname_sysname );
}
if( m_utsname_nodename ) {
free( m_utsname_nodename );
}
if( m_utsname_release ) {
free( m_utsname_release );
}
if( m_utsname_version ) {
free( m_utsname_version );
}
if( m_utsname_machine ) {
free( m_utsname_machine );
}
m_utsname_sysname = param( "UTSNAME_SYSNAME" );
m_utsname_nodename = param( "UTSNAME_NODENAME" );
m_utsname_release = param( "UTSNAME_RELEASE" );
m_utsname_version = param( "UTSNAME_VERSION" );
m_utsname_machine = param( "UTSNAME_MACHINE" );
if( m_uid_domain ) {
free( m_uid_domain );
}
m_uid_domain = param( "UID_DOMAIN" );
dprintf( D_FULLDEBUG, "%s = \"%s\"\n", ATTR_UID_DOMAIN,
m_uid_domain );
if( m_filesystem_domain ) {
free( m_filesystem_domain );
}
m_filesystem_domain = param( "FILESYSTEM_DOMAIN" );
dprintf( D_FULLDEBUG, "%s = \"%s\"\n", ATTR_FILE_SYSTEM_DOMAIN,
m_filesystem_domain );
m_idle_interval = param_integer( "IDLE_INTERVAL", -1 );
// checkpoint platform signature
if (m_ckptpltfrm) {
free(m_ckptpltfrm);
}
const char * ckptpltfrm = param( ATTR_CHECKPOINT_PLATFORM );
if( ckptpltfrm == NULL ) {
ckptpltfrm = sysapi_ckptpltfrm();
}
m_ckptpltfrm = strdup( ckptpltfrm );
pair_strings_vector root_dirs = root_dir_list();
std::stringstream result;
unsigned int chroot_count = 0;
for (pair_strings_vector::const_iterator it=root_dirs.begin();
it != root_dirs.end();
++it, ++chroot_count) {
if (chroot_count) {
result << ", ";
}
result << it->first;
}
if (chroot_count > 1) {
std::string result_str = result.str();
dprintf(D_FULLDEBUG, "Named chroots: %s\n", result_str.c_str() );
m_named_chroot = result_str;
}
}
if( IS_UPDATE(how_much) && IS_SHARED(how_much) ) {
m_virt_mem = sysapi_swap_space();
dprintf( D_FULLDEBUG, "Swap space: %lu\n", m_virt_mem );
#if defined(WIN32)
credd_test();
#endif
}
if( IS_TIMEOUT(how_much) && IS_SHARED(how_much) ) {
m_load = sysapi_load_avg();
sysapi_idle_time( &m_idle, &m_console_idle );
time_t my_timer;
struct tm *the_time;
time( &my_timer );
the_time = localtime(&my_timer);
m_clock_min = (the_time->tm_hour * 60) + the_time->tm_min;
m_clock_day = the_time->tm_wday;
if (m_last_keypress < my_timer - m_idle) {
if (m_idle_interval >= 0) {
int duration = my_timer - m_last_keypress;
if (duration > m_idle_interval) {
if (m_seen_keypress) {
dprintf(D_IDLE, "end idle interval of %d sec.\n",
duration);
} else {
dprintf(D_IDLE,
"first keyboard event %d sec. after startup\n",
duration);
}
}
}
m_last_keypress = my_timer;
m_seen_keypress = true;
}
#ifdef WIN32
update_all_WinPerf_results();
#endif
AttribValue *pav = NULL;
m_lst_dynamic.Rewind();
while ((pav = m_lst_dynamic.Next()) ) {
if (pav) {
#ifdef WIN32
if ( ! update_WinPerf_Value(pav))
pav->vtype = AttribValue_DataType_Max; // undefined vtype
#else
if (pav->pquery) {
// insert code to update pav from pav->pquery
}
#endif
}
}
}
if( IS_TIMEOUT(how_much) && IS_SUMMED(how_much) ) {
m_condor_load = resmgr->sum( &Resource::condor_load );
if( m_condor_load > m_load ) {
m_condor_load = m_load;
}
}
}