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

static void _print_burst_buffer_resv(FILE *out,				     burst_buffer_resv_t* burst_buffer_ptr,				     int one_liner, bool verbose){	char sz_buf[32], time_buf[64], tmp_line[512];	char *out_buf = NULL;	/****** Line 1 ******/	if (burst_buffer_ptr->job_id &&	    (burst_buffer_ptr->array_task_id == NO_VAL)) {		snprintf(tmp_line, sizeof(tmp_line),			"    JobID=%u ", burst_buffer_ptr->job_id);	} else if (burst_buffer_ptr->job_id) {		snprintf(tmp_line, sizeof(tmp_line),			"    JobID=%u_%u(%u) ",			burst_buffer_ptr->array_job_id,		        burst_buffer_ptr->array_task_id,		        burst_buffer_ptr->job_id);	} else {		snprintf(tmp_line, sizeof(tmp_line),			"    Name=%s ", burst_buffer_ptr->name);	}	xstrcat(out_buf, tmp_line);	_get_size_str(sz_buf, sizeof(sz_buf), burst_buffer_ptr->size);	if (burst_buffer_ptr->create_time) {		slurm_make_time_str(&burst_buffer_ptr->create_time, time_buf,				    sizeof(time_buf));	} else {		time_t now = time(NULL);		slurm_make_time_str(&now, time_buf, sizeof(time_buf));	}	if (verbose) {		snprintf(tmp_line, sizeof(tmp_line),			 "Account=%s CreateTime=%s Partition=%s Pool=%s QOS=%s "			 "Size=%s State=%s UserID=%s(%u)",			 burst_buffer_ptr->account, time_buf,			 burst_buffer_ptr->partition, burst_buffer_ptr->pool,			 burst_buffer_ptr->qos,			 sz_buf, bb_state_string(burst_buffer_ptr->state),			 uid_to_string(burst_buffer_ptr->user_id),			 burst_buffer_ptr->user_id);	} else {		snprintf(tmp_line, sizeof(tmp_line),			 "CreateTime=%s Pool=%s Size=%s State=%s UserID=%s(%u)",			 time_buf, burst_buffer_ptr->pool, sz_buf,			 bb_state_string(burst_buffer_ptr->state),			 uid_to_string(burst_buffer_ptr->user_id),			 burst_buffer_ptr->user_id);	}	xstrcat(out_buf, tmp_line);	xstrcat(out_buf, "/n");	fprintf(out, "%s", out_buf);	xfree(out_buf);}

/* * mail_job_info - Send e-mail notice of job state change * IN job_ptr - job identification * IN state_type - job transition type, see MAIL_JOB in slurm.h */extern void mail_job_info (struct job_record *job_ptr, uint16_t mail_type){	char job_time[128];	mail_info_t *mi = _mail_alloc();	if (!job_ptr->mail_user)		mi->user_name = uid_to_string((uid_t)job_ptr->user_id);	else		mi->user_name = xstrdup(job_ptr->mail_user);	mi->message = xmalloc(256);	_set_job_time(job_ptr, mail_type, job_time, sizeof(job_time));	sprintf(mi->message, "SLURM Job_id=%u Name=%.24s %s%s",		job_ptr->job_id, job_ptr->name,		_mail_type_str(mail_type), job_time);	debug("email msg to %s: %s", mi->user_name, mi->message);	slurm_mutex_lock(&mail_mutex);	if (!mail_list) {		mail_list = list_create(_mail_free);		if (!mail_list)			fatal("list_create failed");	}	if (!list_enqueue(mail_list, (void *) mi))		fatal("list_enqueue failed");	slurm_mutex_unlock(&mail_mutex);	return;}

/* updates the burst buffer record on sview */static void _update_bb_record(sview_bb_info_t *sview_bb_info_ptr,			      GtkTreeStore *treestore){	char tmp_create_time[40];	char tmp_size[20], tmp_user_id[60], bb_name_id[32];	char *tmp_state, *tmp_user_name;	burst_buffer_resv_t *bb_ptr = sview_bb_info_ptr->bb_ptr;	if (bb_ptr->name) {		strncpy(bb_name_id, bb_ptr->name, sizeof(bb_name_id));	} else if (bb_ptr->array_task_id == NO_VAL) {		convert_num_unit(bb_ptr->job_id, bb_name_id,				 sizeof(bb_name_id),				 UNIT_NONE, working_sview_config.convert_flags);	} else {		snprintf(bb_name_id, sizeof(bb_name_id),			 "%u_%u(%u)",			 bb_ptr->array_job_id,			 bb_ptr->array_task_id,			 bb_ptr->job_id);	}	if (bb_ptr->create_time) {		slurm_make_time_str((time_t *)&bb_ptr->create_time,				    tmp_create_time, sizeof(tmp_create_time));	} else {		time_t now = time(NULL);		slurm_make_time_str(&now, tmp_create_time,				    sizeof(tmp_create_time));	}	_get_size_str(tmp_size, sizeof(tmp_size), bb_ptr->size);	tmp_state = bb_state_string(bb_ptr->state);	tmp_user_name = uid_to_string(bb_ptr->user_id);	snprintf(tmp_user_id, sizeof(tmp_user_id), "%s(%u)", tmp_user_name,		 bb_ptr->user_id);	xfree(tmp_user_name);	/* Combining these records provides a slight performance improvement */	gtk_tree_store_set(treestore, &sview_bb_info_ptr->iter_ptr,			   SORTID_COLOR,			   sview_colors[sview_bb_info_ptr->color_inx],			   SORTID_COLOR_INX,     sview_bb_info_ptr->color_inx,			   SORTID_PLUGIN,        sview_bb_info_ptr->plugin,			   SORTID_ACCOUNT,       bb_ptr->account,			   SORTID_CREATE_TIME,   tmp_create_time,			   SORTID_NAME,          bb_name_id,			   SORTID_PARTITION,     bb_ptr->partition,			   SORTID_POOL,          bb_ptr->pool,			   SORTID_QOS,           bb_ptr->qos,			   SORTID_SIZE,          tmp_size,			   SORTID_STATE,         tmp_state,			   SORTID_UPDATED,       1,			   SORTID_USERID,        tmp_user_id,			   -1);	return;}

