void
CVarDataFile::MarkSlotDeleted(UInt32 inSlotPos, RecIDT inRecID) {
RecIDT recID = 0; // use 0 as deleted slot marker
#if DB_DEBUG_MODE || DB_INTEGRITY_CHECKING
ASSERT(mBytesUsed <= mAllocatedBytes); // can't use more than we've allocated
ASSERT((mAllocatedBytes+mFirstItemPos) == GetLength()); // LFileStream needs to be in synch
if (GetLength() < (SInt32)inSlotPos) {
DB_LOG("ERROR: Delete Rec " << inRecID << " pos: "<<inSlotPos <<" FAILED, overran datafile length "<<GetLength()<<"B");
DB_DEBUG("ERROR: Trying to delete-mark slot at offset "<<inSlotPos<<", but datafile is only "<<GetLength()<<" bytes long.", DEBUG_ERROR);
Throw_( dbIndexCorrupt );
}
SetMarker(inSlotPos + kVarDBFileRecIDOffset, streamFrom_Start); // debugging, check old ID
ReadBlock(&recID, kSizeOfRecID);
#if PLATFORM_LITTLE_ENDIAN
recID = BigEndian32_ToNative(recID);
#endif // PLATFORM_LITTLE_ENDIAN
DB_DEBUG("MarkSlotDeleted(); deleted_id: " << recID, DEBUG_TRIVIA);
if (recID != inRecID) {
DB_LOG("ERROR: Delete Rec " << inRecID << " pos: "<<inSlotPos << " FAILED, slot has Record "<<recID);
DB_DEBUG("ERROR: Tried to delete Record ID " << inRecID << " but record " <<recID
<<" found in slot at "<<inSlotPos, DEBUG_ERROR);
Throw_( dbIndexCorrupt );
}
if (recID == 0) {
DB_LOG("WARNING: Delete Rec " << inRecID << " pos: "<<inSlotPos << " previously deleted");
DB_DEBUG("NON-CRITICAL ERROR: Deleting a slot with a zero (deleted) ID", DEBUG_ERROR);
}
recID = 0;
#endif
// writing zero, don't worry about endian swap
SetMarker(inSlotPos + kVarDBFileRecIDOffset, streamFrom_Start); // move to position of recID in slot
WriteBlock(&recID, kSizeOfRecID); // write the deletion maker
DB_LOG("Deleted Rec " << inRecID << " pos: "<<inSlotPos);
DB_DEBUG("MarkSlotDeleted(); pos: " << inSlotPos, DEBUG_TRIVIA);
}
ADataStore::ADataStore() { // ** NOT THREAD SAFE **
itsDefaultComparator = (LComparator*)nil;
mBatchMode = false;
mLastRecID = 0;
mFileOpen = false;
itsStream = (LStream*)nil;
SetDefaultComparator(new CRecIDComparator); // use a ID comparator as initial default
#if DB_THREAD_SUPPORT
if (UEnvironment::HasFeature(env_HasThreadsManager)) {
mChangeID = new LMutexSemaphore();
mAccessHeader = new LMutexSemaphore();
mAccessData = new LMutexSemaphore();
mChangeInfo = new LMutexSemaphore();
ThrowIfNil_(mChangeID);
ThrowIfNil_(mAccessHeader);
ThrowIfNil_(mAccessData);
ThrowIfNil_(mChangeInfo);
} else {
mChangeID = (LMutexSemaphore*)nil;
mAccessHeader = (LMutexSemaphore*)nil;
mAccessData = (LMutexSemaphore*)nil;
mChangeInfo = (LMutexSemaphore*)nil;
}
#endif
DB_DEBUG("Contructed v1.0 Datastore", DEBUG_TRIVIA);
}
static int _remove_clusters_from_fed(mysql_conn_t *mysql_conn, List clusters)
{
int rc = SLURM_SUCCESS;
char *query = NULL;
char *name = NULL;
char *names = NULL;
ListIterator itr = NULL;
xassert(clusters);
itr = list_iterator_create(clusters);
while ((name = list_next(itr)))
xstrfmtcat(names, "%s'%s'", names ? "," : "", name );
xstrfmtcat(query, "UPDATE %s "
"SET federation='', fed_id=0, fed_state=%u "
"WHERE name IN (%s) and deleted=0",
cluster_table, CLUSTER_FED_STATE_NA, names);
if (debug_flags & DEBUG_FLAG_FEDR)
DB_DEBUG(mysql_conn->conn, "query\n%s", query);
rc = mysql_db_query(mysql_conn, query);
xfree(query);
if (rc)
error("Failed to remove clusters %s from federation", names);
xfree(names);
return rc;
}
ADataStore::ADataStore(SInt16 inStrcResID) { // ** NOT THREAD SAFE **
ASSERT(inStrcResID >= 128); // Strc ids 0..127 are reserved for internal use
itsDefaultComparator = (LComparator*)nil;
mBatchMode = false;
mLastRecID = 0;
mFileOpen = false;
mOwnsComparator = false;
itsStream = (LStream*)nil;
SetDefaultComparator(new CRecIDComparator, true); // use a ID comparator as initial default
mStrcResID = inStrcResID;
mStructure = (UStructure*)nil;
#if DB_THREAD_SUPPORT
if (UEnvironment::HasFeature(env_HasThreadsManager)) {
mChangeID = new LMutexSemaphore();
mAccessHeader = new LMutexSemaphore();
mAccessData = new LMutexSemaphore();
mChangeInfo = new LMutexSemaphore();
ThrowIfNil_(mChangeID);
ThrowIfNil_(mAccessHeader);
ThrowIfNil_(mAccessData);
ThrowIfNil_(mChangeInfo);
} else {
mChangeID = (LMutexSemaphore*)nil;
mAccessHeader = (LMutexSemaphore*)nil;
mAccessData = (LMutexSemaphore*)nil;
mChangeInfo = (LMutexSemaphore*)nil;
}
#endif
DB_DEBUG("Contructed v1.5 Datastore: struct id " << inStrcResID, DEBUG_TRIVIA);
}
UInt32
CVarDataFile::AddNewEmptySlot(SInt32 inSize) {
if (inSize > mLargestRecSize) {
DB_DEBUG("New largest rec is "<<inSize<<" bytes. Previously "<<mLargestRecSize, DEBUG_TRIVIA);
mLargestRecSize = inSize; // keep track of largest record
}
mItemCount++;
mAllocatedSlots = mItemCount + 1L; // update #slots
UInt32 oldBytesUsed = mBytesUsed;
mBytesUsed += inSize;
if (mBytesUsed >= mAllocatedBytes) {
if (!mBatchMode) {
mAllocatedBytes = mBytesUsed + kAllocationBlockSize;
} else {
mAllocatedBytes = mBytesUsed + kAllocationBlockSize*8L; // big blocks for batches
}
ASSERT(mAllocatedBytes > mBytesUsed);
ASSERT(mAllocatedBytes >= (SInt32)(mItemCount*RecSizeToSlotSize(sizeof(DatabaseRec)))); // must have at least a header
UInt32 fileSize = mFirstItemPos + mAllocatedBytes;
// fill the newly allocated stuff with FFFF
UInt32 eraseStart = mFirstItemPos + oldBytesUsed;
ASSERT(eraseStart < fileSize);
UInt32 eraseLen = fileSize - eraseStart;
void* p = std::malloc(eraseLen);
SetLength(fileSize); // expand file
if (p) {
std::memset(p, 0xff, eraseLen);
SetMarker(eraseStart, streamFrom_Start);
WriteBlock(p, eraseLen); // fill the unused part of the data file
} else {
DB_DEBUG("Failed to malloc "<<eraseLen<<" bytes for new space erasure in data file", DEBUG_ERROR);
}
if (!mBatchMode) {
WriteHeader(); // write new # slots, etc.. in disk file header
}
}
UInt32 recPos = oldBytesUsed + mFirstItemPos;
SetMarker(recPos + kVarDBFileSlotSizeOffset, streamFrom_Start); // write the slot size in the slot
inSize = Native_ToBigEndian32(inSize);
WriteBlock(&inSize, kSizeOfSlotSize);
inSize = BigEndian32_ToNative(inSize); // restore endianness
RecIDT tempID = 0; // debugging, make sure the ID is cleared from new slots
WriteBlock(&tempID, sizeof(RecIDT));
DB_LOG("Add New Slot size: " << inSize << "B pos: "<<recPos <<" slots: " << mAllocatedSlots);
DB_DEBUG("AddNewEmptySlot(); size: "<<inSize<<" pos: "<<recPos<<" slots: "<<mAllocatedSlots, DEBUG_TRIVIA);
return recPos;
}
extern int as_mysql_register_ctld(mysql_conn_t *mysql_conn,
char *cluster, uint16_t port)
{
char *query = NULL;
char *address = NULL;
char hostname[255];
time_t now = time(NULL);
uint32_t flags = slurmdb_setup_cluster_flags();
int rc = SLURM_SUCCESS;
if (slurmdbd_conf)
fatal("clusteracct_storage_g_register_ctld "
"should never be called from the slurmdbd.");
if (check_connection(mysql_conn) != SLURM_SUCCESS)
return ESLURM_DB_CONNECTION;
if (!mysql_conn->cluster_name) {
error("%s:%d no cluster name", THIS_FILE, __LINE__);
return SLURM_ERROR;
}
if (!mysql_conn->cluster_name)
mysql_conn->cluster_name = xstrdup(cluster);
info("Registering slurmctld for cluster %s at port %u in database.",
cluster, port);
gethostname(hostname, sizeof(hostname));
/* check if we are running on the backup controller */
if (slurmctld_conf.backup_controller
&& !strcmp(slurmctld_conf.backup_controller, hostname)) {
address = slurmctld_conf.backup_addr;
} else
address = slurmctld_conf.control_addr;
query = xstrdup_printf(
"update %s set deleted=0, mod_time=%ld, "
"control_host='%s', control_port=%u, last_port=%u, "
"rpc_version=%d, dimensions=%d, flags=%u, "
"plugin_id_select=%d where name='%s';",
cluster_table, now, address, port, port, SLURM_PROTOCOL_VERSION,
SYSTEM_DIMENSIONS, flags, select_get_plugin_id(), cluster);
xstrfmtcat(query,
"insert into %s "
"(timestamp, action, name, actor, info) "
"values (%ld, %d, '%s', '%s', '%s %u %u %u %u');",
txn_table,
now, DBD_MODIFY_CLUSTERS, cluster,
slurmctld_conf.slurm_user_name, address, port,
SYSTEM_DIMENSIONS, flags, select_get_plugin_id());
if (debug_flags & DEBUG_FLAG_DB_ASSOC)
DB_DEBUG(mysql_conn->conn, "query\n%s", query);
rc = mysql_db_query(mysql_conn, query);
xfree(query);
return rc;
}
// updates an existing record with the data in the CRecord object
// use CRecord* ReadRecord(id) to read in the data, then modify it and call this func to update it
void //** Thread Safe **
ADataStore::UpdateRecord(CRecord* inRecP) {
ASSERT(inRecP != nil); // еее pass by reference
DB_DEBUG("UpdateRecord("<<inRecP->GetRecordID()<<")");
AutoLockRecord lock(inRecP); // automatically unlock the record as we exit this code block
DatabaseRec* p = inRecP->GetRecordDataPtr();
UpdateRecord(p);
}
RecIDT //** Thread Safe **
ADataStore::FindRecord(CRecord* inRecP, LComparator *) { //inComparator
ASSERT(inRecP != nil);
RecIDT resultID = kInvalidRecID;
int ignore; //*** ADataStore::FindRecord() NOT YET IMPLEMENTED ***
//*** not sure how I want to implement this yet
DB_DEBUG("FindRecord(): "<< resultID);
return resultID;
}
static int _add_clusters_to_fed(mysql_conn_t *mysql_conn, List clusters,
const char *fed)
{
int rc = SLURM_SUCCESS;
char *query = NULL;
char *name = NULL;
char *names = NULL;
char *indexes = NULL;
ListIterator itr = NULL;
int last_id = -1;
xassert(fed);
xassert(clusters);
itr = list_iterator_create(clusters);
while ((name = list_next(itr))) {
int id;
if ((rc = as_mysql_get_fed_cluster_id(mysql_conn, name, fed,
last_id, &id)))
goto end_it;
last_id = id;
xstrfmtcat(indexes, "WHEN name='%s' THEN %d ", name, id);
xstrfmtcat(names, "%s'%s'", names ? "," : "", name);
}
/* Keep the same fed_state if the cluster isn't changing feds.
* Also note that mysql evaluates from left to right and uses the
* updated column values in case statements. So the check for federation
* in the fed_state case statement must happen before fed_state is set
* or the federation will always equal the federation in the case
* statement. */
xstrfmtcat(query, "UPDATE %s "
"SET "
"fed_state = CASE WHEN federation='%s' THEN fed_state ELSE %u END, "
"fed_id = CASE %s END, "
"federation='%s' "
"WHERE name IN (%s) and deleted=0",
cluster_table, fed, CLUSTER_FED_STATE_ACTIVE, indexes, fed,
names);
if (debug_flags & DEBUG_FLAG_FEDR)
DB_DEBUG(mysql_conn->conn, "query\n%s", query);
rc = mysql_db_query(mysql_conn, query);
if (rc)
error("Failed to add clusters %s to federation %s",
names, fed);
end_it:
xfree(query);
xfree(names);
xfree(indexes);
list_iterator_destroy(itr);
return rc;
}
bool // ** NOT THREAD SAFE **
ADataStore::SetBatchMode(bool inBatchMode) {
bool oldBatchMode = mBatchMode;
mBatchMode = inBatchMode;
if (!mBatchMode) {
WriteHeader(); // write the header now that we are done with batch mode
}
DB_DEBUG("SetBatchMode("<<inBatchMode<<")", DEBUG_TRIVIA);
return(oldBatchMode);
}
// adds a new record with the data in the CRecordObject, returns the ID that was assigned to it
// use MakeNewEmptyRecord() to create the empty record, then you can fill in the fields and
// call this func to add it to the database
RecIDT //** Thread Safe **
ADataStore::AddRecord(CRecord* inRecP) {
ASSERT(inRecP != nil); // еее pass by reference
DB_DEBUG("AddRecord()");
RecIDT id = 0;
AutoLockRecord lock(inRecP); // this will automatically unlock the record when it goes out
DatabaseRec* p = inRecP->GetRecordDataPtr(); // of scope, whether normally or from an exception
id = AddRecord(p);
return id;
}
extern int as_mysql_fix_runaway_jobs(mysql_conn_t *mysql_conn, uint32_t uid,
List runaway_jobs)
{
char *query = NULL, *job_ids = NULL;
slurmdb_job_rec_t *job = NULL;
ListIterator iter = NULL;
int rc = SLURM_SUCCESS;
slurmdb_job_rec_t *first_job;
list_sort(runaway_jobs, _job_sort_by_start_time);
first_job = list_peek(runaway_jobs);
if (check_connection(mysql_conn) != SLURM_SUCCESS)
return ESLURM_DB_CONNECTION;
if (!is_user_min_admin_level(mysql_conn, uid, SLURMDB_ADMIN_OPERATOR)) {
slurmdb_user_rec_t user;
memset(&user, 0, sizeof(slurmdb_user_rec_t));
user.uid = uid;
if (!is_user_any_coord(mysql_conn, &user)) {
error("Only admins/operators/coordinators "
"can fix runaway jobs");
return ESLURM_ACCESS_DENIED;
}
}
iter = list_iterator_create(runaway_jobs);
while ((job = list_next(iter))) {
xstrfmtcat(job_ids, "%s%d", ((job_ids) ? "," : ""), job->jobid);
}
query = xstrdup_printf("UPDATE \"%s_%s\" SET time_end="
"GREATEST(time_start, time_eligible, time_submit), "
"state=%d WHERE id_job IN (%s);",
mysql_conn->cluster_name, job_table,
JOB_COMPLETE, job_ids);
if (debug_flags & DEBUG_FLAG_DB_QUERY)
DB_DEBUG(mysql_conn->conn, "query\n%s", query);
mysql_db_query(mysql_conn, query);
xfree(query);
xfree(job_ids);
/* Set rollup to the the last day of the previous month of the first
* runaway job */
rc = _first_job_roll_up(mysql_conn, first_job->start);
if (rc != SLURM_SUCCESS) {
error("Failed to fix runaway jobs");
return SLURM_ERROR;
}
return rc;
}
bool // ** NOT THREAD SAFE **
ADataStore::ReadHeader() {
Bool8 fileOpen;
itsStream->SetMarker(0, streamFrom_Start);
*itsStream >> mStreamType;
*itsStream >> mStreamVersion;
*itsStream >> fileOpen;
*itsStream >> mLastRecID;
DB_DEBUG("ReadHeader(): "<< (fileOpen?"already open":"closed"), DEBUG_TRIVIA);
return fileOpen;
}
int hss_mysql_query_mmeidentity(const int id_mme_identity,
mysql_mme_identity_t *mme_identity_p)
{
MYSQL_RES *res;
MYSQL_ROW row;
char query[1000];
if ((db_desc->db_conn == NULL) || (mme_identity_p == NULL)) {
return EINVAL;
}
memset(mme_identity_p, 0, sizeof(mysql_mme_identity_t));
sprintf(query, "SELECT mmehost,mmerealm FROM mmeidentity WHERE "
"mmeidentity.idmmeidentity='%d' ", id_mme_identity);
DB_DEBUG("Query: %s\n", query);
pthread_mutex_lock(&db_desc->db_cs_mutex);
if (mysql_query(db_desc->db_conn, query)) {
pthread_mutex_unlock(&db_desc->db_cs_mutex);
DB_ERROR("Query execution failed: %s\n",
mysql_error(db_desc->db_conn));
mysql_thread_end();
return EINVAL;
}
res = mysql_store_result(db_desc->db_conn);
pthread_mutex_unlock(&db_desc->db_cs_mutex);
if ((row = mysql_fetch_row(res)) != NULL) {
if (row[0] != NULL) {
memcpy(mme_identity_p->mme_host, row[0], strlen(row[0]));
} else {
mme_identity_p->mme_host[0] = '\0';
}
if (row[1] != NULL) {
memcpy(mme_identity_p->mme_realm, row[1], strlen(row[1]));
} else {
mme_identity_p->mme_realm[0] = '\0';
}
mysql_free_result(res);
mysql_thread_end();
return 0;
}
mysql_free_result(res);
mysql_thread_end();
return EINVAL;
}
extern int as_mysql_remove_resv(mysql_conn_t *mysql_conn,
slurmdb_reservation_rec_t *resv)
{
int rc = SLURM_SUCCESS;
char *query = NULL;
if (!resv) {
error("No reservation was given to remove");
return SLURM_ERROR;
}
if (!resv->id) {
error("An id is needed to remove a reservation.");
return SLURM_ERROR;
}
if (!resv->time_start) {
error("A start time is needed to remove a reservation.");
return SLURM_ERROR;
}
if (!resv->cluster || !resv->cluster[0]) {
error("A cluster name is needed to remove a reservation.");
return SLURM_ERROR;
}
/* first delete the resv that hasn't happened yet. */
query = xstrdup_printf("delete from \"%s_%s\" where time_start > %ld "
"and id_resv=%u and time_start=%ld;",
resv->cluster, resv_table, resv->time_start_prev,
resv->id,
resv->time_start);
/* then update the remaining ones with a deleted flag and end
* time of the time_start_prev which is set to when the
* command was issued */
xstrfmtcat(query,
"update \"%s_%s\" set time_end=%ld, "
"deleted=1 where deleted=0 and "
"id_resv=%u and time_start=%ld;",
resv->cluster, resv_table, resv->time_start_prev,
resv->id, resv->time_start);
if (debug_flags & DEBUG_FLAG_DB_RESV)
DB_DEBUG(mysql_conn->conn, "query\n%s", query);
rc = mysql_db_query(mysql_conn, query);
xfree(query);
return rc;
}
static int _reset_default_wckey(mysql_conn_t *mysql_conn,
slurmdb_wckey_rec_t *wckey)
{
time_t now = time(NULL);
int rc = SLURM_SUCCESS;
char *query = NULL;
MYSQL_RES *result = NULL;
MYSQL_ROW row;
if ((wckey->is_def != 1)
|| !wckey->cluster || !wckey->user || !wckey->name)
return SLURM_ERROR;
xstrfmtcat(query, "update \"%s_%s\" set is_def=0, mod_time=%ld "
"where (user='******' && wckey_name!='%s' && is_def=1);"
"select id_wckey from \"%s_%s\" "
"where (user='******' && wckey_name!='%s' && is_def=1);",
wckey->cluster, wckey_table, (long)now,
wckey->user, wckey->name,
wckey->cluster, wckey_table,
wckey->user, wckey->name);
if (debug_flags & DEBUG_FLAG_DB_WCKEY)
DB_DEBUG(mysql_conn->conn, "query\n%s", query);
if (!(result = mysql_db_query_ret(mysql_conn, query, 1))) {
xfree(query);
rc = SLURM_ERROR;
goto end_it;
}
xfree(query);
while ((row = mysql_fetch_row(result))) {
slurmdb_wckey_rec_t *mod_wckey =
xmalloc(sizeof(slurmdb_wckey_rec_t));
slurmdb_init_wckey_rec(mod_wckey, 0);
mod_wckey->id = slurm_atoul(row[0]);
mod_wckey->is_def = 0;
if (addto_update_list(mysql_conn->update_list,
SLURMDB_MODIFY_WCKEY,
mod_wckey)
!= SLURM_SUCCESS) {
slurmdb_destroy_wckey_rec(mod_wckey);
error("couldn't add to the update list");
rc = SLURM_ERROR;
break;
}
}
mysql_free_result(result);
end_it:
return rc;
}
void //** Thread Safe **
ADataStore::WriteHeader(bool inFileOpen) {
Bool8 fileOpen = inFileOpen;
#if DB_THREAD_SUPPORT
StSafeMutex mutex(mAccessHeader);
#endif
ASSERT(sizeof(RecIDT) == sizeof(UInt32)); // precondition for this to work correctly
// don't write the type and version info each time
itsStream->SetMarker(sizeof(OSType) + sizeof(UInt32), streamFrom_Start);
*itsStream << fileOpen; //***CW8 // platform independant files
*itsStream << mLastRecID;
DB_DEBUG("WriteHeader("<<(int)inFileOpen<<")", DEBUG_TRIVIA);
}
// must call Close() before deleting object
ADataStore::~ADataStore() { // ** NOT THREAD SAFE **
if (mOwnsComparator)
delete itsDefaultComparator;
#if DB_THREAD_SUPPORT
if (UEnvironment::HasFeature(env_HasThreadsManager)) {
delete mChangeID;
delete mAccessHeader;
delete mAccessData;
delete mChangeInfo;
}
#endif
DB_DEBUG("Deleted Datastore", DEBUG_TRIVIA);
}
SInt32
CVarDataFile::GetRecordSize(RecIDT inRecID) {
#if DB_DEBUG_MODE
if (inRecID > mLastRecID) {
DB_DEBUG("ERROR: Invalid Record ID "<<inRecID<<" requested. Last ID is "<<mLastRecID, DEBUG_ERROR);
}
#endif
if (0 == inRecID) {
return(mLargestRecSize + kSlotSizeExtra + kSlotSizeSlop); // return super-safe buffer size
}
SInt32 recSize;
itsMasterIndex->FindEntry(inRecID, &recSize); // find index entry
return (recSize); // return the allocation block size of the record
}
static int _process_cluster_usage(mysql_conn_t *mysql_conn,
char *cluster_name,
time_t curr_start, time_t curr_end,
time_t now, local_cluster_usage_t *c_usage)
{
int rc = SLURM_SUCCESS;
char *query = NULL;
ListIterator itr;
local_tres_usage_t *loc_tres;
if (!c_usage)
return rc;
/* Now put the lists into the usage tables */
xassert(c_usage->loc_tres);
itr = list_iterator_create(c_usage->loc_tres);
while ((loc_tres = list_next(itr))) {
_setup_cluster_tres_usage(mysql_conn, cluster_name,
curr_start, curr_end, now,
c_usage->start, loc_tres, &query);
}
list_iterator_destroy(itr);
if (!query)
return rc;
xstrfmtcat(query,
" on duplicate key update "
"mod_time=%ld, count=VALUES(count), "
"alloc_secs=VALUES(alloc_secs), "
"down_secs=VALUES(down_secs), "
"pdown_secs=VALUES(pdown_secs), "
"idle_secs=VALUES(idle_secs), "
"over_secs=VALUES(over_secs), "
"resv_secs=VALUES(resv_secs)",
now);
/* Spacing out the inserts here instead of doing them
all at once in the end proves to be faster. Just FYI
so we don't go testing again and again.
*/
if (debug_flags & DEBUG_FLAG_DB_USAGE)
DB_DEBUG(mysql_conn->conn, "query\n%s", query);
rc = mysql_db_query(mysql_conn, query);
xfree(query);
if (rc != SLURM_SUCCESS)
error("Couldn't add cluster hour rollup");
return rc;
}
// creates new CRecord object and fills it with the data of the record specified by inRecID
CRecord* //** Thread Safe **
ADataStore::ReadRecord(RecIDT inRecID) {
DB_DEBUG("ReadRecord("<<inRecID<<")");
CRecord* theRec = (CRecord*)nil;
long size = GetRecordSize(inRecID);
if (size > 0) {
temp_buffer(DatabaseRec, p, size); // allocate a read buffer
p->recID = inRecID;
p->recSize = size;
ReadRecord(p);
theRec = MakeRecordObject(p);
}
return theRec;
}
// deletes the record and the object too and sets the pointer passed in to nil also catches
// the exception if the record was not found, since we were going to delete it anyway
void //** Thread Safe **
ADataStore::DeleteRecord(CRecord* &inRecP) {
ASSERT(inRecP != nil);
DB_DEBUG("WriteRecord("<<inRecP->GetRecordID()<<")");
Try_{
DeleteRecord(inRecP->GetRecordID());
}
Catch_(err) {
if (err != dbItemNotFound)
Throw_(err); // pass on the exception if it was something other than notFound
}
delete inRecP;
inRecP = (CRecord*)nil;
}
void
CVarDataFile::WriteHeader(bool inFileOpen) {
if (mReadOnly) {
return; // v1.5.1 bug fix, don't write to read-only files
}
DB_DEBUG("CVarDataFile::WriteHeader", DEBUG_TRIVIA);
CDataFile::WriteHeader(inFileOpen);
VarDataFileHeaderT tempHeader;
tempHeader.allocatedBytes = Native_ToBigEndian32(mAllocatedBytes);
tempHeader.bytesUsed = Native_ToBigEndian32(mBytesUsed);
tempHeader.largestRecSize = Native_ToBigEndian32(mLargestRecSize);
tempHeader.fileIsDamaged = mFileIsDamaged;
WriteBlock(&tempHeader, sizeof(VarDataFileHeaderT));
FlushFile();
}
bool
CVarDataFile::FindRecord(DatabaseRec *ioRecP, LComparator *inComparator) {
#warning FIXME: pretty sure the loop below is broken and will stay stuck on the same record
bool found = false;
SInt32 slotSize;
SInt32 recPos;
ASSERT(mLargestRecSize > (SInt32)sizeof(DatabaseRec)); // this assertion will fail if no recs in file
DatabaseRecPtr recP = (DatabaseRec*) std::malloc(mLargestRecSize);
ThrowIfNil_(recP);
if (NULL == inComparator) {
inComparator = itsDefaultComparator; // use one of the comparators
}
SetMarker(mFirstItemPos + kVarDBFileSlotSizeOffset, streamFrom_Start); // move to start of the 1st record
for (UInt32 i = 0; i<mItemCount; i++) { // look at all the records in the datafile
recPos = GetMarker();
ReadBlock(&slotSize, kSizeOfSlotSize); // read the slot size into the pointer
#if PLATFORM_LITTLE_ENDIAN
slotSize = BigEndian32_ToNative(slotSize);
#endif // PLATFORM_LITTLE_ENDIAN
ReadBlock(&recP->recID, slotSize - kSizeOfSlotSize); // read the contents of the slot
#if PLATFORM_LITTLE_ENDIAN
recP->recID = BigEndian32_ToNative(recP->recID);
#endif // PLATFORM_LITTLE_ENDIAN
recP->recSize = SlotSizeToRecSize(slotSize);
if (inComparator->IsEqualTo(ioRecP, recP, recP->recSize, recP->recSize) ) {
// compare the current rec to the source еее CW 8 mod - added sizes
found = true;
ioRecP->recPos = recPos; // return the found recPos in the DatabaseRecPtr
if (SlotSizeToRecSize(slotSize) < ioRecP->recSize) {
ioRecP->recSize = SlotSizeToRecSize(slotSize); // return the found recSize in the DatabaseRecPtr
}
UInt8 *dst = (UInt8*)&ioRecP->recSize;
UInt8 *src = (UInt8*)&recP->recSize; // include recSize & recID in copy
for (SInt32 n = RecSizeToSlotSize(ioRecP->recSize); n>0; n--) { // copy the data to be returned
*dst++ = *src++;
}
break;
}
}
#if DB_DEBUG_MODE
if (found && (ioRecP->recID > mLastRecID)) {
DB_DEBUG("ERROR: Invalid Record ID "<<ioRecP->recID<<" returned. Last ID is "<<mLastRecID, DEBUG_ERROR);
}
#endif
std::free(recP); // free the temporary buffer
return found; // return true if found
}
SInt32
CVarDataFile::GetSlotSize(UInt32 inSlotPos) {
#if DB_DEBUG_MODE || DB_INTEGRITY_CHECKING
ASSERT(mBytesUsed <= mAllocatedBytes); // can't use more than we've allocated
ASSERT((mAllocatedBytes+mFirstItemPos) == GetLength()); // LFileStream needs to be in synch
if (GetLength() < (SInt32)inSlotPos) {
DB_DEBUG("ERROR: Trying to read from slot at offset "<<inSlotPos<<", but datafile is only "<<GetLength()<<" bytes long.", DEBUG_ERROR);
Throw_( dbDataCorrupt );
}
#endif
SInt32 slotSize;
SetMarker(inSlotPos + kVarDBFileSlotSizeOffset, streamFrom_Start);
ReadBlock(&slotSize, kSizeOfSlotSize);
#if PLATFORM_LITTLE_ENDIAN
slotSize = BigEndian32_ToNative(slotSize);
#endif // PLATFORM_LITTLE_ENDIAN
return slotSize;
}
extern int as_mysql_add_resv(mysql_conn_t *mysql_conn,
slurmdb_reservation_rec_t *resv)
{
int rc = SLURM_SUCCESS;
char *cols = NULL, *vals = NULL, *extra = NULL,
*query = NULL;
if (!resv) {
error("No reservation was given to add.");
return SLURM_ERROR;
}
if (!resv->id) {
error("We need an id to add a reservation.");
return SLURM_ERROR;
}
if (!resv->time_start) {
error("We need a start time to add a reservation.");
return SLURM_ERROR;
}
if (!resv->cluster || !resv->cluster[0]) {
error("We need a cluster name to add a reservation.");
return SLURM_ERROR;
}
_setup_resv_limits(resv, &cols, &vals, &extra);
xstrfmtcat(query,
"insert into \"%s_%s\" (id_resv%s) values (%u%s) "
"on duplicate key update deleted=0%s;",
resv->cluster, resv_table, cols, resv->id, vals, extra);
if (debug_flags & DEBUG_FLAG_DB_RESV)
DB_DEBUG(mysql_conn->conn, "query\n%s", query);
rc = mysql_db_query(mysql_conn, query);
xfree(query);
xfree(cols);
xfree(vals);
xfree(extra);
return rc;
}
void
CVarDataFile::UpdateRecord(DatabaseRec *inRecP) {
SInt32 recSize = inRecP->recSize;
SInt32 recPos = itsMasterIndex->UpdateEntry(inRecP->recID, recSize); // find index entry
inRecP->recPos = recPos;
#if DB_DEBUG_MODE || DB_INTEGRITY_CHECKING
if (inRecP->recID > mLastRecID) {
DB_DEBUG("ERROR: Invalid Record ID "<<inRecP->recID<<" updated. Last ID is "<<mLastRecID, DEBUG_ERROR);
Throw_( dbInvalidID );
}
if (recSize < (SInt32)sizeof(DatabaseRec)) {
DB_DEBUG("ERROR: Trying to update Rec "<<inRecP->recID<<" with size of "<<recSize<<" bytes, smaller than the record header alone.", DEBUG_ERROR);
Throw_( dbDataCorrupt );
}
ASSERT(mBytesUsed <= mAllocatedBytes); // can't use more than we've allocated
ASSERT((mAllocatedBytes+mFirstItemPos) == GetLength()); // LFileStream needs to be in synch
if (GetLength() < recPos) {
DB_DEBUG("ERROR: Index returned offset "<<recPos<<" for Rec "<<inRecP->recID<<", but datafile is only "<<GetLength()<<" bytes long.", DEBUG_ERROR);
mFileIsDamaged = true;
Throw_( dbIndexCorrupt );
}
// DB_DEBUG("in UpdateRecord("<< inRecP->recID <<"); size: "<<recSize<<" pos: "<<recPos, DEBUG_TRIVIA);
RecIDT oldID;
SInt32 slotSize;
SetMarker(recPos + kVarDBFileSlotSizeOffset, streamFrom_Start); // debugging, check old ID
ReadBlock(&slotSize, kSizeOfSlotSize);
ReadBlock(&oldID, kSizeOfRecID);
#if PLATFORM_LITTLE_ENDIAN
slotSize = BigEndian32_ToNative(slotSize);
oldID = BigEndian32_ToNative(oldID);
#endif // PLATFORM_LITTLE_ENDIAN
if ( (oldID != 0) && (oldID != inRecP->recID) ) {
DB_LOG("ERROR: Update Rec " << inRecP->recID << " " << recSize << "B pos: "<<recPos<<" FAILED, overwriting Rec "<<oldID);
DB_DEBUG("ERROR: Updating "<< inRecP->recID << " into wrong place [" << recPos << "] , overwriting Rec "<<oldID, DEBUG_ERROR);
mFileIsDamaged = true;
Throw_( dbIndexCorrupt );
}
if (slotSize < RecSizeToSlotSize(recSize)) {
DB_LOG("ERROR: Update Rec " << inRecP->recID << " " << recSize << "B pos: "<<recPos<<" FAILED, slot too small "<<slotSize<<"B");
DB_DEBUG("ERROR: Writing "<< inRecP->recID <<" of "<<RecSizeToSlotSize(recSize)<<" bytes into a "<<slotSize<<" byte slot at "<< recPos, DEBUG_ERROR);
mFileIsDamaged = true;
Throw_( dbDataCorrupt );
}
#endif
SetMarker(recPos + kVarDBFileRecIDOffset, streamFrom_Start); // move to start of slot's data, skipping size
inRecP->recID = Native_ToBigEndian32(inRecP->recID);
WriteBlock(&inRecP->recID, RecSizeToIOSize(recSize)); // write the new record data into the slot
inRecP->recID = BigEndian32_ToNative(inRecP->recID);
DB_LOG("Updated Rec " << inRecP->recID << " " << recSize << "B pos: "<<recPos);
DB_DEBUG("UpdateRecord("<< inRecP->recID <<"); size: "<<recSize<<" pos: "<<recPos, DEBUG_TRIVIA);
}
int hss_mysql_check_epc_equipment(mysql_mme_identity_t *mme_identity_p)
{
MYSQL_RES *res;
MYSQL_ROW row;
char query[1000];
if ((db_desc->db_conn == NULL) || (mme_identity_p == NULL)) {
return EINVAL;
}
sprintf(query, "SELECT idmmeidentity FROM mmeidentity WHERE mmeidentity.mmehost='%s' ",
mme_identity_p->mme_host);
DB_DEBUG("Query: %s\n", query);
pthread_mutex_lock(&db_desc->db_cs_mutex);
if (mysql_query(db_desc->db_conn, query)) {
pthread_mutex_unlock(&db_desc->db_cs_mutex);
DB_ERROR("Query execution failed: %s\n",
mysql_error(db_desc->db_conn));
mysql_thread_end();
return EINVAL;
}
res = mysql_store_result(db_desc->db_conn);
pthread_mutex_unlock(&db_desc->db_cs_mutex);
if ((row = mysql_fetch_row(res)) != NULL) {
mysql_free_result(res);
mysql_thread_end();
return 0;
}
mysql_free_result(res);
mysql_thread_end();
return EINVAL;
}
/*
* Remove all clusters from federation.
* IN: mysql_conn - mysql connection
* IN: fed - fed to remove clusters from
* IN: exceptions - list of clusters to not remove.
*/
static int _remove_all_clusters_from_fed(mysql_conn_t *mysql_conn,
const char *fed, List exceptions)
{
int rc = SLURM_SUCCESS;
char *query = NULL;
char *exception_names = NULL;
if (exceptions && list_count(exceptions)) {
char *tmp_name;
ListIterator itr;
itr = list_iterator_create(exceptions);
while ((tmp_name = list_next(itr)))
xstrfmtcat(exception_names, "%s'%s'",
(exception_names) ? "," : "",
tmp_name);
list_iterator_destroy(itr);
}
xstrfmtcat(query, "UPDATE %s "
"SET federation='', fed_id=0, fed_state=%u "
"WHERE federation='%s' and deleted=0",
cluster_table, CLUSTER_FED_STATE_NA, fed);
if (exception_names)
xstrfmtcat(query, " AND name NOT IN (%s)", exception_names);
if (debug_flags & DEBUG_FLAG_FEDR)
DB_DEBUG(mysql_conn->conn, "query\n%s", query);
rc = mysql_db_query(mysql_conn, query);
xfree(query);
if (rc)
error("Failed to remove all clusters from federation %s", fed);
if (exception_names)
xfree(exception_names);
return rc;
}
static int _change_user_name(mysql_conn_t *mysql_conn, slurmdb_user_rec_t *user)
{
int rc = SLURM_SUCCESS;
char *query = NULL;
ListIterator itr = NULL;
char *cluster_name = NULL;
xassert(user->old_name);
xassert(user->name);
slurm_mutex_lock(&as_mysql_cluster_list_lock);
itr = list_iterator_create(as_mysql_cluster_list);
while ((cluster_name = list_next(itr))) {
// Change assoc_tables
xstrfmtcat(query, "update \"%s_%s\" set user='******' "
"where user='******';", cluster_name, assoc_table,
user->name, user->old_name);
// Change wckey_tables
xstrfmtcat(query, "update \"%s_%s\" set user='******' "
"where user='******';", cluster_name, wckey_table,
user->name, user->old_name);
}
list_iterator_destroy(itr);
slurm_mutex_unlock(&as_mysql_cluster_list_lock);
// Change coord_tables
xstrfmtcat(query, "update %s set user='******' where user='******';",
acct_coord_table, user->name, user->old_name);
if (debug_flags & DEBUG_FLAG_DB_ASSOC)
DB_DEBUG(mysql_conn->conn, "query\n%s", query);
rc = mysql_db_query(mysql_conn, query);
xfree(query);
if (rc != SLURM_SUCCESS)
reset_mysql_conn(mysql_conn);
return rc;
}
