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;
}
static void _layout_conf_dbd(GtkTreeStore *treestore)
{
ListIterator itr = NULL;
GtkTreeIter iter;
config_key_pair_t *key_pair;
int update = 0;
time_t now = time(NULL);
char tmp_str[128], *user_name = NULL;
List dbd_config_list = NULL;
/* first load accounting parms from slurm.conf */
char *acct_storage_backup_host =
slurm_get_accounting_storage_backup_host();
char *acct_storage_host = slurm_get_accounting_storage_host();
char *acct_storage_loc = slurm_get_accounting_storage_loc();
char *acct_storage_pass = slurm_get_accounting_storage_pass();
uint32_t acct_storage_port = slurm_get_accounting_storage_port();
char *acct_storage_type = slurm_get_accounting_storage_type();
char *acct_storage_user = slurm_get_accounting_storage_user();
char *auth_type = slurm_get_auth_type();
uint16_t msg_timeout = slurm_get_msg_timeout();
char *plugin_dir = slurm_get_plugin_dir();
uint16_t private_data = slurm_get_private_data();
uint32_t slurm_user_id = slurm_get_slurm_user_id();
uint16_t track_wckey = slurm_get_track_wckey();
slurm_make_time_str(&now, tmp_str, sizeof(tmp_str));
add_display_treestore_line_with_font(
update, treestore, &iter,
"SLURM Configuration data as of", tmp_str, "bold");
add_display_treestore_line(update, treestore, &iter,
"AccountingStorageBackupHost",
acct_storage_backup_host);
add_display_treestore_line(update, treestore, &iter,
"AccountingStorageHost", acct_storage_host);
add_display_treestore_line(update, treestore, &iter,
"AccountingStorageLoc", acct_storage_loc);
add_display_treestore_line(update, treestore, &iter,
"AccountingStoragePass", acct_storage_pass);
sprintf(tmp_str, "%u", acct_storage_port);
add_display_treestore_line(update, treestore, &iter,
"AccountingStoragePort", tmp_str);
add_display_treestore_line(update, treestore, &iter,
"AccountingStorageType", acct_storage_type);
add_display_treestore_line(update, treestore, &iter,
"AccountingStorageUser", acct_storage_user);
add_display_treestore_line(update, treestore, &iter,
"AuthType", auth_type);
sprintf(tmp_str, "%u sec", msg_timeout);
add_display_treestore_line(update, treestore, &iter,
"MessageTimeout", tmp_str);
add_display_treestore_line(update, treestore, &iter,
"PluginDir", plugin_dir);
private_data_string(private_data, tmp_str, sizeof(tmp_str));
add_display_treestore_line(update, treestore, &iter,
"PrivateData", tmp_str);
user_name = uid_to_string(slurm_user_id);
sprintf(tmp_str, "%s(%u)", user_name, slurm_user_id);
xfree(user_name);
add_display_treestore_line(update, treestore, &iter,
"SlurmUserId", tmp_str);
add_display_treestore_line(update, treestore, &iter,
"SLURM_CONF", default_slurm_config_file);
add_display_treestore_line(update, treestore, &iter,
"SLURM_VERSION", SLURM_VERSION_STRING);
sprintf(tmp_str, "%u", track_wckey);
add_display_treestore_line(update, treestore, &iter,
"TrackWCKey", tmp_str);
xfree(acct_storage_backup_host);
xfree(acct_storage_host);
xfree(acct_storage_loc);
xfree(acct_storage_pass);
xfree(acct_storage_type);
xfree(acct_storage_user);
xfree(auth_type);
xfree(plugin_dir);
/* now load accounting parms from slurmdbd.conf */
/* second load slurmdbd.conf parms */
if (!(dbd_config_list = slurmdb_config_get(NULL)))
return;
add_display_treestore_line_with_font(
update, treestore, &iter,
"\nSlurmDBD Configuration:", NULL, "bold");
itr = list_iterator_create(dbd_config_list);
while ((key_pair = list_next(itr))) {
add_display_treestore_line(update, treestore, &iter,
key_pair->name,
key_pair->value);
}
list_iterator_destroy(itr);
}
extern List as_mysql_remove_accts(mysql_conn_t *mysql_conn, uint32_t uid,
slurmdb_account_cond_t *acct_cond)
{
ListIterator itr = NULL;
List ret_list = NULL;
List coord_list = NULL;
int rc = SLURM_SUCCESS;
char *object = NULL;
char *extra = NULL, *query = NULL,
*name_char = NULL, *assoc_char = NULL;
time_t now = time(NULL);
char *user_name = NULL;
int set = 0;
MYSQL_RES *result = NULL;
MYSQL_ROW row;
bool jobs_running = 0;
if (!acct_cond) {
error("we need something to change");
return NULL;
}
if (check_connection(mysql_conn) != SLURM_SUCCESS)
return NULL;
xstrcat(extra, "where deleted=0");
if (acct_cond->assoc_cond
&& acct_cond->assoc_cond->acct_list
&& list_count(acct_cond->assoc_cond->acct_list)) {
set = 0;
xstrcat(extra, " && (");
itr = list_iterator_create(acct_cond->assoc_cond->acct_list);
while ((object = list_next(itr))) {
if (!object[0])
continue;
if (set)
xstrcat(extra, " || ");
xstrfmtcat(extra, "name='%s'", object);
set = 1;
}
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 (!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;
}
/**
* do_basil_reserve - create a BASIL reservation.
* IN job_ptr - pointer to job which has just been allocated resources
* RET 0 or error code, job will abort or be requeued on failure
*/
extern int do_basil_reserve(struct job_record *job_ptr)
{
struct nodespec *ns_head = NULL;
uint16_t mppwidth = 0, mppdepth, mppnppn;
uint32_t mppmem = 0, node_min_mem = 0;
uint32_t resv_id;
int i, first_bit, last_bit;
hostlist_t hl;
long rc;
char *user, batch_id[16];
if (!job_ptr->job_resrcs || job_ptr->job_resrcs->nhosts == 0)
return SLURM_SUCCESS;
debug3("job #%u: %u nodes = %s, cpus=%u" , job_ptr->job_id,
job_ptr->job_resrcs->nhosts,
job_ptr->job_resrcs->nodes,
job_ptr->job_resrcs->ncpus
);
if (job_ptr->job_resrcs->node_bitmap == NULL) {
error("job %u node_bitmap not set", job_ptr->job_id);
return SLURM_SUCCESS;
}
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;
}
extern List as_mysql_modify_accts(mysql_conn_t *mysql_conn, uint32_t uid,
slurmdb_account_cond_t *acct_cond,
slurmdb_account_rec_t *acct)
{
ListIterator itr = NULL;
List ret_list = NULL;
int rc = SLURM_SUCCESS;
char *object = NULL;
char *vals = NULL, *extra = NULL, *query = NULL, *name_char = NULL;
time_t now = time(NULL);
char *user_name = NULL;
int set = 0;
MYSQL_RES *result = NULL;
MYSQL_ROW row;
if (!acct_cond || !acct) {
error("we need something to change");
return NULL;
}
if (check_connection(mysql_conn) != SLURM_SUCCESS)
return NULL;
xstrcat(extra, "where deleted=0");
if (acct_cond->assoc_cond
&& acct_cond->assoc_cond->acct_list
&& list_count(acct_cond->assoc_cond->acct_list)) {
set = 0;
xstrcat(extra, " && (");
itr = list_iterator_create(acct_cond->assoc_cond->acct_list);
while ((object = list_next(itr))) {
if (set)
xstrcat(extra, " || ");
xstrfmtcat(extra, "name='%s'", object);
set = 1;
}
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");
rc = SLURM_SUCCESS;
}
}
} else
xfree(txn_query);
if (list_count(assoc_list)) {
if (as_mysql_add_assocs(mysql_conn, uid, assoc_list)
== SLURM_ERROR) {
error("Problem adding user associations");
rc = SLURM_ERROR;
}
}
list_destroy(assoc_list);
return rc;
}
/*
* 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 List
as_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) {
reset_pgsql_conn(pg_conn);
list_destroy(ret_list);
ret_list = NULL;
goto out;
}
/* TODO: this may leave sub-accts without assoc */
/* handle associations */
FOR_EACH_CLUSTER(NULL) {
rc = _cluster_remove_acct_assoc(pg_conn, cluster_name,
now, assoc_char, has_jobs);
if (rc != SLURM_SUCCESS)
break;
} END_EACH_CLUSTER;
if (rc != SLURM_SUCCESS) {
reset_pgsql_conn(pg_conn);
list_destroy(ret_list);
ret_list = NULL;
}
out:
xfree(name_char);
xfree(assoc_char);
return ret_list;
}
/*
* 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 List
as_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 int
as_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;
}