void
check_execute_dir_perms( StringList &list )
{
char const *exec_path;
list.rewind();
while( (exec_path = list.next()) ) {
check_execute_dir_perms( exec_path );
}
}
void
main_init( int, char* argv[] )
{
char** ptr;
// Reset the cron & benchmark managers to a known state
cron_job_mgr = NULL;
bench_job_mgr = NULL;
// Process command line args.
for(ptr = argv + 1; *ptr; ptr++) {
if(ptr[0][0] != '-') {
usage( argv[0] );
}
switch( ptr[0][1] ) {
case 's':
break;
case 'n':
ptr++;
if( !(ptr && *ptr) ) {
EXCEPT( "-n requires another arugment" );
}
if (Name) {
free(Name);
}
Name = build_valid_daemon_name( *ptr );
dprintf( D_ALWAYS, "Using name: %s\n", Name );
break;
default:
fprintf( stderr, "Error: Unknown option %s\n", *ptr );
usage( argv[0] );
}
}
// Record the time we started up for use in determining
// keyboard idle time on SMP machines, etc.
startd_startup = time( 0 );
// Instantiate the Resource Manager object.
resmgr = new ResMgr;
// find all the starters we care about and get their classads.
resmgr->starter_mgr.init();
ClassAd tmp_classad;
MyString starter_ability_list;
resmgr->starter_mgr.publish(&tmp_classad, A_STATIC | A_PUBLIC);
tmp_classad.LookupString(ATTR_STARTER_ABILITY_LIST, starter_ability_list);
if( starter_ability_list.find(ATTR_HAS_VM) >= 0 ) {
// Now starter has codes for vm universe.
resmgr->m_vmuniverse_mgr.setStarterAbility(true);
// check whether vm universe is available through vmgahp server
resmgr->m_vmuniverse_mgr.checkVMUniverse();
}
// Read in global parameters from the config file.
// We do this after we instantiate the resmgr, so we can know
// what num_cpus is, but before init_resources(), so we can
// use polling_interval to figure out how big to make each
// Resource's LoadQueue object.
init_params(1); // The 1 indicates that this is the first time
#if defined(WIN32)
// We do this on Win32 since Win32 uses last_x_event
// variable in a similar fasion to the X11 condor_kbdd, and
// thus it must be initialized.
command_x_event( 0, 0, 0 );
#endif
// Instantiate Resource objects in the ResMgr
resmgr->init_resources();
// Do a little sanity checking and cleanup
StringList execute_dirs;
resmgr->FillExecuteDirsList( &execute_dirs );
check_execute_dir_perms( execute_dirs );
cleanup_execute_dirs( execute_dirs );
// Compute all attributes
resmgr->compute( A_ALL );
resmgr->walk( &Resource::init_classad );
// Startup Cron
cron_job_mgr = new StartdCronJobMgr( );
cron_job_mgr->Initialize( "startd" );
// Startup benchmarking
bench_job_mgr = new StartdBenchJobMgr( );
bench_job_mgr->Initialize( "benchmarks" );
// Now that we have our classads, we can compute things that
// need to be evaluated
resmgr->walk( &Resource::compute, A_EVALUATED );
resmgr->walk( &Resource::refresh_classad, A_PUBLIC | A_EVALUATED );
// Now that everything is computed and published, we can
// finally put in the attrs shared across the different slots
resmgr->walk( &Resource::refresh_classad, A_PUBLIC | A_SHARED_SLOT );
// If we EXCEPT, don't leave any starters lying around.
_EXCEPT_Cleanup = do_cleanup;
// register daemoncore stuff
//////////////////////////////////////////////////
// Commands
//////////////////////////////////////////////////
// These commands all read the ClaimId off the wire, find
// the resource with that ClaimId, and call appropriate
// action on that resource. Plus, all of these commands only
// make sense when we're in the claimed state. So, we can
// handle them all with a common handler. For all of them,
// you need WRITE permission.
daemonCore->Register_Command( ALIVE, "ALIVE",
(CommandHandler)command_handler,
"command_handler", 0, DAEMON,
D_FULLDEBUG );
daemonCore->Register_Command( DEACTIVATE_CLAIM,
"DEACTIVATE_CLAIM",
(CommandHandler)command_handler,
"command_handler", 0, DAEMON );
daemonCore->Register_Command( DEACTIVATE_CLAIM_FORCIBLY,
"DEACTIVATE_CLAIM_FORCIBLY",
(CommandHandler)command_handler,
"command_handler", 0, DAEMON );
daemonCore->Register_Command( PCKPT_FRGN_JOB, "PCKPT_FRGN_JOB",
(CommandHandler)command_handler,
"command_handler", 0, DAEMON );
daemonCore->Register_Command( REQ_NEW_PROC, "REQ_NEW_PROC",
(CommandHandler)command_handler,
"command_handler", 0, DAEMON );
if (param_boolean("ALLOW_SLOT_PAIRING", false)) {
daemonCore->Register_Command( SWAP_CLAIM_AND_ACTIVATION, "SWAP_CLAIM_AND_ACTIVATION",
(CommandHandler)command_with_opts_handler,
"command_handler", 0, DAEMON );
}
// These commands are special and need their own handlers
// READ permission commands
daemonCore->Register_Command( GIVE_STATE,
"GIVE_STATE",
(CommandHandler)command_give_state,
"command_give_state", 0, READ );
daemonCore->Register_Command( GIVE_TOTALS_CLASSAD,
"GIVE_TOTALS_CLASSAD",
(CommandHandler)command_give_totals_classad,
"command_give_totals_classad", 0, READ );
daemonCore->Register_Command( QUERY_STARTD_ADS, "QUERY_STARTD_ADS",
(CommandHandler)command_query_ads,
"command_query_ads", 0, READ );
// DAEMON permission commands
daemonCore->Register_Command( ACTIVATE_CLAIM, "ACTIVATE_CLAIM",
(CommandHandler)command_activate_claim,
"command_activate_claim", 0, DAEMON );
daemonCore->Register_Command( REQUEST_CLAIM, "REQUEST_CLAIM",
(CommandHandler)command_request_claim,
"command_request_claim", 0, DAEMON );
daemonCore->Register_Command( RELEASE_CLAIM, "RELEASE_CLAIM",
(CommandHandler)command_release_claim,
"command_release_claim", 0, DAEMON );
daemonCore->Register_Command( SUSPEND_CLAIM, "SUSPEND_CLAIM",
(CommandHandler)command_suspend_claim,
"command_suspend_claim", 0, DAEMON );
daemonCore->Register_Command( CONTINUE_CLAIM, "CONTINUE_CLAIM",
(CommandHandler)command_continue_claim,
"command_continue_claim", 0, DAEMON );
daemonCore->Register_Command( X_EVENT_NOTIFICATION,
"X_EVENT_NOTIFICATION",
(CommandHandler)command_x_event,
"command_x_event", 0, ALLOW,
D_FULLDEBUG );
daemonCore->Register_Command( PCKPT_ALL_JOBS, "PCKPT_ALL_JOBS",
(CommandHandler)command_pckpt_all,
"command_pckpt_all", 0, DAEMON );
daemonCore->Register_Command( PCKPT_JOB, "PCKPT_JOB",
(CommandHandler)command_name_handler,
"command_name_handler", 0, DAEMON );
#if !defined(WIN32)
daemonCore->Register_Command( DELEGATE_GSI_CRED_STARTD, "DELEGATE_GSI_CRED_STARTD",
(CommandHandler)command_delegate_gsi_cred,
"command_delegate_gsi_cred", 0, DAEMON );
#endif
// OWNER permission commands
daemonCore->Register_Command( VACATE_ALL_CLAIMS,
"VACATE_ALL_CLAIMS",
(CommandHandler)command_vacate_all,
"command_vacate_all", 0, OWNER );
daemonCore->Register_Command( VACATE_ALL_FAST,
"VACATE_ALL_FAST",
(CommandHandler)command_vacate_all,
"command_vacate_all", 0, OWNER );
daemonCore->Register_Command( VACATE_CLAIM,
"VACATE_CLAIM",
(CommandHandler)command_name_handler,
"command_name_handler", 0, OWNER );
daemonCore->Register_Command( VACATE_CLAIM_FAST,
"VACATE_CLAIM_FAST",
(CommandHandler)command_name_handler,
"command_name_handler", 0, OWNER );
// NEGOTIATOR permission commands
daemonCore->Register_Command( MATCH_INFO, "MATCH_INFO",
(CommandHandler)command_match_info,
"command_match_info", 0, NEGOTIATOR );
// the ClassAd-only command
daemonCore->Register_Command( CA_AUTH_CMD, "CA_AUTH_CMD",
(CommandHandler)command_classad_handler,
"command_classad_handler", 0, WRITE );
daemonCore->Register_Command( CA_CMD, "CA_CMD",
(CommandHandler)command_classad_handler,
"command_classad_handler", 0, WRITE );
// Virtual Machine commands
if( vmapi_is_host_machine() == TRUE ) {
daemonCore->Register_Command( VM_REGISTER,
"VM_REGISTER",
(CommandHandler)command_vm_register,
"command_vm_register", 0, DAEMON,
D_FULLDEBUG );
}
// Commands from starter for VM universe
daemonCore->Register_Command( VM_UNIV_GAHP_ERROR,
"VM_UNIV_GAHP_ERROR",
(CommandHandler)command_vm_universe,
"command_vm_universe", 0, DAEMON,
D_FULLDEBUG );
daemonCore->Register_Command( VM_UNIV_VMPID,
"VM_UNIV_VMPID",
(CommandHandler)command_vm_universe,
"command_vm_universe", 0, DAEMON,
D_FULLDEBUG );
daemonCore->Register_Command( VM_UNIV_GUEST_IP,
"VM_UNIV_GUEST_IP",
(CommandHandler)command_vm_universe,
"command_vm_universe", 0, DAEMON,
D_FULLDEBUG );
daemonCore->Register_Command( VM_UNIV_GUEST_MAC,
"VM_UNIV_GUEST_MAC",
(CommandHandler)command_vm_universe,
"command_vm_universe", 0, DAEMON,
D_FULLDEBUG );
daemonCore->Register_CommandWithPayload( DRAIN_JOBS,
"DRAIN_JOBS",
(CommandHandler)command_drain_jobs,
"command_drain_jobs", 0, ADMINISTRATOR);
daemonCore->Register_CommandWithPayload( CANCEL_DRAIN_JOBS,
"CANCEL_DRAIN_JOBS",
(CommandHandler)command_cancel_drain_jobs,
"command_cancel_drain_jobs", 0, ADMINISTRATOR);
//////////////////////////////////////////////////
// Reapers
//////////////////////////////////////////////////
main_reaper = daemonCore->Register_Reaper( "reaper_starters",
(ReaperHandler)reaper, "reaper" );
ASSERT(main_reaper != FALSE);
daemonCore->Set_Default_Reaper( main_reaper );
#if defined(WIN32)
// Pretend we just got an X event so we think our console idle
// is something, even if we haven't heard from the kbdd yet.
// We do this on Win32 since Win32 uses last_x_event
// variable in a similar fasion to the X11 condor_kbdd, and
// thus it must be initialized.
command_x_event( 0, 0, 0 );
#endif
resmgr->start_update_timer();
#if HAVE_HIBERNATION
resmgr->updateHibernateConfiguration();
#endif /* HAVE_HIBERNATION */
// Evaluate the state of all resources and update CM
// We don't just call eval_and_update_all() b/c we don't need
// to recompute anything.
// This is now called by a timer registered by start_update_timer()
//resmgr->update_all();
#if defined(WANT_CONTRIB) && defined(WITH_MANAGEMENT)
#if defined(HAVE_DLOPEN)
StartdPluginManager::Load();
#elif defined(WIN32)
load_startd_mgmt();
#endif
StartdPluginManager::Initialize();
#endif
}