自学教程：C++ DB_DEBUG函数代码示例

voidCVarDataFile::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);}

UInt32CVarDataFile::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;}

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);}

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='%s' && wckey_name!='%s' && is_def=1);"               "select id_wckey from /"%s_%s/" "               "where (user='%s' && 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);}

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;}

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;}

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='%s' "			   "where user='%s';", cluster_name, assoc_table,			   user->name, user->old_name);		// Change wckey_tables		xstrfmtcat(query, "update /"%s_%s/" set user='%s' "			   "where user='%s';", 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='%s' where user='%s';",		   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;}