extern List as_mysql_remove_wckeys(mysql_conn_t *mysql_conn,                                   uint32_t uid,                                   slurmdb_wckey_cond_t *wckey_cond){    List ret_list = NULL;    int rc = SLURM_SUCCESS;    char *extra = NULL, *object = NULL;    char *user_name = NULL;    List use_cluster_list = as_mysql_cluster_list;    ListIterator itr;    if (!wckey_cond) {        xstrcat(extra, " where deleted=0");        goto empty;    }    if (check_connection(mysql_conn) != SLURM_SUCCESS)        return NULL;    if (!is_user_min_admin_level(mysql_conn, uid, SLURMDB_ADMIN_OPERATOR)) {        errno = ESLURM_ACCESS_DENIED;        return NULL;    }    (void) _setup_wckey_cond_limits(wckey_cond, &extra);    if (wckey_cond->cluster_list && list_count(wckey_cond->cluster_list))        use_cluster_list = wckey_cond->cluster_list;empty:    if (!extra) {        error("Nothing to remove");        return NULL;    }    user_name = uid_to_string((uid_t) uid);    if (use_cluster_list == as_mysql_cluster_list)        slurm_mutex_lock(&as_mysql_cluster_list_lock);    ret_list = list_create(slurm_destroy_char);    itr = list_iterator_create(use_cluster_list);    while ((object = list_next(itr))) {        if ((rc = _cluster_remove_wckeys(                      mysql_conn, extra, object, user_name, ret_list))                != SLURM_SUCCESS)            break;    }    list_iterator_destroy(itr);    xfree(extra);    xfree(user_name);    if (use_cluster_list == as_mysql_cluster_list)        slurm_mutex_unlock(&as_mysql_cluster_list_lock);    if (rc == SLURM_ERROR) {        list_destroy(ret_list);        return NULL;    }    return ret_list;}

/* * mcs_p_set_mcs_label() is called to obtain mcs_label. */extern int mcs_p_set_mcs_label (struct job_record *job_ptr, char *label){	char *user = NULL;	int rc = SLURM_SUCCESS;	user = uid_to_string((uid_t) job_ptr->user_id);	xfree(job_ptr->mcs_label);	if (label != NULL) {		/* test label param */		if (xstrcmp(label, user) == 0)			job_ptr->mcs_label = xstrdup(user);		else			rc = SLURM_ERROR;	} else {		if ((slurm_mcs_get_enforced() == 0) && job_ptr->details &&		    (job_ptr->details->whole_node != WHOLE_NODE_MCS))			;		else			job_ptr->mcs_label = xstrdup(user);	}	xfree(user);	return rc;}

static void _print_slurm_config(void){	time_t now = time(NULL);	char tmp_str[128], *user_name = NULL;	slurm_make_time_str(&now, tmp_str, sizeof(tmp_str));	printf("Configuration data as of %s/n", tmp_str);	printf("AccountingStorageBackupHost  = %s/n", acct_storage_backup_host);	printf("AccountingStorageHost  = %s/n", acct_storage_host);	printf("AccountingStorageLoc   = %s/n", acct_storage_loc);	printf("AccountingStoragePass  = %s/n", acct_storage_pass);	printf("AccountingStoragePort  = %u/n", acct_storage_port);	printf("AccountingStorageType  = %s/n", acct_storage_type);	printf("AccountingStorageUser  = %s/n", acct_storage_user);	printf("AuthType               = %s/n", auth_type);	printf("MessageTimeout         = %u sec/n", msg_timeout);	printf("PluginDir              = %s/n", plugin_dir);	private_data_string(private_data, tmp_str, sizeof(tmp_str));	printf("PrivateData            = %s/n", tmp_str);	user_name = uid_to_string(slurm_user_id);	printf("SlurmUserId            = %s(%u)/n", user_name, slurm_user_id);	xfree(user_name);	printf("SLURM_CONF             = %s/n", default_slurm_config_file);	printf("SLURM_VERSION          = %s/n", SLURM_VERSION_STRING);	printf("TrackWCKey             = %u/n", track_wckey);}

static void	_send_reply(slurm_fd_t new_fd, char *response){	size_t i;	char *buf, sum[20], *tmp;	static char uname[64] = "";	i = strlen(response);	i += 100;	/* leave room for header */	buf = xmalloc(i);	if (uname[0] == '/0') {		tmp = uid_to_string(getuid());		strncpy(uname, tmp, sizeof(uname));		uname[sizeof(uname) - 1] = '/0';		xfree(tmp);	}	snprintf(buf, i, "CK=dummy67890123456 TS=%u AUTH=%s DT=%s",		(uint32_t) time(NULL), uname, response);	checksum(sum, auth_key, (buf+20));   /* overwrite "CK=dummy..." above */	memcpy(buf, sum, 19);	i = strlen(buf) + 1;	(void) _send_msg(new_fd, buf, i);	xfree(buf);}

