void
invalidate_ads() {
ClassAd cmd_ad;
SetMyTypeName( cmd_ad, QUERY_ADTYPE );
SetTargetTypeName( cmd_ad, MASTER_ADTYPE );
MyString line;
std::string escaped_name;
char* default_name = ::strnewp(MasterName);
if(!default_name) {
default_name = default_daemon_name();
}
EscapeAdStringValue( default_name, escaped_name );
line.formatstr( "( TARGET.%s == \"%s\" )", ATTR_NAME, escaped_name.c_str() );
cmd_ad.AssignExpr( ATTR_REQUIREMENTS, line.Value() );
cmd_ad.Assign( ATTR_NAME, default_name );
cmd_ad.Assign( ATTR_MY_ADDRESS, daemonCore->publicNetworkIpAddr());
daemonCore->sendUpdates( INVALIDATE_MASTER_ADS, &cmd_ad, NULL, false );
delete [] default_name;
}
void
init_classad()
{
if( ad ) delete( ad );
ad = new ClassAd();
SetMyTypeName(*ad, MASTER_ADTYPE);
SetTargetTypeName(*ad, "");
if (MasterName) {
ad->Assign(ATTR_NAME, MasterName);
} else {
char* default_name = default_daemon_name();
if( ! default_name ) {
EXCEPT( "default_daemon_name() returned NULL" );
}
ad->Assign(ATTR_NAME, default_name);
delete [] default_name;
}
#if !defined(WIN32)
ad->Assign(ATTR_REAL_UID, (int)getuid());
#endif
}
void
JobQueueDBManager::config(bool reconfig)
{
char *tmp;
MyString sql_str;
int bndcnt = 0;
const char *data_arr[3];
QuillAttrDataType data_typ[3];
if (param_boolean("QUILL_ENABLED", false) == false) {
EXCEPT("Quill++ is currently disabled. Please set QUILL_ENABLED to "
"TRUE if you want this functionality and read the manual "
"about this feature since it requires other attributes to be "
"set properly.");
}
//bail out if no SPOOL variable is defined since its used to
//figure out the location of the job_queue.log file
char *spool = param("SPOOL");
if(!spool) {
EXCEPT("No SPOOL variable found in config file\n");
}
jobQueueLogFile = (char *) malloc(_POSIX_PATH_MAX * sizeof(char));
snprintf(jobQueueLogFile,_POSIX_PATH_MAX * sizeof(char),
"%s/job_queue.log", spool);
/*
Here we try to read the database parameters in config
the db ip address format is <ipaddress:port>
*/
dt = getConfigDBType();
jobQueueDBIpAddress = param("QUILL_DB_IP_ADDR");
jobQueueDBName = param("QUILL_DB_NAME");
jobQueueDBUser = param("QUILL_DB_USER");
jobQueueDBConn = getDBConnStr(jobQueueDBIpAddress,
jobQueueDBName,
jobQueueDBUser,
spool);
dprintf(D_ALWAYS, "Using Job Queue File %s\n", jobQueueLogFile);
dprintf(D_ALWAYS, "Using Database Type = Postgres\n");
dprintf(D_ALWAYS, "Using Database IpAddress = %s\n",
jobQueueDBIpAddress?jobQueueDBIpAddress:"");
dprintf(D_ALWAYS, "Using Database Name = %s\n",
jobQueueDBName?jobQueueDBName:"");
dprintf(D_ALWAYS, "Using Database User = %s\n",
jobQueueDBUser?jobQueueDBUser:"");
if(spool) {
free(spool);
spool = NULL;
}
// this function is also called when condor_reconfig is issued
// and so we dont want to recreate all essential objects
if(!reconfig) {
prober = new ClassAdLogProber();
caLogParser = new ClassAdLogParser();
switch (dt) {
case T_PGSQL:
DBObj = new PGSQLDatabase(jobQueueDBConn);
break;
default:
break;;
}
xactState = NOT_IN_XACT;
QuillErrCode ret_st;
ret_st = DBObj->connectDB();
if (ret_st == QUILL_FAILURE) {
displayErrorMsg("config: unable to connect to DB--- ERROR");
EXCEPT("config: unable to connect to DB\n");
}
/* the following will also throw an exception if the schema
version is not correct */
DBObj->assertSchemaVersion();
tmp = param( "SCHEDD_NAME" );
if( tmp ) {
scheddname = build_valid_daemon_name( tmp );
dprintf(D_FULLDEBUG, "scheddname %s built from param value %s\n",
scheddname, tmp);
free(tmp);
} else {
scheddname = default_daemon_name();
dprintf(D_FULLDEBUG, "scheddname built from default daemon name: %s\n", scheddname);
}
{
/* create an entry in jobqueuepollinginfo if this schedd is the
* first time being logged to database
*/
sql_str.formatstr("INSERT INTO jobqueuepollinginfo (scheddname, last_file_mtime, last_file_size) SELECT '%s', 0, 0 FROM dummy_single_row_table WHERE NOT EXISTS (SELECT * FROM jobqueuepollinginfo WHERE scheddname = '%s')", scheddname, scheddname);
ret_st = DBObj->execCommand(sql_str.Value());
if (ret_st == QUILL_FAILURE) {
dprintf(D_ALWAYS, "Insert JobQueuePollInfo --- ERROR [SQL] %s\n",
sql_str.Value());
}
}
{
/* create an entry in currency table if this schedd is the first
* time being logged to database
*/
sql_str.formatstr("INSERT INTO currencies (datasource) SELECT '%s' FROM dummy_single_row_table WHERE NOT EXISTS (SELECT * FROM currencies WHERE datasource = '%s')", scheddname, scheddname);
ret_st = DBObj->execCommand(sql_str.Value());
if (ret_st == QUILL_FAILURE) {
dprintf(D_ALWAYS, "Insert Currency --- ERROR [SQL] %s\n", sql_str.Value());
}
}
ret_st = DBObj->commitTransaction();
if (ret_st == QUILL_FAILURE) {
dprintf(D_ALWAYS, "Commit transaction failed in JobQueueDBManager::config\n");
}
if (param_boolean("QUILL_MAINTAIN_DB_CONN", true) == false) {
ret_st = DBObj->disconnectDB();
if (ret_st == QUILL_FAILURE) {
dprintf(D_ALWAYS, "JobQueueDBManager:config: unable to disconnect database --- ERROR\n");
}
}
}
//this function assumes that certain members have been initialized
// (specifically prober and caLogParser) and so the order is important.
setJobQueueFileName(jobQueueLogFile);
}
void
DBMSManager::config() {
char *name = param("DBMSMANAGER_NAME");
if(name) {
char *valid_name = build_valid_daemon_name(name);
m_name = valid_name;
free(name);
delete [] valid_name;
}
else {
char *default_name = default_daemon_name();
if(default_name) {
m_name = default_name;
delete [] default_name;
}
}
InitPublicAd();
int update_interval = param_integer("UPDATE_INTERVAL", 60);
if(m_public_ad_update_interval != update_interval) {
m_public_ad_update_interval = update_interval;
if(m_public_ad_update_timer >= 0) {
daemonCore->Cancel_Timer(m_public_ad_update_timer);
m_public_ad_update_timer = -1;
}
dprintf(D_FULLDEBUG, "Setting update interval to %d\n",
m_public_ad_update_interval);
m_public_ad_update_timer = daemonCore->Register_Timer(
0,
m_public_ad_update_interval,
(TimerHandlercpp)&DBMSManager::TimerHandler_UpdateCollector,
"DBMSManager::TimerHandler_UpdateCollector",
this);
}
/* register the database purging callback */
int purge_interval = param_integer("DATABASE_PURGE_INTERVAL", 86400); // 24 hours
if(m_database_purge_interval != purge_interval) {
m_database_purge_interval = purge_interval;
if(m_database_purge_timer >= 0) {
daemonCore->Cancel_Timer(m_database_purge_timer);
m_database_purge_timer = -1;
}
dprintf(D_FULLDEBUG, "Setting database purge interval to %d\n",
m_database_purge_interval);
m_database_purge_timer = daemonCore->Register_Timer(
0,
m_database_purge_interval,
(TimerHandlercpp)&DBMSManager::TimerHandler_PurgeDatabase,
"DBMSManager::TimerHandler_PurgeDatabase",
this);
}
/* register the database reindexing callback */
int reindex_interval = param_integer("DATABASE_REINDEX_INTERVAL", 86400); // 24 hours
if(m_database_reindex_interval != reindex_interval) {
m_database_reindex_interval = reindex_interval;
if(m_database_reindex_timer >= 0) {
daemonCore->Cancel_Timer(m_database_reindex_timer);
m_database_reindex_timer = -1;
}
dprintf(D_FULLDEBUG, "Setting database reindex interval to %d\n",
m_database_reindex_interval);
m_database_reindex_timer = daemonCore->Register_Timer(
0,
m_database_reindex_interval,
(TimerHandlercpp)&DBMSManager::TimerHandler_ReindexDatabase,
"DBMSManager::TimerHandler_ReindexDatabase",
this);
}
}