/* * Substitute the path option for a batch job * */static void _batch_path_check(char **p, char **q, char **name,			      unsigned int wid, stepd_step_rec_t *job,			      int taskid){	switch (**p) {	case 'a':  /* '%a' => array task id   */		xmemcat(*name, *q, *p - 1);		xstrfmtcat(*name, "%0*u", wid,			   job->array_task_id);		*q = ++(*p);		break;	case 'A':  /* '%A' => array master job id */		xmemcat(*name, *q, *p - 1);		if (job->array_task_id == NO_VAL)			xstrfmtcat(*name, "%0*u", wid, job->jobid);		else			xstrfmtcat(*name, "%0*u",wid, job->array_job_id);		*q = ++(*p);		break;	case 'J':  /* '%J' => jobid.stepid */	case 'j':  /* '%j' => jobid        */		xmemcat(*name, *q, *p - 1);		xstrfmtcat(*name, "%0*u", wid, job->jobid);		if ((**p == 'J') && (job->stepid != NO_VAL))			xstrfmtcat(*name, ".%u", job->stepid);		*q = ++(*p);		break;	case 'n':  /* '%n' => nodeid         */		xmemcat(*name, *q, *p - 1);		xstrfmtcat(*name, "%0*u", wid, job->nodeid);		*q = ++(*p);		break;	case 'N':  /* '%N' => node name      */		xmemcat(*name, *q, *p - 1);		xstrfmtcat(*name, "%s", conf->hostname);		*q = ++(*p);		break;	case 's':  /* '%s' => step id        */		xmemcat(*name, *q, *p - 1);		xstrfmtcat(*name, "%0*u", wid, job->stepid);		*q = ++(*p);		break;	case 't':  /* '%t' => taskid         */		xmemcat(*name, *q, *p - 1);		xstrfmtcat(*name, "%0*u", wid, taskid);		*q = ++(*p);		break;	case 'u':  /* '%u' => user name      */		if (!job->user_name)			job->user_name = uid_to_string(job->uid);		xmemcat(*name, *q, *p - 1);		xstrfmtcat(*name, "%s", job->user_name);		*q = ++(*p);		break;	default:		break;	}}

/* Get the user name for the give user_id */static void _get_user_name(uint32_t user_id, char *user_name, int buf_size){	static uint32_t cache_uid = 0;	static char cache_name[32] = "root", *uname;	if (user_id != cache_uid) {		uname = uid_to_string((uid_t) user_id);		snprintf(cache_name, sizeof(cache_name), "%s", uname);		xfree(uname);		cache_uid = user_id;	}	snprintf(user_name, buf_size, "%s", cache_name);}

int _print_job_user_name(job_info_t * job, int width, bool right, char* suffix){	if (job == NULL)	/* Print the Header instead */		_print_str("USER", width, right, true);	else {		char *uname = uid_to_string((uid_t) job->user_id);		_print_str(uname, width, right, true);		xfree(uname);	}	if (suffix)		printf("%s", suffix);	return SLURM_SUCCESS;}

/* read and broadcast the file */static void _bcast_file(void){	int buf_size;	ssize_t size_read = 0;	file_bcast_msg_t bcast_msg;	char *buffer;	if (params.block_size)		buf_size = MIN(params.block_size, f_stat.st_size);	else		buf_size = MIN((512 * 1024), f_stat.st_size);	bcast_msg.fname		= params.dst_fname;	bcast_msg.block_no	= 1;	bcast_msg.last_block	= 0;	bcast_msg.force		= params.force;	bcast_msg.modes		= f_stat.st_mode;	bcast_msg.uid		= f_stat.st_uid;	bcast_msg.user_name	= uid_to_string(f_stat.st_uid);	bcast_msg.gid		= f_stat.st_gid;	buffer			= xmalloc(buf_size);	bcast_msg.block		= buffer;	bcast_msg.block_len	= 0;	bcast_msg.cred          = sbcast_cred->sbcast_cred;	if (params.preserve) {		bcast_msg.atime     = f_stat.st_atime;		bcast_msg.mtime     = f_stat.st_mtime;	} else {		bcast_msg.atime     = 0;		bcast_msg.mtime     = 0;	}	while (1) {		bcast_msg.block_len = _get_block(buffer, buf_size);		debug("block %d, size %u", bcast_msg.block_no,		      bcast_msg.block_len);		size_read += bcast_msg.block_len;		if (size_read >= f_stat.st_size)			bcast_msg.last_block = 1;		send_rpc(&bcast_msg, sbcast_cred);		if (bcast_msg.last_block)			break;	/* end of file */		bcast_msg.block_no++;	}	xfree(bcast_msg.user_name);	xfree(buffer);}

/* * Substitute the path option for a step. * */static void _step_path_check(char **p, char **q, char **name, unsigned int wid,			     bool double_p, stepd_step_rec_t *job, int taskid,			     int offset){	switch (**p) {	case '%': /* This is in case there is a 3rd %, ie. %%% */		xmemcat(*name, *q, *p - 1);		*q = *p;		break;	case 't':  /* '%t' => taskid         */		xmemcat(*name, *q, *p - offset);		if (!double_p) {			if (job->pack_task_offset != NO_VAL)				taskid += job->pack_task_offset;			xstrfmtcat(*name, "%0*u", wid, taskid);			(*p)++;		}		*q = (*p)++;		break;	case 'n':  /* '%n' => nodeid         */		xmemcat(*name, *q, *p - offset);		if (!double_p) {			xstrfmtcat(*name, "%0*u", wid, job->nodeid);			(*p)++;		}		*q = (*p)++;		break;	case 'N':  /* '%N' => node name      */		xmemcat(*name, *q, *p - offset);		if (!double_p) {			xstrfmtcat(*name, "%s", conf->hostname);			(*p)++;		}		*q = (*p)++;		break;	case 'u':  /* '%u' => user name      */		if (!job->user_name)			job->user_name = uid_to_string(job->uid);		xmemcat(*name, *q, *p - 1);		if (!double_p) {			xstrfmtcat(*name, "%s", job->user_name);			(*p)++;		}		*q = (*p)++;		break;	default:		break;	}}

/* Perform file name substitutions * %A - Job array's master job allocation number. * %a - Job array ID (index) number. * %j - Job ID * %u - User name */static void _fname_format(char *buf, int buf_size, job_info_t * job_ptr,			  char *fname){	char *ptr, *tmp, *tmp2 = NULL, *user;	tmp = xstrdup(fname);	while ((ptr = strstr(tmp, "%A"))) {	/* Array job ID */		ptr[0] = '/0';		if (job_ptr->array_task_id == NO_VAL) {			/* Not a job array */			xstrfmtcat(tmp2, "%s%u%s", tmp, job_ptr->job_id, ptr+2);		} else {			xstrfmtcat(tmp2, "%s%u%s", tmp, job_ptr->array_job_id,				   ptr+2);		}		xfree(tmp);	/* transfer the results */		tmp = tmp2;		tmp2 = NULL;	}	while ((ptr = strstr(tmp, "%a"))) {	/* Array task ID */		ptr[0] = '/0';		xstrfmtcat(tmp2, "%s%u%s", tmp, job_ptr->array_task_id, ptr+2);		xfree(tmp);	/* transfer the results */		tmp = tmp2;		tmp2 = NULL;	}	while ((ptr = strstr(tmp, "%j"))) {	/* Job ID */		ptr[0] = '/0';		xstrfmtcat(tmp2, "%s%u%s", tmp, job_ptr->job_id, ptr+2);		xfree(tmp);	/* transfer the results */		tmp = tmp2;		tmp2 = NULL;	}	while ((ptr = strstr(tmp, "%u"))) {	/* User name */		ptr[0] = '/0';		user = uid_to_string((uid_t) job_ptr->user_id);		xstrfmtcat(tmp2, "%s%s%s", tmp, user, ptr+2);		xfree(user);		xfree(tmp);	/* transfer the results */		tmp = tmp2;		tmp2 = NULL;	}	if (tmp[0] == '/')		snprintf(buf, buf_size, "%s", tmp);	else		snprintf(buf, buf_size, "%s/%s", job_ptr->work_dir, tmp);	xfree(tmp);}

/* * Print information about a job to stdout */void print_job (job_info_t * job_ptr, char * user) {    char * user_name = uid_to_string((uid_t)job_ptr->user_id);    if (user == NULL || strcmp(user, user_name) == 0) {        uint32_t job_id = job_ptr->job_id;        char * job_state = job_state_string_compact(job_ptr->job_state);        char * partition = job_ptr->partition;        char * batch_host = (job_ptr->batch_host == NULL) ? "N/A" : job_ptr->batch_host;        char req_cores[128];        char submit_time_str[32];        char start_time_str[32];        _sprint_range(req_cores, sizeof(req_cores), job_ptr->num_cpus, job_ptr->max_cpus);        make_time_str((time_t *)&job_ptr->submit_time, submit_time_str, sizeof(submit_time_str));        make_time_str((time_t *)&job_ptr->start_time, start_time_str, sizeof(start_time_str));        printf("%u|%s|%s|%s|%s|%s|%s|%s/n", job_id, job_state, user_name, partition, req_cores, batch_host, submit_time_str, start_time_str);    }}

static void _print_burst_buffer_use(FILE *out,				    burst_buffer_use_t* usage_ptr,				    int one_liner){	char tmp_line[512], sz_buf[32];	char *out_buf = NULL;	_get_size_str(sz_buf, sizeof(sz_buf), usage_ptr->used);	snprintf(tmp_line, sizeof(tmp_line),		 "    UserID=%s(%u) Used=%s",	         uid_to_string(usage_ptr->user_id), usage_ptr->user_id, sz_buf);	xstrcat(out_buf, tmp_line);	xstrcat(out_buf, "/n");	fprintf(out, "%s", out_buf);	xfree(out_buf);}

/* * mcs_p_check_mcs_label() is called to check mcs_label. */extern int mcs_p_check_mcs_label (uint32_t user_id, char *mcs_label){	char *user = NULL;	int rc = SLURM_SUCCESS;	user = uid_to_string((uid_t) user_id);	if (mcs_label != NULL) {		if (xstrcmp(mcs_label, user) == 0) {			rc = SLURM_SUCCESS;		} else {			rc = SLURM_ERROR;		}	} else {		rc = SLURM_SUCCESS;	}	xfree(user);	return rc;}

/* Translate an array of (zero terminated) UIDs into a string with colon * delimited UIDs * Return value must be xfreed */static char *_print_users(uid_t *buf){	char *user_elem, *user_str = NULL;	int i;	if (!buf)		return user_str;	for (i = 0; buf[i]; i++) {		user_elem = uid_to_string(buf[i]);		if (!user_elem)			continue;		if (user_str)			xstrcat(user_str, ":");		xstrcat(user_str, user_elem);		xfree(user_elem);	}	return user_str;}

/* get the user name for the give user_id */static char *_get_user_name(uint32_t user_id){	static uint32_t cache_uid      = 0;	static char     cache_name[32] = "root", *uname;	char *ret_name = NULL;	slurm_mutex_lock(&jobcomp_lock);	if (user_id != cache_uid) {		uname = uid_to_string((uid_t) user_id);		snprintf(cache_name, sizeof(cache_name), "%s", uname);		xfree(uname);		cache_uid = user_id;	}	ret_name = xstrdup(cache_name);	slurm_mutex_unlock(&jobcomp_lock);	return ret_name;}

/* * Get a list of groups associated with a specific user_id * Return 0 on success, -1 on failure */static int _get_user_groups(uint32_t user_id, uint32_t group_id,			    gid_t *groups, int max_groups, int *ngroups){	int rc;	char *user_name;	user_name = uid_to_string((uid_t) user_id);	*ngroups = max_groups;	rc = getgrouplist(user_name, (gid_t) group_id, groups, ngroups);	if (rc < 0) {		error("getgrouplist(%s): %m", user_name);		rc = -1;	} else {		*ngroups = rc;		rc = 0;	}	xfree(user_name);	return rc;}

String User::current(){    String out;#if defined(DJV_WINDOWS)    //! /todo TCHAR conversion?    TCHAR tmp [cstring_size] = { 0 };    DWORD size = cstring_size;    ::GetUserName(tmp, &size);    out = String(tmp);#else // DJV_WINDOWS    out = uid_to_string(::getuid());#endif // DJV_WINDOWS    return out;}

extern char *uid_to_string_cached(uid_t uid){	uid_cache_entry_t *entry;	uid_cache_entry_t target = {uid, NULL};	slurm_mutex_lock(&uid_lock);	entry = bsearch(&target, uid_cache, uid_cache_used,			sizeof(uid_cache_entry_t), _uid_compare);	if (entry == NULL) {		uid_cache_entry_t new_entry = {uid, uid_to_string(uid)};		uid_cache_used++;		uid_cache = xrealloc(uid_cache,				     sizeof(uid_cache_entry_t)*uid_cache_used);		uid_cache[uid_cache_used-1] = new_entry;		qsort(uid_cache, uid_cache_used, sizeof(uid_cache_entry_t),		      _uid_compare);		slurm_mutex_unlock(&uid_lock); 		return new_entry.username;	}	slurm_mutex_unlock(&uid_lock); 	return entry->username;}

/* * _opt_default(): used by initialize_and_process_args to set defaults */static void _opt_default(){	static slurm_step_io_fds_t fds = SLURM_STEP_IO_FDS_INITIALIZER;	uid_t uid = getuid();	opt.user = uid_to_string(uid);	if (xstrcmp(opt.user, "nobody") == 0)		fatal("Invalid user id: %u", uid);	opt.uid = uid;	opt.gid = getgid();	opt.progname = NULL;	opt.jobid = NO_VAL;	opt.jobid_set = false;	opt.quiet = 0;	opt.verbose = 0;	opt.euid = (uid_t) -1;	opt.egid = (gid_t) -1;	opt.labelio = false;	opt.ctrl_comm_ifhn  = xshort_hostname();	memcpy(&opt.fds, &fds, sizeof(fds));	opt.layout_only = false;	opt.debugger_test = false;	opt.input_filter = (uint32_t)-1;	opt.input_filter_set = false;	opt.output_filter = (uint32_t)-1;	opt.output_filter_set = false;	opt.error_filter = (uint32_t)-1;	opt.error_filter_set = false;	opt.pty = false;}

//.........这里部分代码省略.........		itr = list_iterator_create(acct_cond->description_list);		while ((object = list_next(itr))) {			if (set)				xstrcat(extra, " || ");			xstrfmtcat(extra, "description='%s'", object);			set = 1;		}		list_iterator_destroy(itr);		xstrcat(extra, ")");	}	if (acct_cond->organization_list	    && list_count(acct_cond->organization_list)) {		set = 0;		xstrcat(extra, " && (");		itr = list_iterator_create(acct_cond->organization_list);		while ((object = list_next(itr))) {			if (set)				xstrcat(extra, " || ");			xstrfmtcat(extra, "organization='%s'", object);			set = 1;		}		list_iterator_destroy(itr);		xstrcat(extra, ")");	}	if (!extra) {		error("Nothing to remove");		return NULL;	}	query = xstrdup_printf("select name from %s %s;", acct_table, extra);	xfree(extra);	if (!(result = mysql_db_query_ret(		      mysql_conn, query, 0))) {		xfree(query);		return NULL;	}	rc = 0;	ret_list = list_create(slurm_destroy_char);	while ((row = mysql_fetch_row(result))) {		char *object = xstrdup(row[0]);		list_append(ret_list, object);		if (!rc) {			xstrfmtcat(name_char, "name='%s'", object);			xstrfmtcat(assoc_char, "t2.acct='%s'", object);			rc = 1;		} else  {			xstrfmtcat(name_char, " || name='%s'", object);			xstrfmtcat(assoc_char, " || t2.acct='%s'", object);		}	}	mysql_free_result(result);	if (!list_count(ret_list)) {		errno = SLURM_NO_CHANGE_IN_DATA;		if (debug_flags & DEBUG_FLAG_DB_ASSOC)			DB_DEBUG(mysql_conn->conn,				 "didn't effect anything/n%s", query);		xfree(query);		return ret_list;	}	xfree(query);	/* We need to remove these accounts from the coord's that have it */	coord_list = as_mysql_remove_coord(		mysql_conn, uid, ret_list, NULL);	if (coord_list)		list_destroy(coord_list);	user_name = uid_to_string((uid_t) uid);	slurm_mutex_lock(&as_mysql_cluster_list_lock);	itr = list_iterator_create(as_mysql_cluster_list);	while ((object = list_next(itr))) {		if ((rc = remove_common(mysql_conn, DBD_REMOVE_ACCOUNTS, now,					user_name, acct_table, name_char,					assoc_char, object, ret_list,					&jobs_running))		    != SLURM_SUCCESS)			break;	}	list_iterator_destroy(itr);	slurm_mutex_unlock(&as_mysql_cluster_list_lock);	xfree(user_name);	xfree(name_char);	xfree(assoc_char);	if (rc == SLURM_ERROR) {		list_destroy(ret_list);		return NULL;	}	if (jobs_running)		errno = ESLURM_JOBS_RUNNING_ON_ASSOC;	else		errno = SLURM_SUCCESS;	return ret_list;}

//.........这里部分代码省略.........	first_bit = bit_ffs(job_ptr->job_resrcs->node_bitmap);	last_bit  = bit_fls(job_ptr->job_resrcs->node_bitmap);	if (first_bit == -1 || last_bit == -1)		return SLURM_SUCCESS;		/* no nodes allocated */	mppdepth = MAX(1, job_ptr->details->cpus_per_task);	mppnppn  = job_ptr->details->ntasks_per_node;	/* mppmem */	if (job_ptr->details->pn_min_memory & MEM_PER_CPU) {		/* Only honour --mem-per-cpu if --ntasks has been given */		if (job_ptr->details->num_tasks)			mppmem = job_ptr->details->pn_min_memory & ~MEM_PER_CPU;	} else if (job_ptr->details->pn_min_memory) {		node_min_mem = job_ptr->details->pn_min_memory;	}	hl = hostlist_create("");	if (hl == NULL)		fatal("hostlist_create: malloc error");	for (i = first_bit; i <= last_bit; i++) {		struct node_record *node_ptr = node_record_table_ptr + i;		uint32_t basil_node_id;		if (!bit_test(job_ptr->job_resrcs->node_bitmap, i))			continue;		if (!node_ptr->name || node_ptr->name[0] == '/0')			continue;	/* bad node */		if (sscanf(node_ptr->name, "nid%05u", &basil_node_id) != 1)			fatal("can not read basil_node_id from %s", node_ptr->name);		if (ns_add_node(&ns_head, basil_node_id) != 0) {			error("can not add node %s (nid%05u)", node_ptr->name,			      basil_node_id);			free_nodespec(ns_head);			return SLURM_ERROR;		}		if (node_min_mem) {			uint32_t node_cpus, node_mem;			if (slurmctld_conf.fast_schedule) {				node_cpus = node_ptr->config_ptr->cpus;				node_mem  = node_ptr->config_ptr->real_memory;			} else {				node_cpus = node_ptr->cpus;				node_mem  = node_ptr->real_memory;			}			/*			 * ALPS 'Processing Elements per Node' value (aprun -N),			 * which in slurm is --ntasks-per-node and 'mppnppn' in			 * PBS: if --ntasks is specified, default to the number			 * of cores per node (also the default for 'aprun -N').			 */			node_mem /= mppnppn ? mppnppn : node_cpus;			mppmem = node_min_mem = MIN(node_mem, node_min_mem);		}	}	/* mppwidth */	for (i = 0; i < job_ptr->job_resrcs->nhosts; i++) {		uint16_t node_tasks = job_ptr->job_resrcs->cpus[i] / mppdepth;		if (mppnppn && mppnppn < node_tasks)			node_tasks = mppnppn;		mppwidth += node_tasks;	}	snprintf(batch_id, sizeof(batch_id), "%u", job_ptr->job_id);	user = uid_to_string(job_ptr->user_id);	rc   = basil_reserve(user, batch_id, mppwidth,			     mppdepth, mppnppn, mppmem, ns_head);	xfree(user);	if (rc <= 0) {		/* errno value will be resolved by select_g_job_begin() */		errno = is_transient_error(rc) ? EAGAIN : ECONNABORTED;		return SLURM_ERROR;	}	resv_id	= rc;	if (_set_select_jobinfo(job_ptr->select_jobinfo->data,			SELECT_JOBDATA_RESV_ID, &resv_id) != SLURM_SUCCESS) {		/*		 * This is a fatal error since it means we will not be able to		 * confirm the reservation; no step will be able to run in it.		 */		error("job %u: can not set resId %u", job_ptr->job_id, resv_id);		basil_release(resv_id);		return SLURM_ERROR;	}	info("ALPS RESERVATION #%u, JobId %u: BASIL -n %d -N %d -d %d -m %d",	     resv_id, job_ptr->job_id, mppwidth, mppnppn, mppdepth, mppmem);	return SLURM_SUCCESS;}

//.........这里部分代码省略.........		}		list_iterator_destroy(itr);		xstrcat(extra, ")");	}	if (acct_cond->description_list	    && list_count(acct_cond->description_list)) {		set = 0;		xstrcat(extra, " && (");		itr = list_iterator_create(acct_cond->description_list);		while ((object = list_next(itr))) {			if (set)				xstrcat(extra, " || ");			xstrfmtcat(extra, "description='%s'", object);			set = 1;		}		list_iterator_destroy(itr);		xstrcat(extra, ")");	}	if (acct_cond->organization_list	    && list_count(acct_cond->organization_list)) {		set = 0;		xstrcat(extra, " && (");		itr = list_iterator_create(acct_cond->organization_list);		while ((object = list_next(itr))) {			if (set)				xstrcat(extra, " || ");			xstrfmtcat(extra, "organization='%s'", object);			set = 1;		}		list_iterator_destroy(itr);		xstrcat(extra, ")");	}	if (acct->description)		xstrfmtcat(vals, ", description='%s'", acct->description);	if (acct->organization)		xstrfmtcat(vals, ", organization='%s'", acct->organization);	if (!extra || !vals) {		errno = SLURM_NO_CHANGE_IN_DATA;		error("Nothing to change");		return NULL;	}	query = xstrdup_printf("select name from %s %s;", acct_table, extra);	xfree(extra);	if (debug_flags & DEBUG_FLAG_DB_ASSOC)		DB_DEBUG(mysql_conn->conn, "query/n%s", query);	if (!(result = mysql_db_query_ret(		      mysql_conn, query, 0))) {		xfree(query);		xfree(vals);		return NULL;	}	rc = 0;	ret_list = list_create(slurm_destroy_char);	while ((row = mysql_fetch_row(result))) {		object = xstrdup(row[0]);		list_append(ret_list, object);		if (!rc) {			xstrfmtcat(name_char, "(name='%s'", object);			rc = 1;		} else  {			xstrfmtcat(name_char, " || name='%s'", object);		}	}	mysql_free_result(result);	if (!list_count(ret_list)) {		errno = SLURM_NO_CHANGE_IN_DATA;		if (debug_flags & DEBUG_FLAG_DB_ASSOC)			DB_DEBUG(mysql_conn->conn,				 "didn't effect anything/n%s", query);		xfree(query);		xfree(vals);		return ret_list;	}	xfree(query);	xstrcat(name_char, ")");	user_name = uid_to_string((uid_t) uid);	rc = modify_common(mysql_conn, DBD_MODIFY_ACCOUNTS, now,			   user_name, acct_table, name_char, vals, NULL);	xfree(user_name);	if (rc == SLURM_ERROR) {		error("Couldn't modify accounts");		list_destroy(ret_list);		errno = SLURM_ERROR;		ret_list = NULL;	}	xfree(name_char);	xfree(vals);	return ret_list;}

extern int as_mysql_add_accts(mysql_conn_t *mysql_conn, uint32_t uid,			      List acct_list){	ListIterator itr = NULL;	int rc = SLURM_SUCCESS;	slurmdb_account_rec_t *object = NULL;	char *cols = NULL, *vals = NULL, *query = NULL, *txn_query = NULL;	time_t now = time(NULL);	char *user_name = NULL;	char *extra = NULL, *tmp_extra = NULL;	int affect_rows = 0;	List assoc_list = list_create(slurmdb_destroy_association_rec);	if (check_connection(mysql_conn) != SLURM_SUCCESS)		return ESLURM_DB_CONNECTION;	user_name = uid_to_string((uid_t) uid);	itr = list_iterator_create(acct_list);	while ((object = list_next(itr))) {		if (!object->name || !object->name[0]		    || !object->description || !object->description[0]		    || !object->organization || !object->organization[0]) {			error("We need an account name, description, and "			      "organization to add. %s %s %s",			      object->name, object->description,			      object->organization);			rc = SLURM_ERROR;			continue;		}		xstrcat(cols, "creation_time, mod_time, name, "			"description, organization");		xstrfmtcat(vals, "%ld, %ld, '%s', '%s', '%s'",			   now, now, object->name,			   object->description, object->organization);		xstrfmtcat(extra, ", description='%s', organization='%s'",			   object->description, object->organization);		query = xstrdup_printf(			"insert into %s (%s) values (%s) "			"on duplicate key update deleted=0, mod_time=%ld %s;",			acct_table, cols, vals,			now, extra);		if (debug_flags & DEBUG_FLAG_DB_ASSOC)			DB_DEBUG(mysql_conn->conn, "query/n%s", query);		rc = mysql_db_query(mysql_conn, query);		xfree(cols);		xfree(vals);		xfree(query);		if (rc != SLURM_SUCCESS) {			error("Couldn't add acct");			xfree(extra);			continue;		}		affect_rows = last_affected_rows(mysql_conn);		/* if (debug_flags & DEBUG_FLAG_DB_ASSOC) */		/* 	DB_DEBUG(mysql_conn->conn, "affected %d", affect_rows); */		if (!affect_rows) {			if (debug_flags & DEBUG_FLAG_DB_ASSOC)				DB_DEBUG(mysql_conn->conn, "nothing changed");			xfree(extra);			continue;		}		/* we always have a ', ' as the first 2 chars */		tmp_extra = slurm_add_slash_to_quotes(extra+2);		if (txn_query)			xstrfmtcat(txn_query,				   ", (%ld, %u, '%s', '%s', '%s')",				   now, DBD_ADD_ACCOUNTS, object->name,				   user_name, tmp_extra);		else			xstrfmtcat(txn_query,				   "insert into %s "				   "(timestamp, action, name, actor, info) "				   "values (%ld, %u, '%s', '%s', '%s')",				   txn_table,				   now, DBD_ADD_ACCOUNTS, object->name,				   user_name, tmp_extra);		xfree(tmp_extra);		xfree(extra);		if (!object->assoc_list)			continue;		list_transfer(assoc_list, object->assoc_list);	}	list_iterator_destroy(itr);	xfree(user_name);	if (rc != SLURM_ERROR) {		if (txn_query) {			xstrcat(txn_query, ";");			rc = mysql_db_query(mysql_conn,					    txn_query);			xfree(txn_query);			if (rc != SLURM_SUCCESS) {				error("Couldn't add txn");//.........这里部分代码省略.........

/* * as_pg_remove_accts - remove accounts * * IN pg_conn: database connection * IN uid: user performing the remove operation * IN acct_cond: accounts to remove * RET: list of accounts removed */extern Listas_pg_remove_accts(pgsql_conn_t *pg_conn, uint32_t uid,		   slurmdb_account_cond_t *acct_cond){	DEF_VARS;	List ret_list = NULL, tmp_list = NULL;	char *user_name = NULL, *cond = NULL, *name_char = NULL,		*assoc_char = NULL;	time_t now = time(NULL);	int rc = SLURM_SUCCESS, has_jobs;	if(!acct_cond) {		error("as/pg: remove_accts: we need something to remove");		return NULL;	}	if (check_db_connection(pg_conn) != SLURM_SUCCESS)		return NULL;	if(acct_cond->assoc_cond)		concat_cond_list(acct_cond->assoc_cond->acct_list,				 NULL, "name", &cond);	concat_cond_list(acct_cond->description_list,			 NULL, "description", &cond);	concat_cond_list(acct_cond->organization_list,			 NULL, "organization", &cond);	if(!cond) {		error("as/pg: remove_accts: nothing to remove");		return NULL;	}	query = xstrdup_printf(		"SELECT name FROM %s WHERE deleted=0 %s;",		acct_table, cond);	xfree(cond);	result = DEF_QUERY_RET;	if(!result)		return NULL;	rc = 0;	ret_list = list_create(slurm_destroy_char);	FOR_EACH_ROW {		char *object = xstrdup(ROW(0));		list_append(ret_list, object);		if(!rc) {			xstrfmtcat(name_char, "name='%s'", object);			xstrfmtcat(assoc_char, "t2.acct='%s'", object);			rc = 1;		} else  {			xstrfmtcat(name_char, " OR name='%s'", object);			xstrfmtcat(assoc_char, " OR t2.acct='%s'", object);		}	} END_EACH_ROW;	PQclear(result);	if(!list_count(ret_list)) {		errno = SLURM_NO_CHANGE_IN_DATA;		debug3("as/pg: remove_accts: didn't effect anything");		return ret_list;	}	/* remove these accounts from the coord's that have it */	tmp_list = acct_storage_p_remove_coord(pg_conn, uid, ret_list, NULL);	if(tmp_list)		list_destroy(tmp_list);	/* if there are running jobs of the accounts, return the jobs */	tmp_list = _get_acct_running_jobs(pg_conn, assoc_char);	if (tmp_list) {		errno = ESLURM_JOBS_RUNNING_ON_ASSOC;		list_destroy(ret_list);		reset_pgsql_conn(pg_conn);		return tmp_list;	}	/* delete recently added accounts */	has_jobs = _acct_has_jobs(pg_conn, assoc_char);	if (! has_jobs ) {		query = xstrdup_printf(			"DELETE FROM %s WHERE creation_time>%d AND (%s);",			acct_table, (int)(now - DELETE_SEC_BACK), name_char);	}	/* mark others as deleted */	xstrfmtcat(query, "UPDATE %s SET mod_time=%ld, deleted=1 "		   "WHERE deleted=0 "		   "AND (%s);", acct_table, (long)now, name_char);	user_name = uid_to_string((uid_t) uid);	xstrfmtcat(query, "INSERT INTO %s (timestamp, action, name, actor) "		   "VALUES (%ld, %d, $$%s$$, '%s');", txn_table, (long)now,		   DBD_REMOVE_ACCOUNTS, name_char, user_name);	xfree(user_name);	rc = DEF_QUERY_RET_RC;	if (rc != SLURM_SUCCESS) {//.........这里部分代码省略.........

/* * as_pg_modify_accounts - modify accounts * * IN pg_conn: database connection * IN uid: user performing the modify operation * IN acct_cond: accounts to modify * IN acct: attribute of accounts after modification * RET: list of accounts modified */extern Listas_pg_modify_accounts(pgsql_conn_t *pg_conn, uint32_t uid,		      slurmdb_account_cond_t *acct_cond,		      slurmdb_account_rec_t *acct){	DEF_VARS;	List ret_list = NULL;	int rc = SLURM_SUCCESS;	char *object = NULL, *user_name = NULL;	char *vals = NULL, *cond = NULL, *name_char = NULL;	time_t now = time(NULL);	if(!acct_cond || !acct) {		error("as/pg: modify_accounts: we need something to change");		return NULL;	}	if (check_db_connection(pg_conn) != SLURM_SUCCESS)		return NULL;	if(acct_cond->assoc_cond)		concat_cond_list(acct_cond->assoc_cond->acct_list,				 NULL, "name", &cond);	concat_cond_list(acct_cond->description_list,			 NULL, "description", &cond);	concat_cond_list(acct_cond->organization_list,			 NULL, "organization", &cond);	if (!cond) {		errno = SLURM_NO_CHANGE_IN_DATA;		error("as/pg: modify_accounts: no condition given");		return NULL;	}	if(acct->description)		xstrfmtcat(vals, ", description='%s'", acct->description);	if(acct->organization)		xstrfmtcat(vals, ", organization='%s'", acct->organization);	if(!vals) {		xfree(cond);		errno = SLURM_NO_CHANGE_IN_DATA;		error("as/pg: modify_accounts: no new values given");		return NULL;	}	query = xstrdup_printf("SELECT name FROM %s WHERE deleted=0 %s;",			       acct_table, cond);	xfree(cond);	result = DEF_QUERY_RET;	if(!result) {		xfree(vals);		return NULL;	}	rc = 0;	ret_list = list_create(slurm_destroy_char);	FOR_EACH_ROW {		object = xstrdup(ROW(0));		list_append(ret_list, object);		if(!rc) {			xstrfmtcat(name_char, "(name='%s'", object);			rc = 1;		} else  {			xstrfmtcat(name_char, " OR name='%s'", object);		}	} END_EACH_ROW;	PQclear(result);	if(!list_count(ret_list)) {		errno = SLURM_NO_CHANGE_IN_DATA;		debug3("as/pg: modify_accounts: didn't effect anything");		xfree(vals);		return ret_list;	}	xstrcat(name_char, ")");	user_name = uid_to_string((uid_t) uid);	rc = pgsql_modify_common(pg_conn, DBD_MODIFY_ACCOUNTS, now, "",				 user_name, acct_table, name_char, vals);	xfree(user_name);	xfree(name_char);	xfree(vals);	if (rc == SLURM_ERROR) {		error("as/pg: couldn't modify accounts");		list_destroy(ret_list);		errno = SLURM_ERROR;		ret_list = NULL;	}	return ret_list;}

/* * as_pg_add_accts - add accounts * * IN pg_conn: database connection * IN uid: user performing the add operation * IN acct_list: accounts to add * RET: error code */extern intas_pg_add_accts(pgsql_conn_t *pg_conn, uint32_t uid, List acct_list){	ListIterator itr = NULL;	slurmdb_account_rec_t *object = NULL;	List assoc_list = NULL;	int rc = SLURM_SUCCESS;	char *user_name = NULL, *query = NULL, *txn_query = NULL;	char *rec = NULL, *info = NULL;	time_t now = time(NULL);	if (check_db_connection(pg_conn) != SLURM_SUCCESS)		return ESLURM_DB_CONNECTION;	assoc_list = list_create(slurmdb_destroy_association_rec);	user_name = uid_to_string((uid_t) uid);	itr = list_iterator_create(acct_list);	while((object = list_next(itr))) {		if(!object->name || !object->description		   || !object->organization) {			error("as/pg: add_accts: We need an account name, "			      "description, and organization to add. %s %s %s",			      object->name, object->description,			      object->organization);			rc = SLURM_ERROR;			continue;		}		/* order of vals must match structure of acct_table */		rec = xstrdup_printf("(%ld, %ld, 0, '%s', '%s', '%s')", now,				     now, object->name, object->description,				     object->organization);		query = xstrdup_printf("SELECT public.add_acct(%s);", rec);		xfree(rec);		rc = DEF_QUERY_RET_RC;		if(rc != SLURM_SUCCESS) {			error("as/pg: couldn't add acct %s", object->name);			continue;		}		info = xstrdup_printf("description='%s', organization='%s'",				      object->description,				      object->organization);		if(txn_query)			xstrfmtcat(txn_query,				   ", (%ld, %u, '%s', '%s', $$%s$$)",				   now, DBD_ADD_ACCOUNTS, object->name,				   user_name, info);		else			xstrfmtcat(txn_query,				   "INSERT INTO %s "				   "(timestamp, action, name, actor, info) "				   "VALUES (%ld, %u, '%s', '%s', $$%s$$)",				   txn_table,				   now, DBD_ADD_ACCOUNTS, object->name,				   user_name, info);		xfree(info);		if(!object->assoc_list)			continue;		list_transfer(assoc_list, object->assoc_list);	}	list_iterator_destroy(itr);	xfree(user_name);	if(rc == SLURM_SUCCESS) {		if(txn_query) {			xstrcat(txn_query, ";");			rc = pgsql_db_query(pg_conn->db_conn, txn_query);			xfree(txn_query);			if(rc != SLURM_SUCCESS) {				error("as/pg: add_accts: couldn't add txn");				rc = SLURM_SUCCESS;			}		}	} else		xfree(txn_query);	if(rc == SLURM_SUCCESS && list_count(assoc_list)) {		if(acct_storage_p_add_associations(pg_conn, uid, assoc_list)		   != SLURM_SUCCESS) {			error("as/pg: add_accts: problem adding account "			      "associations");			rc = SLURM_ERROR;		}	}	list_destroy(assoc_list);	return rc;}