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;
}
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;
}
extern int as_mysql_add_federations(mysql_conn_t *mysql_conn, uint32_t uid,
List federation_list)
{
ListIterator itr = NULL;
int rc = SLURM_SUCCESS;
slurmdb_federation_rec_t *object = NULL;
char *cols = NULL, *vals = NULL, *extra = NULL, *query = NULL,
*tmp_extra = NULL;
time_t now = time(NULL);
char *user_name = NULL;
int affect_rows = 0;
int added = 0;
if (check_connection(mysql_conn) != SLURM_SUCCESS)
return ESLURM_DB_CONNECTION;
if (!is_user_min_admin_level(mysql_conn, uid, SLURMDB_ADMIN_SUPER_USER))
return ESLURM_ACCESS_DENIED;
user_name = uid_to_string((uid_t) uid);
itr = list_iterator_create(federation_list);
while ((object = list_next(itr))) {
if (object->cluster_list &&
(list_count(federation_list) > 1)) {
xfree(user_name);
error("Clusters can only be assigned to one "
"federation");
errno = ESLURM_FED_CLUSTER_MULTIPLE_ASSIGNMENT;
return ESLURM_FED_CLUSTER_MULTIPLE_ASSIGNMENT;
}
xstrcat(cols, "creation_time, mod_time, name");
xstrfmtcat(vals, "%ld, %ld, '%s'", now, now, object->name);
xstrfmtcat(extra, ", mod_time=%ld", now);
_setup_federation_rec_limits(object, &cols, &vals, &extra);
xstrfmtcat(query,
"insert into %s (%s) values (%s) "
"on duplicate key update deleted=0%s",
federation_table, cols, vals, extra);
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 != SLURM_SUCCESS) {
error("Couldn't add federation %s", object->name);
xfree(cols);
xfree(vals);
xfree(extra);
added = 0;
break;
}
affect_rows = last_affected_rows(mysql_conn);
if (!affect_rows) {
debug2("nothing changed %d", affect_rows);
xfree(cols);
xfree(vals);
xfree(extra);
continue;
}
if (object->cluster_list &&
_assign_clusters_to_federation(mysql_conn, object->name,
object->cluster_list)) {
xfree(cols);
xfree(vals);
xfree(extra);
xfree(user_name);
return SLURM_ERROR;
}
/* Add Transaction */
/* we always have a ', ' as the first 2 chars */
tmp_extra = slurm_add_slash_to_quotes(extra+2);
xstrfmtcat(query,
"insert into %s "
"(timestamp, action, name, actor, info) "
"values (%ld, %u, '%s', '%s', '%s');",
txn_table, now, DBD_ADD_FEDERATIONS,
object->name, user_name, tmp_extra);
xfree(cols);
xfree(vals);
xfree(tmp_extra);
xfree(extra);
debug4("%d(%s:%d) query\n%s",
mysql_conn->conn, THIS_FILE, __LINE__, query);
rc = mysql_db_query(mysql_conn, query);
xfree(query);
if (rc != SLURM_SUCCESS) {
error("Couldn't add txn");
} else {
added++;
}
}
list_iterator_destroy(itr);
xfree(user_name);
if (!added)
reset_mysql_conn(mysql_conn);
else
as_mysql_add_feds_to_update_list(mysql_conn);
return rc;
}
extern List as_mysql_remove_clusters(mysql_conn_t *mysql_conn, uint32_t uid,
slurmdb_cluster_cond_t *cluster_cond)
{
ListIterator itr = NULL;
List ret_list = NULL;
List tmp_list = NULL;
int rc = SLURM_SUCCESS;
char *object = NULL;
char *extra = NULL, *query = NULL, *cluster_name = NULL,
*name_char = NULL, *assoc_char = NULL;
time_t now = time(NULL);
char *user_name = NULL;
slurmdb_wckey_cond_t wckey_cond;
MYSQL_RES *result = NULL;
MYSQL_ROW row;
bool jobs_running = 0;
if (!cluster_cond) {
error("we need something to change");
return NULL;
}
if (check_connection(mysql_conn) != SLURM_SUCCESS)
return NULL;
if (!is_user_min_admin_level(
mysql_conn, uid, SLURMDB_ADMIN_SUPER_USER)) {
errno = ESLURM_ACCESS_DENIED;
return NULL;
}
/* force to only do non-deleted clusters */
cluster_cond->with_deleted = 0;
_setup_cluster_cond_limits(cluster_cond, &extra);
if (!extra) {
error("Nothing to remove");
return NULL;
}
query = xstrdup_printf("select name from %s%s;", cluster_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);
if (!mysql_num_rows(result)) {
mysql_free_result(result);
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);
assoc_char = xstrdup_printf("t2.acct='root'");
user_name = uid_to_string((uid_t) uid);
while ((row = mysql_fetch_row(result))) {
char *object = xstrdup(row[0]);
if (!jobs_running)
list_append(ret_list, object);
xfree(name_char);
xstrfmtcat(name_char, "name='%s'", object);
if (jobs_running)
xfree(object);
/* We should not need to delete any cluster usage just set it
* to deleted */
xstrfmtcat(query,
"update \"%s_%s\" set time_end=%ld where time_end=0;"
"update \"%s_%s\" set mod_time=%ld, deleted=1;"
"update \"%s_%s\" set mod_time=%ld, deleted=1;"
"update \"%s_%s\" set mod_time=%ld, deleted=1;",
object, event_table, now,
object, cluster_day_table, now,
object, cluster_hour_table, now,
object, cluster_month_table, now);
if ((rc = remove_common(mysql_conn, DBD_REMOVE_CLUSTERS, now,
user_name, cluster_table,
name_char, assoc_char, object,
ret_list, &jobs_running))
!= SLURM_SUCCESS)
break;
}
mysql_free_result(result);
xfree(user_name);
xfree(name_char);
xfree(assoc_char);
if (rc != SLURM_SUCCESS) {
FREE_NULL_LIST(ret_list);
return NULL;
}
if (!jobs_running) {
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);
FREE_NULL_LIST(ret_list);
return NULL;
}
/* We need to remove these clusters from the wckey table */
memset(&wckey_cond, 0, sizeof(slurmdb_wckey_cond_t));
wckey_cond.cluster_list = ret_list;
tmp_list = as_mysql_remove_wckeys(mysql_conn, uid, &wckey_cond);
FREE_NULL_LIST(tmp_list);
itr = list_iterator_create(ret_list);
while ((object = list_next(itr))) {
if ((rc = remove_cluster_tables(mysql_conn, object))
!= SLURM_SUCCESS)
break;
cluster_name = xstrdup(object);
if (addto_update_list(mysql_conn->update_list,
SLURMDB_REMOVE_CLUSTER,
cluster_name) != SLURM_SUCCESS)
xfree(cluster_name);
}
list_iterator_destroy(itr);
if (rc != SLURM_SUCCESS) {
reset_mysql_conn(mysql_conn);
FREE_NULL_LIST(ret_list);
errno = rc;
return NULL;
}
errno = SLURM_SUCCESS;
} else
errno = ESLURM_JOBS_RUNNING_ON_ASSOC;
return ret_list;
}
extern int as_mysql_add_clusters(mysql_conn_t *mysql_conn, uint32_t uid,
List cluster_list)
{
ListIterator itr = NULL;
int rc = SLURM_SUCCESS;
slurmdb_cluster_rec_t *object = NULL;
char *cols = NULL, *vals = NULL, *extra = NULL,
*query = NULL, *tmp_extra = NULL;
time_t now = time(NULL);
char *user_name = NULL;
int affect_rows = 0;
int added = 0;
List assoc_list = NULL;
slurmdb_assoc_rec_t *assoc = NULL;
if (check_connection(mysql_conn) != SLURM_SUCCESS)
return ESLURM_DB_CONNECTION;
if (!is_user_min_admin_level(mysql_conn, uid, SLURMDB_ADMIN_SUPER_USER))
return ESLURM_ACCESS_DENIED;
assoc_list = list_create(slurmdb_destroy_assoc_rec);
user_name = uid_to_string((uid_t) uid);
/* Since adding tables make it so you can't roll back, if
there is an error there is no way to easily remove entries
in the database, so we will create the tables first and
then after that works out then add them to the mix.
*/
itr = list_iterator_create(cluster_list);
while ((object = list_next(itr))) {
if (!object->name || !object->name[0]) {
error("We need a cluster name to add.");
rc = SLURM_ERROR;
list_remove(itr);
continue;
}
if ((rc = create_cluster_tables(mysql_conn,
object->name))
!= SLURM_SUCCESS) {
xfree(extra);
xfree(cols);
xfree(vals);
added = 0;
if (mysql_errno(mysql_conn->db_conn)
== ER_WRONG_TABLE_NAME)
rc = ESLURM_BAD_NAME;
goto end_it;
}
}
/* Now that all the tables were created successfully lets go
ahead and add it to the system.
*/
list_iterator_reset(itr);
while ((object = list_next(itr))) {
xstrcat(cols, "creation_time, mod_time, acct");
xstrfmtcat(vals, "%ld, %ld, 'root'", now, now);
xstrfmtcat(extra, ", mod_time=%ld", now);
if (object->root_assoc)
setup_assoc_limits(object->root_assoc, &cols,
&vals, &extra,
QOS_LEVEL_SET, 1);
xstrfmtcat(query,
"insert into %s (creation_time, mod_time, "
"name, classification) "
"values (%ld, %ld, '%s', %u) "
"on duplicate key update deleted=0, mod_time=%ld, "
"control_host='', control_port=0, "
"classification=%u, flags=0",
cluster_table,
now, now, object->name, object->classification,
now, object->classification);
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) {
error("Couldn't add cluster %s", object->name);
xfree(extra);
xfree(cols);
xfree(vals);
added=0;
break;
}
affect_rows = last_affected_rows(mysql_conn);
if (!affect_rows) {
debug2("nothing changed %d", affect_rows);
xfree(extra);
xfree(cols);
xfree(vals);
continue;
}
xstrfmtcat(query,
"insert into \"%s_%s\" (%s, lft, rgt) "
"values (%s, 1, 2) "
"on duplicate key update deleted=0, "
"id_assoc=LAST_INSERT_ID(id_assoc)%s;",
object->name, assoc_table, cols,
vals,
extra);
xfree(cols);
xfree(vals);
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) {
error("Couldn't add cluster root assoc");
xfree(extra);
added=0;
break;
}
/* we always have a ', ' as the first 2 chars */
tmp_extra = slurm_add_slash_to_quotes(extra+2);
xstrfmtcat(query,
"insert into %s "
"(timestamp, action, name, actor, info) "
"values (%ld, %u, '%s', '%s', '%s');",
txn_table, now, DBD_ADD_CLUSTERS,
object->name, user_name, tmp_extra);
xfree(tmp_extra);
xfree(extra);
debug4("%d(%s:%d) query\n%s",
mysql_conn->conn, THIS_FILE, __LINE__, query);
rc = mysql_db_query(mysql_conn, query);
xfree(query);
if (rc != SLURM_SUCCESS) {
error("Couldn't add txn");
} else {
ListIterator check_itr;
char *tmp_name;
added++;
/* add it to the list and sort */
slurm_mutex_lock(&as_mysql_cluster_list_lock);
check_itr = list_iterator_create(as_mysql_cluster_list);
while ((tmp_name = list_next(check_itr))) {
if (!strcmp(tmp_name, object->name))
break;
}
list_iterator_destroy(check_itr);
if (!tmp_name) {
list_append(as_mysql_cluster_list,
xstrdup(object->name));
list_sort(as_mysql_cluster_list,
(ListCmpF)slurm_sort_char_list_asc);
} else
error("Cluster %s(%s) appears to already be in "
"our cache list, not adding.", tmp_name,
object->name);
slurm_mutex_unlock(&as_mysql_cluster_list_lock);
}
/* Add user root by default to run from the root
* association. This gets popped off so we need to
* read it every time here.
*/
assoc = xmalloc(sizeof(slurmdb_assoc_rec_t));
slurmdb_init_assoc_rec(assoc, 0);
list_append(assoc_list, assoc);
assoc->cluster = xstrdup(object->name);
assoc->user = xstrdup("root");
assoc->acct = xstrdup("root");
assoc->is_def = 1;
if (as_mysql_add_assocs(mysql_conn, uid, assoc_list)
== SLURM_ERROR) {
error("Problem adding root user association");
rc = SLURM_ERROR;
}
}
end_it:
list_iterator_destroy(itr);
xfree(user_name);
FREE_NULL_LIST(assoc_list);
if (!added)
reset_mysql_conn(mysql_conn);
return rc;
}
extern List as_mysql_get_resvs(mysql_conn_t *mysql_conn, uid_t uid,
slurmdb_reservation_cond_t *resv_cond)
{
//DEF_TIMERS;
char *query = NULL;
char *extra = NULL;
char *tmp = NULL;
List resv_list = NULL;
int i=0, is_admin=1;
MYSQL_RES *result = NULL;
MYSQL_ROW row;
uint16_t private_data = 0;
slurmdb_job_cond_t job_cond;
void *curr_cluster = NULL;
List local_cluster_list = NULL;
List use_cluster_list = as_mysql_cluster_list;
ListIterator itr = NULL;
char *cluster_name = NULL;
/* needed if we don't have an resv_cond */
uint16_t with_usage = 0;
/* if this changes you will need to edit the corresponding enum */
char *resv_req_inx[] = {
"id_resv",
"assoclist",
"flags",
"nodelist",
"node_inx",
"resv_name",
"time_start",
"time_end",
"tres"
};
enum {
RESV_REQ_ID,
RESV_REQ_ASSOCS,
RESV_REQ_FLAGS,
RESV_REQ_NODES,
RESV_REQ_NODE_INX,
RESV_REQ_NAME,
RESV_REQ_START,
RESV_REQ_END,
RESV_REQ_TRES,
RESV_REQ_COUNT
};
if (!resv_cond) {
xstrcat(extra, " where deleted=0");
goto empty;
}
if (check_connection(mysql_conn) != SLURM_SUCCESS)
return NULL;
private_data = slurm_get_private_data();
if (private_data & PRIVATE_DATA_RESERVATIONS) {
if (!(is_admin = is_user_min_admin_level(
mysql_conn, uid, SLURMDB_ADMIN_OPERATOR))) {
error("Only admins can look at reservations");
errno = ESLURM_ACCESS_DENIED;
return NULL;
}
}
memset(&job_cond, 0, sizeof(slurmdb_job_cond_t));
if (resv_cond->nodes) {
job_cond.usage_start = resv_cond->time_start;
job_cond.usage_end = resv_cond->time_end;
job_cond.used_nodes = resv_cond->nodes;
job_cond.cluster_list = resv_cond->cluster_list;
local_cluster_list = setup_cluster_list_with_inx(
mysql_conn, &job_cond, (void **)&curr_cluster);
} else if (with_usage) {
job_cond.usage_start = resv_cond->time_start;
job_cond.usage_end = resv_cond->time_end;
}
(void) _setup_resv_cond_limits(resv_cond, &extra);
with_usage = resv_cond->with_usage;
if (resv_cond->cluster_list && list_count(resv_cond->cluster_list))
use_cluster_list = resv_cond->cluster_list;
empty:
xfree(tmp);
xstrfmtcat(tmp, "t1.%s", resv_req_inx[i]);
for(i=1; i<RESV_REQ_COUNT; i++) {
xstrfmtcat(tmp, ", t1.%s", resv_req_inx[i]);
}
if (use_cluster_list == as_mysql_cluster_list)
slurm_mutex_lock(&as_mysql_cluster_list_lock);
itr = list_iterator_create(use_cluster_list);
while ((cluster_name = list_next(itr))) {
if (query)
xstrcat(query, " union ");
//START_TIMER;
xstrfmtcat(query, "select distinct %s,'%s' as cluster "
"from \"%s_%s\" as t1%s",
tmp, cluster_name, cluster_name, resv_table,
extra ? extra : "");
}
list_iterator_destroy(itr);
if (use_cluster_list == as_mysql_cluster_list)
slurm_mutex_unlock(&as_mysql_cluster_list_lock);
if (query)
xstrcat(query, " order by cluster, resv_name;");
xfree(tmp);
xfree(extra);
if (debug_flags & DEBUG_FLAG_DB_RESV)
DB_DEBUG(mysql_conn->conn, "query\n%s", query);
if (!(result = mysql_db_query_ret(mysql_conn, query, 0))) {
xfree(query);
FREE_NULL_LIST(local_cluster_list);
return NULL;
}
xfree(query);
resv_list = list_create(slurmdb_destroy_reservation_rec);
while ((row = mysql_fetch_row(result))) {
slurmdb_reservation_rec_t *resv =
xmalloc(sizeof(slurmdb_reservation_rec_t));
int start = slurm_atoul(row[RESV_REQ_START]);
list_append(resv_list, resv);
if (!good_nodes_from_inx(local_cluster_list, &curr_cluster,
row[RESV_REQ_NODE_INX], start))
continue;
resv->id = slurm_atoul(row[RESV_REQ_ID]);
if (with_usage) {
if (!job_cond.resvid_list)
job_cond.resvid_list = list_create(NULL);
list_append(job_cond.resvid_list, row[RESV_REQ_ID]);
}
resv->name = xstrdup(row[RESV_REQ_NAME]);
resv->cluster = xstrdup(row[RESV_REQ_COUNT]);
resv->assocs = xstrdup(row[RESV_REQ_ASSOCS]);
resv->nodes = xstrdup(row[RESV_REQ_NODES]);
resv->time_start = start;
resv->time_end = slurm_atoul(row[RESV_REQ_END]);
resv->flags = slurm_atoul(row[RESV_REQ_FLAGS]);
resv->tres_str = xstrdup(row[RESV_REQ_TRES]);
}
FREE_NULL_LIST(local_cluster_list);
if (with_usage && resv_list && list_count(resv_list)) {
List job_list = as_mysql_jobacct_process_get_jobs(
mysql_conn, uid, &job_cond);
ListIterator itr = NULL, itr2 = NULL;
slurmdb_job_rec_t *job = NULL;
slurmdb_reservation_rec_t *resv = NULL;
if (!job_list || !list_count(job_list))
goto no_jobs;
itr = list_iterator_create(job_list);
itr2 = list_iterator_create(resv_list);
while ((job = list_next(itr))) {
int start = job->start;
int end = job->end;
int set = 0;
while ((resv = list_next(itr2))) {
int elapsed = 0;
/* since a reservation could have
changed while a job was running we
have to make sure we get the time
in the correct record.
*/
if (resv->id != job->resvid)
continue;
set = 1;
if (start < resv->time_start)
start = resv->time_start;
if (!end || end > resv->time_end)
end = resv->time_end;
if ((elapsed = (end - start)) < 1)
continue;
slurmdb_transfer_tres_time(
&resv->tres_list, job->tres_alloc_str,
elapsed);
}
list_iterator_reset(itr2);
if (!set) {
error("we got a job %u with no reservation "
"associatied with it?", job->jobid);
}
}
list_iterator_destroy(itr2);
list_iterator_destroy(itr);
no_jobs:
FREE_NULL_LIST(job_list);
}
FREE_NULL_LIST(job_cond.resvid_list);
/* free result after we use the list with resv id's in it. */
mysql_free_result(result);
//END_TIMER2("get_resvs");
return resv_list;
}
extern List as_mysql_get_users(mysql_conn_t *mysql_conn, uid_t uid,
slurmdb_user_cond_t *user_cond)
{
char *query = NULL;
char *extra = NULL;
char *tmp = NULL;
List user_list = NULL;
ListIterator itr = NULL;
char *object = NULL;
int set = 0;
int i=0, is_admin=1;
MYSQL_RES *result = NULL;
MYSQL_ROW row;
uint16_t private_data = 0;
slurmdb_user_rec_t user;
/* if this changes you will need to edit the corresponding enum */
char *user_req_inx[] = {
"name",
"admin_level"
};
enum {
USER_REQ_NAME,
USER_REQ_AL,
USER_REQ_COUNT
};
if (check_connection(mysql_conn) != SLURM_SUCCESS)
return NULL;
memset(&user, 0, sizeof(slurmdb_user_rec_t));
user.uid = uid;
private_data = slurm_get_private_data();
if (private_data & PRIVATE_DATA_USERS) {
if (!(is_admin = is_user_min_admin_level(
mysql_conn, uid, SLURMDB_ADMIN_OPERATOR))) {
assoc_mgr_fill_in_user(
mysql_conn, &user, 1, NULL);
}
if (!is_admin && !user.name) {
debug("User %u has no assocations, and is not admin, "
"so not returning any users.", user.uid);
return NULL;
}
}
if (!user_cond) {
xstrcat(extra, "where deleted=0");
set = 1;
goto empty;
}
if (user_cond->with_deleted)
xstrcat(extra, "where (deleted=0 || deleted=1)");
else
xstrcat(extra, "where deleted=0");
user_list = _get_other_user_names_to_mod(mysql_conn, uid, user_cond);
if (user_list) {
if (!user_cond->assoc_cond)
user_cond->assoc_cond =
xmalloc(sizeof(slurmdb_association_rec_t));
if (!user_cond->assoc_cond->user_list)
user_cond->assoc_cond->user_list = user_list;
else {
list_transfer(user_cond->assoc_cond->user_list,
user_list);
list_destroy(user_list);
}
user_list = NULL;
} else if ((user_cond->def_acct_list
&& list_count(user_cond->def_acct_list))
|| (user_cond->def_wckey_list
&& list_count(user_cond->def_wckey_list)))
return NULL;
if (user_cond->assoc_cond &&
user_cond->assoc_cond->user_list
&& list_count(user_cond->assoc_cond->user_list)) {
set = 0;
xstrcat(extra, " && (");
itr = list_iterator_create(user_cond->assoc_cond->user_list);
while ((object = list_next(itr))) {
if (set)
xstrcat(extra, " || ");
xstrfmtcat(extra, "name='%s'", object);
set = 1;
}
list_iterator_destroy(itr);
xstrcat(extra, ")");
}
if (user_cond->admin_level != SLURMDB_ADMIN_NOTSET) {
xstrfmtcat(extra, " && admin_level=%u",
user_cond->admin_level);
set = 1;
}
empty:
/* This is here to make sure we are looking at only this user
* if this flag is set.
*/
if (!is_admin && (private_data & PRIVATE_DATA_USERS)) {
xstrfmtcat(extra, " && name='%s'", user.name);
}
xfree(tmp);
xstrfmtcat(tmp, "%s", user_req_inx[0]);
for(i=1; i<USER_REQ_COUNT; i++) {
xstrfmtcat(tmp, ", %s", user_req_inx[i]);
}
query = xstrdup_printf("select %s from %s %s", tmp, user_table, extra);
xfree(tmp);
xfree(extra);
debug3("%d(%s:%d) query\n%s",
mysql_conn->conn, THIS_FILE, __LINE__, query);
if (!(result = mysql_db_query_ret(
mysql_conn, query, 0))) {
xfree(query);
return NULL;
}
xfree(query);
user_list = list_create(slurmdb_destroy_user_rec);
while ((row = mysql_fetch_row(result))) {
slurmdb_user_rec_t *user = xmalloc(sizeof(slurmdb_user_rec_t));
list_append(user_list, user);
user->name = xstrdup(row[USER_REQ_NAME]);
user->admin_level = slurm_atoul(row[USER_REQ_AL]);
if (user_cond && user_cond->with_coords)
_get_user_coords(mysql_conn, user);
}
mysql_free_result(result);
if (user_cond && (user_cond->with_assocs
|| (user_cond->assoc_cond
&& user_cond->assoc_cond->only_defs))) {
ListIterator assoc_itr = NULL;
slurmdb_user_rec_t *user = NULL;
slurmdb_association_rec_t *assoc = NULL;
List assoc_list = NULL;
/* Make sure we don't get any non-user associations
* this is done by at least having a user_list
* defined */
if (!user_cond->assoc_cond)
user_cond->assoc_cond =
xmalloc(sizeof(slurmdb_association_cond_t));
if (!user_cond->assoc_cond->user_list)
user_cond->assoc_cond->user_list = list_create(NULL);
user_cond->assoc_cond->with_deleted = user_cond->with_deleted;
assoc_list = as_mysql_get_assocs(
mysql_conn, uid, user_cond->assoc_cond);
if (!assoc_list) {
error("no associations");
goto get_wckeys;
}
itr = list_iterator_create(user_list);
assoc_itr = list_iterator_create(assoc_list);
while ((user = list_next(itr))) {
while ((assoc = list_next(assoc_itr))) {
if (strcmp(assoc->user, user->name))
continue;
/* Set up the default. This is needed
* for older versions primarily that
* don't have the notion of default
* account per cluster. */
if (!user->default_acct && (assoc->is_def == 1))
user->default_acct =
xstrdup(assoc->acct);
if (!user_cond->with_assocs) {
/* We just got the default so no
reason to hang around if we aren't
getting the associations.
*/
if (user->default_acct)
break;
else
continue;
}
if (!user->assoc_list)
user->assoc_list = list_create(
slurmdb_destroy_association_rec);
list_append(user->assoc_list, assoc);
list_remove(assoc_itr);
}
list_iterator_reset(assoc_itr);
}
list_iterator_destroy(itr);
list_iterator_destroy(assoc_itr);
list_destroy(assoc_list);
}
get_wckeys:
if (user_cond && (user_cond->with_wckeys
|| (user_cond->assoc_cond
&& user_cond->assoc_cond->only_defs))) {
ListIterator wckey_itr = NULL;
slurmdb_user_rec_t *user = NULL;
slurmdb_wckey_rec_t *wckey = NULL;
List wckey_list = NULL;
slurmdb_wckey_cond_t wckey_cond;
memset(&wckey_cond, 0, sizeof(slurmdb_wckey_cond_t));
if (user_cond->assoc_cond) {
wckey_cond.user_list =
user_cond->assoc_cond->user_list;
wckey_cond.cluster_list =
user_cond->assoc_cond->cluster_list;
wckey_cond.only_defs =
user_cond->assoc_cond->only_defs;
}
wckey_list = as_mysql_get_wckeys(mysql_conn, uid, &wckey_cond);
if (!wckey_list)
return user_list;
itr = list_iterator_create(user_list);
wckey_itr = list_iterator_create(wckey_list);
while ((user = list_next(itr))) {
while ((wckey = list_next(wckey_itr))) {
if (strcmp(wckey->user, user->name))
continue;
/* Set up the default. This is needed
* for older versions primarily that
* don't have the notion of default
* wckey per cluster. */
if (!user->default_wckey
&& (wckey->is_def == 1))
user->default_wckey =
xstrdup(wckey->name);
/* We just got the default so no
reason to hang around if we aren't
getting the wckeys.
*/
if (!user_cond->with_wckeys) {
/* We just got the default so no
reason to hang around if we aren't
getting the wckeys.
*/
if (user->default_wckey)
break;
else
continue;
}
if (!user->wckey_list)
user->wckey_list = list_create(
slurmdb_destroy_wckey_rec);
list_append(user->wckey_list, wckey);
list_remove(wckey_itr);
}
list_iterator_reset(wckey_itr);
/* If a user doesn't have a default wckey (they
might not of had track_wckeys on), set it now.
*/
if (!user->default_wckey)
user->default_wckey = xstrdup("");
}
list_iterator_destroy(itr);
list_iterator_destroy(wckey_itr);
list_destroy(wckey_list);
}
return user_list;
}
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;
if (!is_user_min_admin_level(mysql_conn, uid, SLURMDB_ADMIN_OPERATOR)) {
errno = ESLURM_ACCESS_DENIED;
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");
FREE_NULL_LIST(ret_list);
errno = SLURM_ERROR;
ret_list = NULL;
}
xfree(name_char);
xfree(vals);
return ret_list;
}
extern int as_mysql_add_coord(mysql_conn_t *mysql_conn, uint32_t uid,
List acct_list, slurmdb_user_cond_t *user_cond)
{
char *query = NULL, *user = NULL, *acct = NULL;
char *user_name = NULL, *txn_query = NULL;
ListIterator itr, itr2;
time_t now = time(NULL);
int rc = SLURM_SUCCESS;
slurmdb_user_rec_t *user_rec = NULL;
if (!user_cond || !user_cond->assoc_cond
|| !user_cond->assoc_cond->user_list
|| !list_count(user_cond->assoc_cond->user_list)
|| !acct_list || !list_count(acct_list)) {
error("we need something to add");
return SLURM_ERROR;
}
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;
slurmdb_coord_rec_t *coord = NULL;
char *acct = NULL;
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 add account coordinators");
return ESLURM_ACCESS_DENIED;
}
itr = list_iterator_create(acct_list);
itr2 = list_iterator_create(user.coord_accts);
while ((acct = list_next(itr))) {
while ((coord = list_next(itr2))) {
if (!xstrcasecmp(coord->name, acct))
break;
}
if (!coord)
break;
list_iterator_reset(itr2);
}
list_iterator_destroy(itr2);
list_iterator_destroy(itr);
if (!coord) {
error("Coordinator %s(%d) tried to add another "
"coordinator to an account they aren't "
"coordinator over.",
user.name, user.uid);
return ESLURM_ACCESS_DENIED;
}
}
user_name = uid_to_string((uid_t) uid);
itr = list_iterator_create(user_cond->assoc_cond->user_list);
itr2 = list_iterator_create(acct_list);
while ((user = list_next(itr))) {
if (!user[0])
continue;
while ((acct = list_next(itr2))) {
if (!acct[0])
continue;
if (query)
xstrfmtcat(query, ", (%ld, %ld, '%s', '%s')",
(long)now, (long)now, acct, user);
else
query = xstrdup_printf(
"insert into %s (creation_time, "
"mod_time, acct, user) values "
"(%ld, %ld, '%s', '%s')",
acct_coord_table,
(long)now, (long)now, acct, user);
if (txn_query)
xstrfmtcat(txn_query,
", (%ld, %u, '%s', '%s', '%s')",
(long)now, DBD_ADD_ACCOUNT_COORDS,
user, user_name, acct);
else
xstrfmtcat(txn_query,
"insert into %s "
"(timestamp, action, name, "
"actor, info) "
"values (%ld, %u, '%s', "
"'%s', '%s')",
txn_table,
(long)now, DBD_ADD_ACCOUNT_COORDS,
user,
user_name, acct);
}
list_iterator_reset(itr2);
}
xfree(user_name);
list_iterator_destroy(itr);
list_iterator_destroy(itr2);
if (query) {
xstrfmtcat(query,
" on duplicate key update mod_time=%ld, "
"deleted=0;%s",
(long)now, txn_query);
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);
xfree(txn_query);
if (rc != SLURM_SUCCESS) {
error("Couldn't add cluster hour rollup");
return rc;
}
/* get the update list set */
itr = list_iterator_create(user_cond->assoc_cond->user_list);
while ((user = list_next(itr))) {
user_rec = xmalloc(sizeof(slurmdb_user_rec_t));
user_rec->name = xstrdup(user);
_get_user_coords(mysql_conn, user_rec);
if (addto_update_list(mysql_conn->update_list,
SLURMDB_ADD_COORD, user_rec)
!= SLURM_SUCCESS)
slurmdb_destroy_user_rec(user_rec);
}
list_iterator_destroy(itr);
}
return SLURM_SUCCESS;
}
extern int as_mysql_add_users(mysql_conn_t *mysql_conn, uint32_t uid,
List user_list)
{
ListIterator itr = NULL;
int rc = SLURM_SUCCESS;
slurmdb_user_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_assoc_rec);
List wckey_list = list_create(slurmdb_destroy_wckey_rec);
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 add accounts");
return ESLURM_ACCESS_DENIED;
}
/* If the user is a coord of any acct they can add
* accounts they are only able to make associations to
* these accounts if they are coordinators of the
* parent they are trying to add to
*/
}
user_name = uid_to_string((uid_t) uid);
itr = list_iterator_create(user_list);
while ((object = list_next(itr))) {
if (!object->name || !object->name[0]) {
error("We need a user name and "
"default acct to add.");
rc = SLURM_ERROR;
continue;
}
xstrcat(cols, "creation_time, mod_time, name");
xstrfmtcat(vals, "%ld, %ld, '%s'",
(long)now, (long)now, object->name);
if (object->admin_level != SLURMDB_ADMIN_NOTSET) {
xstrcat(cols, ", admin_level");
xstrfmtcat(vals, ", %u", object->admin_level);
xstrfmtcat(extra, ", admin_level=%u",
object->admin_level);
} else
xstrfmtcat(extra, ", admin_level=%u",
SLURMDB_ADMIN_NONE);
query = xstrdup_printf(
"insert into %s (%s) values (%s) "
"on duplicate key update deleted=0, mod_time=%ld %s;",
user_table, cols, vals,
(long)now, extra);
xfree(cols);
xfree(vals);
rc = mysql_db_query(mysql_conn, query);
xfree(query);
if (rc != SLURM_SUCCESS) {
error("Couldn't add user %s", object->name);
xfree(extra);
continue;
}
affect_rows = last_affected_rows(mysql_conn);
if (!affect_rows) {
debug("nothing changed");
xfree(extra);
continue;
}
if (addto_update_list(mysql_conn->update_list, SLURMDB_ADD_USER,
object) == SLURM_SUCCESS)
list_remove(itr);
/* 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')",
(long)now, DBD_ADD_USERS, 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,
(long)now, DBD_ADD_USERS, object->name,
user_name, tmp_extra);
xfree(tmp_extra);
xfree(extra);
/* For < 2.2 systems we need to set the is_def flag in
the default association/wckey so as to make sure we get
it set correctly.
*/
if (object->assoc_list) {
slurmdb_assoc_rec_t *assoc = NULL;
ListIterator assoc_itr =
list_iterator_create(object->assoc_list);
while ((assoc = list_next(assoc_itr))) {
/* We need to mark all of the
associations with this account
since there could be multiple
clusters here.
*/
if (!xstrcmp(assoc->acct, object->default_acct))
assoc->is_def = 1;
}
list_iterator_destroy(assoc_itr);
list_transfer(assoc_list, object->assoc_list);
}
if (object->wckey_list) {
if (object->default_wckey) {
slurmdb_wckey_rec_t *wckey = NULL;
ListIterator wckey_itr = list_iterator_create(
object->wckey_list);
while ((wckey = list_next(wckey_itr))) {
/* We need to mark all of the
wckeys with this account
since there could be multiple
clusters here.
*/
if (!xstrcmp(wckey->name,
object->default_wckey))
wckey->is_def = 1;
}
list_iterator_destroy(wckey_itr);
}
list_transfer(wckey_list, object->wckey_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 ((rc = as_mysql_add_assocs(mysql_conn, uid, assoc_list))
!= SLURM_SUCCESS)
error("Problem adding user associations");
}
FREE_NULL_LIST(assoc_list);
if (rc == SLURM_SUCCESS && list_count(wckey_list)) {
if ((rc = as_mysql_add_wckeys(mysql_conn, uid, wckey_list))
!= SLURM_SUCCESS)
error("Problem adding user wckeys");
}
FREE_NULL_LIST(wckey_list);
return rc;
}
extern List as_mysql_remove_qos(mysql_conn_t *mysql_conn, uint32_t uid,
slurmdb_qos_cond_t *qos_cond)
{
ListIterator itr = NULL;
List ret_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;
if (!qos_cond) {
error("we need something to change");
return NULL;
}
if (check_connection(mysql_conn) != SLURM_SUCCESS)
return NULL;
if (!is_user_min_admin_level(
mysql_conn, uid, SLURMDB_ADMIN_SUPER_USER)) {
errno = ESLURM_ACCESS_DENIED;
return NULL;
}
xstrcat(extra, "where deleted=0");
if (qos_cond->description_list
&& list_count(qos_cond->description_list)) {
set = 0;
xstrcat(extra, " && (");
itr = list_iterator_create(qos_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 (qos_cond->id_list
&& list_count(qos_cond->id_list)) {
set = 0;
xstrcat(extra, " && (");
itr = list_iterator_create(qos_cond->id_list);
while ((object = list_next(itr))) {
if (!object[0])
continue;
if (set)
xstrcat(extra, " || ");
xstrfmtcat(extra, "id='%s'", object);
set = 1;
}
list_iterator_destroy(itr);
xstrcat(extra, ")");
}
if (qos_cond->name_list
&& list_count(qos_cond->name_list)) {
set = 0;
xstrcat(extra, " && (");
itr = list_iterator_create(qos_cond->name_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 (!extra) {
error("Nothing to remove");
return NULL;
}
query = xstrdup_printf("select id, name from %s %s;", qos_table, extra);
xfree(extra);
if (!(result = mysql_db_query_ret(
mysql_conn, query, 0))) {
xfree(query);
return NULL;
}
name_char = NULL;
ret_list = list_create(slurm_destroy_char);
while ((row = mysql_fetch_row(result))) {
slurmdb_qos_rec_t *qos_rec = NULL;
list_append(ret_list, xstrdup(row[1]));
if (!name_char)
xstrfmtcat(name_char, "id='%s'", row[0]);
else
xstrfmtcat(name_char, " || id='%s'", row[0]);
if (!assoc_char)
xstrfmtcat(assoc_char, "id_qos='%s'", row[0]);
else
xstrfmtcat(assoc_char, " || id_qos='%s'", row[0]);
xstrfmtcat(extra,
", qos=replace(qos, ',%s,', '')"
", delta_qos=replace(delta_qos, ',+%s,', '')"
", delta_qos=replace(delta_qos, ',-%s,', '')",
row[0], row[0], row[0]);
qos_rec = xmalloc(sizeof(slurmdb_qos_rec_t));
/* we only need id when removing no real need to init */
qos_rec->id = slurm_atoul(row[0]);
if (addto_update_list(mysql_conn->update_list,
SLURMDB_REMOVE_QOS, qos_rec)
!= SLURM_SUCCESS)
slurmdb_destroy_qos_rec(qos_rec);
}
mysql_free_result(result);
if (!list_count(ret_list)) {
errno = SLURM_NO_CHANGE_IN_DATA;
if (debug_flags & DEBUG_FLAG_DB_QOS)
DB_DEBUG(mysql_conn->conn, "didn't effect anything\n%s", query);
xfree(query);
return ret_list;
}
xfree(query);
/* remove this qos from all the users/accts that have it */
query = xstrdup_printf("update %s set mod_time=%ld %s where deleted=0;",
assoc_table, now, extra);
xfree(extra);
if (debug_flags & DEBUG_FLAG_DB_QOS)
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);
xfree(assoc_char);
xfree(name_char);
FREE_NULL_LIST(ret_list);
return NULL;
}
user_name = uid_to_string((uid_t) uid);
slurm_mutex_lock(&as_mysql_cluster_list_lock);
if (list_count(as_mysql_cluster_list)) {
itr = list_iterator_create(as_mysql_cluster_list);
while ((object = list_next(itr))) {
if ((rc = remove_common(mysql_conn, DBD_REMOVE_QOS, now,
user_name, qos_table, name_char,
assoc_char, object, NULL, NULL))
!= SLURM_SUCCESS)
break;
}
list_iterator_destroy(itr);
} else
rc = remove_common(mysql_conn, DBD_REMOVE_QOS, now,
user_name, qos_table, name_char,
assoc_char, NULL, NULL, NULL);
slurm_mutex_unlock(&as_mysql_cluster_list_lock);
xfree(assoc_char);
xfree(name_char);
xfree(user_name);
if (rc == SLURM_ERROR) {
FREE_NULL_LIST(ret_list);
return NULL;
}
return ret_list;
}
extern List as_mysql_modify_qos(mysql_conn_t *mysql_conn, uint32_t uid,
slurmdb_qos_cond_t *qos_cond,
slurmdb_qos_rec_t *qos)
{
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, i;
MYSQL_RES *result = NULL;
MYSQL_ROW row;
char *tmp_char1=NULL, *tmp_char2=NULL;
bitstr_t *preempt_bitstr = NULL;
char *added_preempt = NULL;
uint32_t qos_cnt;
assoc_mgr_lock_t locks = { NO_LOCK, NO_LOCK, READ_LOCK, NO_LOCK,
NO_LOCK, NO_LOCK, NO_LOCK };
if (!qos_cond || !qos) {
error("we need something to change");
return NULL;
}
if (check_connection(mysql_conn) != SLURM_SUCCESS)
return NULL;
if (!is_user_min_admin_level(mysql_conn, uid,
SLURMDB_ADMIN_SUPER_USER)) {
errno = ESLURM_ACCESS_DENIED;
return NULL;
}
xstrcat(extra, "where deleted=0");
if (qos_cond->description_list
&& list_count(qos_cond->description_list)) {
set = 0;
xstrcat(extra, " && (");
itr = list_iterator_create(qos_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 (qos_cond->id_list
&& list_count(qos_cond->id_list)) {
set = 0;
xstrcat(extra, " && (");
itr = list_iterator_create(qos_cond->id_list);
while ((object = list_next(itr))) {
if (set)
xstrcat(extra, " || ");
xstrfmtcat(extra, "id='%s'", object);
set = 1;
}
list_iterator_destroy(itr);
xstrcat(extra, ")");
}
if (qos_cond->name_list
&& list_count(qos_cond->name_list)) {
set = 0;
xstrcat(extra, " && (");
itr = list_iterator_create(qos_cond->name_list);
while ((object = list_next(itr))) {
if (set)
xstrcat(extra, " || ");
xstrfmtcat(extra, "name='%s'", object);
set = 1;
}
list_iterator_destroy(itr);
xstrcat(extra, ")");
}
_setup_qos_limits(qos, &tmp_char1, &tmp_char2,
&vals, &added_preempt, 0);
assoc_mgr_lock(&locks);
qos_cnt = g_qos_count;
assoc_mgr_unlock(&locks);
if (added_preempt) {
preempt_bitstr = bit_alloc(qos_cnt);
bit_unfmt(preempt_bitstr, added_preempt+1);
xfree(added_preempt);
}
xfree(tmp_char1);
xfree(tmp_char2);
if (!extra || !vals) {
errno = SLURM_NO_CHANGE_IN_DATA;
FREE_NULL_BITMAP(preempt_bitstr);
error("Nothing to change");
return NULL;
}
object = xstrdup(mqos_req_inx[0]);
for (i = 1; i < MQOS_COUNT; i++)
xstrfmtcat(object, ", %s", mqos_req_inx[i]);
query = xstrdup_printf("select %s from %s %s;",
object, qos_table, extra);
xfree(extra);
xfree(object);
if (!(result = mysql_db_query_ret(mysql_conn, query, 0))) {
xfree(query);
FREE_NULL_BITMAP(preempt_bitstr);
return NULL;
}
rc = 0;
ret_list = list_create(slurm_destroy_char);
while ((row = mysql_fetch_row(result))) {
slurmdb_qos_rec_t *qos_rec = NULL;
uint32_t id = slurm_atoul(row[MQOS_ID]);
if (preempt_bitstr) {
if (_preemption_loop(mysql_conn, id, preempt_bitstr))
break;
}
object = xstrdup(row[MQOS_NAME]);
list_append(ret_list, object);
if (!rc) {
xstrfmtcat(name_char, "(name='%s'", object);
rc = 1;
} else {
xstrfmtcat(name_char, " || name='%s'", object);
}
qos_rec = xmalloc(sizeof(slurmdb_qos_rec_t));
qos_rec->name = xstrdup(object);
qos_rec->id = id;
qos_rec->flags = qos->flags;
qos_rec->grace_time = qos->grace_time;
mod_tres_str(&qos_rec->grp_tres,
qos->grp_tres, row[MQOS_GT],
NULL, "grp_tres", &vals, qos_rec->id, 0);
mod_tres_str(&qos_rec->grp_tres_mins,
qos->grp_tres_mins, row[MQOS_GTM],
NULL, "grp_tres_mins", &vals, qos_rec->id, 0);
mod_tres_str(&qos_rec->grp_tres_run_mins,
qos->grp_tres_run_mins, row[MQOS_GTRM],
NULL, "grp_tres_run_mins", &vals,
qos_rec->id, 0);
qos_rec->grp_jobs = qos->grp_jobs;
qos_rec->grp_submit_jobs = qos->grp_submit_jobs;
qos_rec->grp_wall = qos->grp_wall;
mod_tres_str(&qos_rec->max_tres_pa,
qos->max_tres_pa, row[MQOS_MTPA],
NULL, "max_tres_pa", &vals, qos_rec->id, 0);
mod_tres_str(&qos_rec->max_tres_pj,
qos->max_tres_pj, row[MQOS_MTPJ],
NULL, "max_tres_pj", &vals, qos_rec->id, 0);
mod_tres_str(&qos_rec->max_tres_pn,
qos->max_tres_pn, row[MQOS_MTPN],
NULL, "max_tres_pn", &vals, qos_rec->id, 0);
mod_tres_str(&qos_rec->max_tres_pu,
qos->max_tres_pu, row[MQOS_MTPU],
NULL, "max_tres_pu", &vals, qos_rec->id, 0);
mod_tres_str(&qos_rec->max_tres_mins_pj,
qos->max_tres_mins_pj, row[MQOS_MTMPJ],
NULL, "max_tres_mins_pj", &vals, qos_rec->id, 0);
mod_tres_str(&qos_rec->max_tres_run_mins_pa,
qos->max_tres_run_mins_pa, row[MQOS_MTRM],
NULL, "max_tres_run_mins_pa", &vals,
qos_rec->id, 0);
mod_tres_str(&qos_rec->max_tres_run_mins_pu,
qos->max_tres_run_mins_pu, row[MQOS_MTRM],
NULL, "max_tres_run_mins_pu", &vals,
qos_rec->id, 0);
qos_rec->max_jobs_pa = qos->max_jobs_pa;
qos_rec->max_jobs_pu = qos->max_jobs_pu;
qos_rec->max_submit_jobs_pa = qos->max_submit_jobs_pa;
qos_rec->max_submit_jobs_pu = qos->max_submit_jobs_pu;
qos_rec->max_wall_pj = qos->max_wall_pj;
mod_tres_str(&qos_rec->min_tres_pj,
qos->min_tres_pj, row[MQOS_MITPJ],
NULL, "min_tres_pj", &vals, qos_rec->id, 0);
qos_rec->preempt_mode = qos->preempt_mode;
qos_rec->priority = qos->priority;
if (qos->preempt_list) {
ListIterator new_preempt_itr =
list_iterator_create(qos->preempt_list);
char *new_preempt = NULL;
bool cleared = 0;
qos_rec->preempt_bitstr = bit_alloc(qos_cnt);
if (row[MQOS_PREEMPT] && row[MQOS_PREEMPT][0])
bit_unfmt(qos_rec->preempt_bitstr,
row[MQOS_PREEMPT]+1);
while ((new_preempt = list_next(new_preempt_itr))) {
if (new_preempt[0] == '-') {
bit_clear(qos_rec->preempt_bitstr,
atol(new_preempt+1));
} else if (new_preempt[0] == '+') {
bit_set(qos_rec->preempt_bitstr,
atol(new_preempt+1));
} else {
if (!cleared) {
cleared = 1;
bit_nclear(
qos_rec->preempt_bitstr,
0,
qos_cnt-1);
}
bit_set(qos_rec->preempt_bitstr,
atol(new_preempt));
}
}
list_iterator_destroy(new_preempt_itr);
}
qos_rec->usage_factor = qos->usage_factor;
qos_rec->usage_thres = qos->usage_thres;
if (addto_update_list(mysql_conn->update_list,
SLURMDB_MODIFY_QOS, qos_rec)
!= SLURM_SUCCESS)
slurmdb_destroy_qos_rec(qos_rec);
}
mysql_free_result(result);
FREE_NULL_BITMAP(preempt_bitstr);
if (row) {
xfree(vals);
xfree(name_char);
xfree(query);
FREE_NULL_LIST(ret_list);
ret_list = NULL;
errno = ESLURM_QOS_PREEMPTION_LOOP;
return ret_list;
}
if (!list_count(ret_list)) {
errno = SLURM_NO_CHANGE_IN_DATA;
if (debug_flags & DEBUG_FLAG_DB_QOS)
DB_DEBUG(mysql_conn->conn,
"didn't effect anything\n%s", query);
xfree(vals);
xfree(query);
return ret_list;
}
xfree(query);
xstrcat(name_char, ")");
user_name = uid_to_string((uid_t) uid);
rc = modify_common(mysql_conn, DBD_MODIFY_QOS, now,
user_name, qos_table, name_char, vals, NULL);
xfree(user_name);
xfree(name_char);
xfree(vals);
if (rc == SLURM_ERROR) {
error("Couldn't modify qos");
FREE_NULL_LIST(ret_list);
ret_list = NULL;
}
return ret_list;
}
extern int as_mysql_add_qos(mysql_conn_t *mysql_conn, uint32_t uid,
List qos_list)
{
ListIterator itr = NULL;
int rc = SLURM_SUCCESS;
slurmdb_qos_rec_t *object = NULL;
char *cols = NULL, *extra = NULL, *vals = NULL, *query = NULL,
*tmp_extra = NULL;
time_t now = time(NULL);
char *user_name = NULL;
int affect_rows = 0;
int added = 0;
char *added_preempt = NULL;
uint32_t qos_cnt;
assoc_mgr_lock_t locks = { NO_LOCK, NO_LOCK, READ_LOCK, NO_LOCK,
NO_LOCK, NO_LOCK, NO_LOCK };
if (check_connection(mysql_conn) != SLURM_SUCCESS)
return ESLURM_DB_CONNECTION;
if (!is_user_min_admin_level(mysql_conn, uid, SLURMDB_ADMIN_SUPER_USER))
return ESLURM_ACCESS_DENIED;
assoc_mgr_lock(&locks);
qos_cnt = g_qos_count;
assoc_mgr_unlock(&locks);
user_name = uid_to_string((uid_t) uid);
itr = list_iterator_create(qos_list);
while ((object = list_next(itr))) {
if (!object->name || !object->name[0]) {
error("We need a qos name to add.");
rc = SLURM_ERROR;
continue;
}
xstrcat(cols, "creation_time, mod_time, name");
xstrfmtcat(vals, "%ld, %ld, '%s'",
now, now, object->name);
xstrfmtcat(extra, ", mod_time=%ld", now);
_setup_qos_limits(object, &cols, &vals,
&extra, &added_preempt, 1);
if (added_preempt) {
object->preempt_bitstr = bit_alloc(qos_cnt);
bit_unfmt(object->preempt_bitstr, added_preempt+1);
xfree(added_preempt);
}
xstrfmtcat(query,
"insert into %s (%s) values (%s) "
"on duplicate key update deleted=0, "
"id=LAST_INSERT_ID(id)%s;",
qos_table, cols, vals, extra);
if (debug_flags & DEBUG_FLAG_DB_QOS)
DB_DEBUG(mysql_conn->conn, "query\n%s", query);
object->id = (uint32_t)mysql_db_insert_ret_id(
mysql_conn, query);
xfree(query);
if (!object->id) {
error("Couldn't add qos %s", object->name);
added=0;
xfree(cols);
xfree(extra);
xfree(vals);
break;
}
affect_rows = last_affected_rows(mysql_conn);
if (!affect_rows) {
debug2("nothing changed %d", affect_rows);
xfree(cols);
xfree(extra);
xfree(vals);
continue;
}
/* we always have a ', ' as the first 2 chars */
tmp_extra = slurm_add_slash_to_quotes(extra+2);
xstrfmtcat(query,
"insert into %s "
"(timestamp, action, name, actor, info) "
"values (%ld, %u, '%s', '%s', '%s');",
txn_table,
now, DBD_ADD_QOS, object->name, user_name,
tmp_extra);
xfree(tmp_extra);
xfree(cols);
xfree(extra);
xfree(vals);
debug4("query\n%s",query);
rc = mysql_db_query(mysql_conn, query);
xfree(query);
if (rc != SLURM_SUCCESS) {
error("Couldn't add txn");
} else {
if (addto_update_list(mysql_conn->update_list,
SLURMDB_ADD_QOS,
object) == SLURM_SUCCESS)
list_remove(itr);
added++;
}
}
list_iterator_destroy(itr);
xfree(user_name);
if (!added) {
reset_mysql_conn(mysql_conn);
}
return rc;
}
extern List as_mysql_remove_federations(mysql_conn_t *mysql_conn, uint32_t uid,
slurmdb_federation_cond_t *fed_cond)
{
List ret_list = NULL;
int rc = SLURM_SUCCESS;
char *extra = NULL, *query = NULL, *name_char = NULL;
time_t now = time(NULL);
char *user_name = NULL;
MYSQL_RES *result = NULL;
MYSQL_ROW row;
if (!fed_cond) {
error("we need something to change");
return NULL;
}
if (check_connection(mysql_conn) != SLURM_SUCCESS)
return NULL;
if (!is_user_min_admin_level(
mysql_conn, uid, SLURMDB_ADMIN_SUPER_USER)) {
errno = ESLURM_ACCESS_DENIED;
return NULL;
}
/* force to only do non-deleted federations */
fed_cond->with_deleted = 0;
_setup_federation_cond_limits(fed_cond, &extra);
if (!extra) {
error("Nothing to remove");
return NULL;
}
query = xstrdup_printf("select name from %s as t1 %s;",
federation_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);
if (!mysql_num_rows(result)) {
mysql_free_result(result);
errno = SLURM_NO_CHANGE_IN_DATA;
if (debug_flags & DEBUG_FLAG_FEDR)
DB_DEBUG(mysql_conn->conn,
"didn't effect anything\n%s", query);
xfree(query);
return ret_list;
}
xfree(query);
user_name = uid_to_string((uid_t) uid);
while ((row = mysql_fetch_row(result))) {
char *object = xstrdup(row[0]);
list_append(ret_list, object);
if ((rc = _remove_all_clusters_from_fed(mysql_conn, object,
NULL)))
break;
xfree(name_char);
xstrfmtcat(name_char, "name='%s'", object);
if ((rc = remove_common(mysql_conn, DBD_REMOVE_FEDERATIONS, now,
user_name, federation_table, name_char,
NULL, NULL, ret_list, NULL)))
break;
}
mysql_free_result(result);
xfree(user_name);
xfree(name_char);
if (rc != SLURM_SUCCESS) {
FREE_NULL_LIST(ret_list);
return NULL;
} else
as_mysql_add_feds_to_update_list(mysql_conn);
return ret_list;
}
extern List as_mysql_modify_federations(
mysql_conn_t *mysql_conn, uint32_t uid,
slurmdb_federation_cond_t *fed_cond,
slurmdb_federation_rec_t *fed)
{
List ret_list = NULL;
int rc = SLURM_SUCCESS;
int req_inx = 0;
char *object = NULL;
char *vals = NULL, *extra = NULL, *query = NULL,
*name_char = NULL, *fed_items = NULL;
char *tmp_char1 = NULL, *tmp_char2 = NULL;
time_t now = time(NULL);
MYSQL_RES *result = NULL;
MYSQL_ROW row;
if (!fed_cond || !fed) {
error("we need something to change");
return NULL;
}
if (check_connection(mysql_conn) != SLURM_SUCCESS)
return NULL;
if (!is_user_min_admin_level(mysql_conn, uid,
SLURMDB_ADMIN_SUPER_USER)) {
errno = ESLURM_ACCESS_DENIED;
return NULL;
}
/* force to only do non-deleted federations */
fed_cond->with_deleted = 0;
_setup_federation_cond_limits(fed_cond, &extra);
_setup_federation_rec_limits(fed, &tmp_char1, &tmp_char2, &vals);
xfree(tmp_char1);
xfree(tmp_char2);
if (!extra ||
(!vals && (!fed->cluster_list || !list_count(fed->cluster_list)))) {
xfree(extra);
xfree(vals);
errno = SLURM_NO_CHANGE_IN_DATA;
error("Nothing to change");
return NULL;
}
if (fed->cluster_list &&
fed_cond->federation_list &&
(list_count(fed_cond->federation_list) > 1)) {
xfree(extra);
xfree(vals);
error("Clusters can only be assigned to one federation");
errno = ESLURM_FED_CLUSTER_MULTIPLE_ASSIGNMENT;
return NULL;
}
/* Select records that are going to get updated.
* 1 - to be able to report what is getting updated
* 2 - to create an update object to let the controller know. */
xstrfmtcat(fed_items, "%s", fed_req_inx[req_inx]);
for(req_inx = 1; req_inx < FED_REQ_COUNT; req_inx++) {
xstrfmtcat(fed_items, ", %s", fed_req_inx[req_inx]);
}
xstrfmtcat(query, "select %s from %s as t1 %s;",
fed_items, federation_table, extra);
xfree(fed_items);
if (debug_flags & DEBUG_FLAG_FEDR)
DB_DEBUG(mysql_conn->conn, "query\n%s", query);
if (!(result = mysql_db_query_ret(mysql_conn, query, 0))) {
xfree(query);
xfree(vals);
xfree(extra);
error("no result given for %s", extra);
return NULL;
}
xfree(extra);
ret_list = list_create(slurm_destroy_char);
while ((row = mysql_fetch_row(result))) {
object = xstrdup(row[0]);
list_append(ret_list, object);
if (!name_char) {
xstrfmtcat(name_char, "(name='%s'", object);
} else {
xstrfmtcat(name_char, " || name='%s'", object);
}
}
mysql_free_result(result);
if (fed->cluster_list &&
(_assign_clusters_to_federation(mysql_conn, object,
fed->cluster_list))) {
xfree(vals);
xfree(name_char);
xfree(query);
return NULL;
}
if (!list_count(ret_list)) {
errno = SLURM_NO_CHANGE_IN_DATA;
if (debug_flags & DEBUG_FLAG_FEDR)
DB_DEBUG(mysql_conn->conn,
"didn't effect anything\n%s", query);
xfree(vals);
xfree(name_char);
xfree(query);
return ret_list;
}
xfree(query);
xstrcat(name_char, ")");
if (vals) {
char *user_name = uid_to_string((uid_t) uid);
rc = modify_common(mysql_conn, DBD_MODIFY_FEDERATIONS, now,
user_name, federation_table,
name_char, vals, NULL);
xfree(user_name);
}
xfree(name_char);
xfree(vals);
if (rc == SLURM_ERROR) {
error("Couldn't modify federation");
FREE_NULL_LIST(ret_list);
ret_list = NULL;
} else
as_mysql_add_feds_to_update_list(mysql_conn);
return ret_list;
}
extern List as_mysql_get_wckeys(mysql_conn_t *mysql_conn, uid_t uid,
slurmdb_wckey_cond_t *wckey_cond)
{
//DEF_TIMERS;
char *extra = NULL;
char *tmp = NULL;
char *cluster_name = NULL;
List wckey_list = NULL;
int i=0, is_admin=1;
uint16_t private_data = 0;
slurmdb_user_rec_t user;
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;
memset(&user, 0, sizeof(slurmdb_user_rec_t));
user.uid = uid;
private_data = slurm_get_private_data();
if (private_data & PRIVATE_DATA_USERS) {
if (!(is_admin = is_user_min_admin_level(
mysql_conn, uid, SLURMDB_ADMIN_OPERATOR))) {
assoc_mgr_fill_in_user(
mysql_conn, &user, 1, NULL);
}
if (!is_admin && !user.name) {
debug("User %u has no assocations, and is not admin, "
"so not returning any wckeys.", user.uid);
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:
xfree(tmp);
xstrfmtcat(tmp, "t1.%s", wckey_req_inx[i]);
for(i=1; i<WCKEY_REQ_COUNT; i++) {
xstrfmtcat(tmp, ", t1.%s", wckey_req_inx[i]);
}
/* this is here to make sure we are looking at only this user
* if this flag is set. We also include any accounts they may be
* coordinator of.
*/
if (!is_admin && (private_data & PRIVATE_DATA_USERS))
xstrfmtcat(extra, " && t1.user='******'", user.name);
wckey_list = list_create(slurmdb_destroy_wckey_rec);
if (use_cluster_list == as_mysql_cluster_list)
slurm_mutex_lock(&as_mysql_cluster_list_lock);
//START_TIMER;
itr = list_iterator_create(use_cluster_list);
while ((cluster_name = list_next(itr))) {
if (_cluster_get_wckeys(mysql_conn, wckey_cond, tmp, extra,
cluster_name, wckey_list)
!= SLURM_SUCCESS) {
list_destroy(wckey_list);
wckey_list = NULL;
break;
}
}
list_iterator_destroy(itr);
if (use_cluster_list == as_mysql_cluster_list)
slurm_mutex_unlock(&as_mysql_cluster_list_lock);
xfree(tmp);
xfree(extra);
//END_TIMER2("get_wckeys");
return wckey_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_assoc_rec);
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 add accounts");
return ESLURM_ACCESS_DENIED;
}
/* If the user is a coord of any acct they can add
* accounts they are only able to make associations to
* these accounts if they are coordinators of the
* parent they are trying to add to
*/
}
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;
if (!assoc_list)
assoc_list =
list_create(slurmdb_destroy_assoc_rec);
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 (assoc_list && list_count(assoc_list)) {
if ((rc = as_mysql_add_assocs(mysql_conn, uid, assoc_list))
!= SLURM_SUCCESS)
error("Problem adding accounts associations");
}
FREE_NULL_LIST(assoc_list);
return rc;
}
extern List as_mysql_remove_users(mysql_conn_t *mysql_conn, uint32_t uid,
slurmdb_user_cond_t *user_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;
slurmdb_user_cond_t user_coord_cond;
slurmdb_assoc_cond_t assoc_cond;
slurmdb_wckey_cond_t wckey_cond;
bool jobs_running = 0;
if (!user_cond) {
error("we need something to remove");
return NULL;
}
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;
}
if (user_cond->assoc_cond && user_cond->assoc_cond->user_list
&& list_count(user_cond->assoc_cond->user_list)) {
set = 0;
xstrcat(extra, " && (");
itr = list_iterator_create(user_cond->assoc_cond->user_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, ")");
}
ret_list = _get_other_user_names_to_mod(mysql_conn, uid, user_cond);
if (user_cond->admin_level != SLURMDB_ADMIN_NOTSET) {
xstrfmtcat(extra, " && admin_level=%u", user_cond->admin_level);
}
if (!extra && !ret_list) {
error("Nothing to remove");
return NULL;
} else if (!extra) {
/* means we got a ret_list and don't need to look at
the user_table. */
goto no_user_table;
}
/* Only handle this if we need to actually query the
user_table. If a request comes in stating they want to
remove all users with default account of whatever then that
doesn't deal with the user_table.
*/
query = xstrdup_printf("select name from %s where deleted=0 %s;",
user_table, extra);
xfree(extra);
if (!(result = mysql_db_query_ret(mysql_conn, query, 0))) {
xfree(query);
return NULL;
}
if (!ret_list)
ret_list = list_create(slurm_destroy_char);
while ((row = mysql_fetch_row(result)))
slurm_addto_char_list(ret_list, row[0]);
mysql_free_result(result);
no_user_table:
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);
memset(&user_coord_cond, 0, sizeof(slurmdb_user_cond_t));
memset(&assoc_cond, 0, sizeof(slurmdb_assoc_cond_t));
/* we do not need to free the objects we put in here since
they are also placed in a list that will be freed
*/
assoc_cond.user_list = list_create(NULL);
user_coord_cond.assoc_cond = &assoc_cond;
itr = list_iterator_create(ret_list);
while ((object = list_next(itr))) {
slurmdb_user_rec_t *user_rec =
xmalloc(sizeof(slurmdb_user_rec_t));
list_append(assoc_cond.user_list, object);
if (name_char) {
xstrfmtcat(name_char, " || name='%s'", object);
xstrfmtcat(assoc_char, " || t2.user='******'", object);
} else {
xstrfmtcat(name_char, "name='%s'", object);
xstrfmtcat(assoc_char, "t2.user='******'", object);
}
user_rec->name = xstrdup(object);
if (addto_update_list(mysql_conn->update_list,
SLURMDB_REMOVE_USER, user_rec)
!= SLURM_SUCCESS)
slurmdb_destroy_user_rec(user_rec);
}
list_iterator_destroy(itr);
/* We need to remove these accounts from the coord's that have it */
coord_list = as_mysql_remove_coord(
mysql_conn, uid, NULL, &user_coord_cond);
FREE_NULL_LIST(coord_list);
/* We need to remove these users from the wckey table */
memset(&wckey_cond, 0, sizeof(slurmdb_wckey_cond_t));
wckey_cond.user_list = assoc_cond.user_list;
coord_list = as_mysql_remove_wckeys(mysql_conn, uid, &wckey_cond);
FREE_NULL_LIST(coord_list);
FREE_NULL_LIST(assoc_cond.user_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_USERS, now,
user_name, user_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);
if (rc == SLURM_ERROR) {
FREE_NULL_LIST(ret_list);
xfree(assoc_char);
return NULL;
}
query = xstrdup_printf(
"update %s as t2 set deleted=1, mod_time=%ld where %s",
acct_coord_table, (long)now, assoc_char);
xfree(assoc_char);
rc = mysql_db_query(mysql_conn, query);
xfree(query);
if (rc != SLURM_SUCCESS) {
error("Couldn't remove user coordinators");
FREE_NULL_LIST(ret_list);
return NULL;
}
if (jobs_running)
errno = ESLURM_JOBS_RUNNING_ON_ASSOC;
else
errno = SLURM_SUCCESS;
return ret_list;
}
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;
if (!is_user_min_admin_level(mysql_conn, uid, SLURMDB_ADMIN_OPERATOR)) {
errno = ESLURM_ACCESS_DENIED;
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);
FREE_NULL_LIST(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) {
FREE_NULL_LIST(ret_list);
return NULL;
}
if (jobs_running)
errno = ESLURM_JOBS_RUNNING_ON_ASSOC;
else
errno = SLURM_SUCCESS;
return ret_list;
}
extern List as_mysql_modify_job(mysql_conn_t *mysql_conn, uint32_t uid,
slurmdb_job_modify_cond_t *job_cond,
slurmdb_job_rec_t *job)
{
List ret_list = NULL;
int rc = SLURM_SUCCESS;
char *object = NULL;
char *vals = NULL, *query = NULL, *cond_char = NULL;
time_t now = time(NULL);
char *user_name = NULL;
MYSQL_RES *result = NULL;
MYSQL_ROW row;
if (!job_cond || !job) {
error("we need something to change");
return NULL;
} else if (job_cond->job_id == NO_VAL) {
errno = SLURM_NO_CHANGE_IN_DATA;
error("Job ID was not specified for job modification\n");
return NULL;
} else if (!job_cond->cluster) {
errno = SLURM_NO_CHANGE_IN_DATA;
error("Cluster was not specified for job modification\n");
return NULL;
} else if (check_connection(mysql_conn) != SLURM_SUCCESS)
return NULL;
if (job->derived_ec != NO_VAL)
xstrfmtcat(vals, ", derived_ec=%u", job->derived_ec);
if (job->derived_es) {
char *derived_es = slurm_add_slash_to_quotes(job->derived_es);
xstrfmtcat(vals, ", derived_es='%s'", derived_es);
xfree(derived_es);
}
if (!vals) {
errno = SLURM_NO_CHANGE_IN_DATA;
error("No change specified for job modification");
return NULL;
}
/* Here we want to get the last job submitted here */
query = xstrdup_printf("select job_db_inx, id_job, time_submit, "
"id_user "
"from \"%s_%s\" where deleted=0 "
"&& id_job=%u "
"order by time_submit desc limit 1;",
job_cond->cluster, job_table,
job_cond->job_id);
debug3("%d(%s:%d) query\n%s",
mysql_conn->conn, THIS_FILE, __LINE__, query);
if (!(result = mysql_db_query_ret(mysql_conn, query, 0))) {
xfree(vals);
xfree(query);
return NULL;
}
if ((row = mysql_fetch_row(result))) {
char tmp_char[25];
time_t time_submit = atol(row[2]);
if ((uid != atoi(row[3])) &&
!is_user_min_admin_level(mysql_conn, uid,
SLURMDB_ADMIN_OPERATOR)) {
errno = ESLURM_ACCESS_DENIED;
xfree(vals);
xfree(query);
mysql_free_result(result);
return NULL;
}
slurm_make_time_str(&time_submit, tmp_char, sizeof(tmp_char));
xstrfmtcat(cond_char, "job_db_inx=%s", row[0]);
object = xstrdup_printf("%s submitted at %s", row[1], tmp_char);
ret_list = list_create(slurm_destroy_char);
list_append(ret_list, object);
mysql_free_result(result);
} else {
errno = ESLURM_INVALID_JOB_ID;
debug3("as_mysql_modify_job: Job not found\n%s", query);
xfree(vals);
xfree(query);
mysql_free_result(result);
return NULL;
}
xfree(query);
user_name = uid_to_string((uid_t) uid);
rc = modify_common(mysql_conn, DBD_MODIFY_JOB, now, user_name,
job_table, cond_char, vals, job_cond->cluster);
xfree(user_name);
xfree(cond_char);
xfree(vals);
if (rc == SLURM_ERROR) {
error("Couldn't modify job");
list_destroy(ret_list);
ret_list = NULL;
}
return ret_list;
}
extern List as_mysql_remove_coord(mysql_conn_t *mysql_conn, uint32_t uid,
List acct_list,
slurmdb_user_cond_t *user_cond)
{
char *query = NULL, *object = NULL, *extra = NULL, *last_user = NULL;
char *user_name = NULL;
time_t now = time(NULL);
int set = 0, is_admin=0, rc = SLURM_SUCCESS;
ListIterator itr = NULL;
slurmdb_user_rec_t *user_rec = NULL;
List ret_list = NULL;
List user_list = NULL;
MYSQL_RES *result = NULL;
MYSQL_ROW row;
slurmdb_user_rec_t user;
if (!user_cond && !acct_list) {
error("we need something to remove");
return NULL;
} else if (user_cond && user_cond->assoc_cond)
user_list = user_cond->assoc_cond->user_list;
if (check_connection(mysql_conn) != SLURM_SUCCESS)
return NULL;
memset(&user, 0, sizeof(slurmdb_user_rec_t));
user.uid = uid;
if (!(is_admin = is_user_min_admin_level(
mysql_conn, uid, SLURMDB_ADMIN_OPERATOR))) {
if (!is_user_any_coord(mysql_conn, &user)) {
error("Only admins/coordinators can "
"remove coordinators");
errno = ESLURM_ACCESS_DENIED;
return NULL;
}
}
/* Leave it this way since we are using extra below */
if (user_list && list_count(user_list)) {
set = 0;
if (extra)
xstrcat(extra, " && (");
else
xstrcat(extra, "(");
itr = list_iterator_create(user_list);
while ((object = list_next(itr))) {
if (!object[0])
continue;
if (set)
xstrcat(extra, " || ");
xstrfmtcat(extra, "user='******'", object);
set = 1;
}
list_iterator_destroy(itr);
xstrcat(extra, ")");
}
if (acct_list && list_count(acct_list)) {
set = 0;
if (extra)
xstrcat(extra, " && (");
else
xstrcat(extra, "(");
itr = list_iterator_create(acct_list);
while ((object = list_next(itr))) {
if (!object[0])
continue;
if (set)
xstrcat(extra, " || ");
xstrfmtcat(extra, "acct='%s'", object);
set = 1;
}
list_iterator_destroy(itr);
xstrcat(extra, ")");
}
if (!extra) {
errno = SLURM_ERROR;
debug3("No conditions given");
return NULL;
}
query = xstrdup_printf(
"select user, acct from %s where deleted=0 && %s order by user",
acct_coord_table, extra);
debug3("%d(%s:%d) query\n%s",
mysql_conn->conn, THIS_FILE, __LINE__, query);
if (!(result =
mysql_db_query_ret(mysql_conn, query, 0))) {
xfree(query);
xfree(extra);
errno = SLURM_ERROR;
return NULL;
}
xfree(query);
ret_list = list_create(slurm_destroy_char);
user_list = list_create(slurm_destroy_char);
while ((row = mysql_fetch_row(result))) {
if (!is_admin) {
slurmdb_coord_rec_t *coord = NULL;
if (!user.coord_accts) { // This should never
// happen
error("We are here with no coord accts");
errno = ESLURM_ACCESS_DENIED;
list_destroy(ret_list);
list_destroy(user_list);
xfree(extra);
mysql_free_result(result);
return NULL;
}
itr = list_iterator_create(user.coord_accts);
while ((coord = list_next(itr))) {
if (!strcasecmp(coord->name, row[1]))
break;
}
list_iterator_destroy(itr);
if (!coord) {
error("User %s(%d) does not have the "
"ability to change this account (%s)",
user.name, user.uid, row[1]);
errno = ESLURM_ACCESS_DENIED;
list_destroy(ret_list);
list_destroy(user_list);
xfree(extra);
mysql_free_result(result);
return NULL;
}
}
if (!last_user || strcasecmp(last_user, row[0])) {
list_append(user_list, xstrdup(row[0]));
last_user = row[0];
}
list_append(ret_list, xstrdup_printf("U = %-9s A = %-10s",
row[0], row[1]));
}
mysql_free_result(result);
user_name = uid_to_string((uid_t) uid);
rc = remove_common(mysql_conn, DBD_REMOVE_ACCOUNT_COORDS,
now, user_name, acct_coord_table,
extra, NULL, NULL, NULL, NULL);
xfree(user_name);
xfree(extra);
if (rc == SLURM_ERROR) {
list_destroy(ret_list);
list_destroy(user_list);
errno = SLURM_ERROR;
return NULL;
}
/* get the update list set */
itr = list_iterator_create(user_list);
while ((last_user = list_next(itr))) {
user_rec = xmalloc(sizeof(slurmdb_user_rec_t));
user_rec->name = xstrdup(last_user);
_get_user_coords(mysql_conn, user_rec);
if (addto_update_list(mysql_conn->update_list,
SLURMDB_REMOVE_COORD, user_rec)
!= SLURM_SUCCESS)
slurmdb_destroy_user_rec(user_rec);
}
list_iterator_destroy(itr);
list_destroy(user_list);
return ret_list;
}
extern int as_mysql_get_usage(mysql_conn_t *mysql_conn, uid_t uid,
void *in, slurmdbd_msg_type_t type,
time_t start, time_t end)
{
int rc = SLURM_SUCCESS;
int i=0, is_admin=1;
MYSQL_RES *result = NULL;
MYSQL_ROW row;
char *tmp = NULL;
char *my_usage_table = NULL;
slurmdb_association_rec_t *slurmdb_assoc = in;
slurmdb_wckey_rec_t *slurmdb_wckey = in;
char *query = NULL;
char *username = NULL;
uint16_t private_data = 0;
slurmdb_user_rec_t user;
List *my_list;
uint32_t id = NO_VAL;
char *cluster_name = NULL;
char **usage_req_inx = NULL;
enum {
USAGE_ID,
USAGE_START,
USAGE_ACPU,
USAGE_COUNT,
USAGE_ENERGY
};
switch (type) {
case DBD_GET_ASSOC_USAGE:
{
char *temp_usage[] = {
"t3.id_assoc",
"t1.time_start",
"t1.alloc_cpu_secs"
};
usage_req_inx = temp_usage;
id = slurmdb_assoc->id;
cluster_name = slurmdb_assoc->cluster;
username = slurmdb_assoc->user;
my_list = &slurmdb_assoc->accounting_list;
my_usage_table = assoc_day_table;
break;
}
case DBD_GET_WCKEY_USAGE:
{
char *temp_usage[] = {
"id_wckey",
"time_start",
"alloc_cpu_secs"
};
usage_req_inx = temp_usage;
id = slurmdb_wckey->id;
cluster_name = slurmdb_wckey->cluster;
username = slurmdb_wckey->user;
my_list = &slurmdb_wckey->accounting_list;
my_usage_table = wckey_day_table;
break;
}
case DBD_GET_CLUSTER_USAGE:
{
return _get_cluster_usage(mysql_conn, uid, in,
type, start, end);
break;
}
default:
error("Unknown usage type %d", type);
return SLURM_ERROR;
break;
}
if (!id) {
error("We need an id to set data for getting usage");
return SLURM_ERROR;
} else if (!cluster_name) {
error("We need a cluster_name to set data for getting usage");
return SLURM_ERROR;
}
if (check_connection(mysql_conn) != SLURM_SUCCESS)
return ESLURM_DB_CONNECTION;
memset(&user, 0, sizeof(slurmdb_user_rec_t));
user.uid = uid;
private_data = slurm_get_private_data();
if (private_data & PRIVATE_DATA_USAGE) {
if (!(is_admin = is_user_min_admin_level(
mysql_conn, uid, SLURMDB_ADMIN_OPERATOR))) {
ListIterator itr = NULL;
slurmdb_coord_rec_t *coord = NULL;
if (username && !strcmp(slurmdb_assoc->user, user.name))
goto is_user;
if (type != DBD_GET_ASSOC_USAGE)
goto bad_user;
if (!slurmdb_assoc->acct) {
debug("No account name given "
"in association.");
goto bad_user;
}
if (!is_user_any_coord(mysql_conn, &user)) {
debug4("This user is not a coordinator.");
goto bad_user;
}
/* Existance of user.coord_accts is checked in
is_user_any_coord.
*/
itr = list_iterator_create(user.coord_accts);
while ((coord = list_next(itr)))
if (!strcasecmp(coord->name,
slurmdb_assoc->acct))
break;
list_iterator_destroy(itr);
if (coord)
goto is_user;
bad_user:
errno = ESLURM_ACCESS_DENIED;
return SLURM_ERROR;
}
}
is_user:
if (set_usage_information(&my_usage_table, type, &start, &end)
!= SLURM_SUCCESS) {
return SLURM_ERROR;
}
xfree(tmp);
i=0;
xstrfmtcat(tmp, "%s", usage_req_inx[i]);
for(i=1; i<USAGE_COUNT; i++) {
xstrfmtcat(tmp, ", %s", usage_req_inx[i]);
}
switch (type) {
case DBD_GET_ASSOC_USAGE:
query = xstrdup_printf(
"select %s from \"%s_%s\" as t1, "
"\"%s_%s\" as t2, \"%s_%s\" as t3 "
"where (t1.time_start < %ld && t1.time_start >= %ld) "
"&& t1.id_assoc=t2.id_assoc && t3.id_assoc=%d && "
"t2.lft between t3.lft and t3.rgt "
"order by t3.id_assoc, time_start;",
tmp, cluster_name, my_usage_table,
cluster_name, cluster_name, assoc_table, assoc_table,
end, start, id);
break;
case DBD_GET_WCKEY_USAGE:
query = xstrdup_printf(
"select %s from \"%s_%s\" "
"where (time_start < %ld && time_start >= %ld) "
"&& id_wckey=%d order by id_wckey, time_start;",
tmp, cluster_name, my_usage_table, end, start, id);
break;
default:
error("Unknown usage type %d", type);
return SLURM_ERROR;
break;
}
xfree(tmp);
debug4("%d(%s:%d) query\n%s",
mysql_conn->conn, THIS_FILE, __LINE__, query);
if (!(result = mysql_db_query_ret(
mysql_conn, query, 0))) {
xfree(query);
return SLURM_ERROR;
}
xfree(query);
if (!(*my_list))
(*my_list) = list_create(slurmdb_destroy_accounting_rec);
while ((row = mysql_fetch_row(result))) {
slurmdb_accounting_rec_t *accounting_rec =
xmalloc(sizeof(slurmdb_accounting_rec_t));
accounting_rec->id = slurm_atoul(row[USAGE_ID]);
accounting_rec->period_start = slurm_atoul(row[USAGE_START]);
accounting_rec->alloc_secs = slurm_atoull(row[USAGE_ACPU]);
accounting_rec->consumed_energy = slurm_atoull(row[USAGE_ENERGY]);
list_append((*my_list), accounting_rec);
}
mysql_free_result(result);
return rc;
}
extern List as_mysql_jobacct_process_get_jobs(mysql_conn_t *mysql_conn,
uid_t uid,
slurmdb_job_cond_t *job_cond)
{
char *extra = NULL;
char *tmp = NULL, *tmp2 = NULL;
ListIterator itr = NULL;
int is_admin=1;
int i;
List job_list = NULL;
uint16_t private_data = 0;
slurmdb_user_rec_t user;
int only_pending = 0;
List use_cluster_list = as_mysql_cluster_list;
char *cluster_name;
assoc_mgr_lock_t locks = { NO_LOCK, NO_LOCK, NO_LOCK, NO_LOCK,
READ_LOCK, NO_LOCK, NO_LOCK };
memset(&user, 0, sizeof(slurmdb_user_rec_t));
user.uid = uid;
private_data = slurm_get_private_data();
if (private_data & PRIVATE_DATA_JOBS) {
if (!(is_admin = is_user_min_admin_level(
mysql_conn, uid, SLURMDB_ADMIN_OPERATOR))) {
/* Only fill in the coordinator accounts here
we will check them later when we actually
try to get the jobs.
*/
is_user_any_coord(mysql_conn, &user);
}
if (!is_admin && !user.name) {
debug("User %u has no assocations, and is not admin, "
"so not returning any jobs.", user.uid);
return NULL;
}
}
if (job_cond
&& job_cond->state_list && (list_count(job_cond->state_list) == 1)
&& (slurm_atoul(list_peek(job_cond->state_list)) == JOB_PENDING))
only_pending = 1;
setup_job_cond_limits(job_cond, &extra);
xfree(tmp);
xstrfmtcat(tmp, "%s", job_req_inx[0]);
for(i=1; i<JOB_REQ_COUNT; i++) {
xstrfmtcat(tmp, ", %s", job_req_inx[i]);
}
xfree(tmp2);
xstrfmtcat(tmp2, "%s", step_req_inx[0]);
for(i=1; i<STEP_REQ_COUNT; i++) {
xstrfmtcat(tmp2, ", %s", step_req_inx[i]);
}
if (job_cond
&& job_cond->cluster_list && list_count(job_cond->cluster_list))
use_cluster_list = job_cond->cluster_list;
else
slurm_mutex_lock(&as_mysql_cluster_list_lock);
assoc_mgr_lock(&locks);
job_list = list_create(slurmdb_destroy_job_rec);
itr = list_iterator_create(use_cluster_list);
while ((cluster_name = list_next(itr))) {
int rc;
if ((rc = _cluster_get_jobs(mysql_conn, &user, job_cond,
cluster_name, tmp, tmp2, extra,
is_admin, only_pending, job_list))
!= SLURM_SUCCESS)
error("Problem getting jobs for cluster %s",
cluster_name);
}
list_iterator_destroy(itr);
assoc_mgr_unlock(&locks);
if (use_cluster_list == as_mysql_cluster_list)
slurm_mutex_unlock(&as_mysql_cluster_list_lock);
xfree(tmp);
xfree(tmp2);
xfree(extra);
return job_list;
}
extern int as_mysql_add_wckeys(mysql_conn_t *mysql_conn, uint32_t uid,
List wckey_list)
{
ListIterator itr = NULL;
int rc = SLURM_SUCCESS;
slurmdb_wckey_rec_t *object = NULL;
char *cols = NULL, *extra = NULL, *vals = NULL, *query = NULL,
*tmp_extra = NULL;
time_t now = time(NULL);
char *user_name = NULL;
int affect_rows = 0;
int added = 0;
List added_user_list = NULL;
if (check_connection(mysql_conn) != SLURM_SUCCESS)
return ESLURM_DB_CONNECTION;
if (!is_user_min_admin_level(mysql_conn, uid, SLURMDB_ADMIN_OPERATOR))
return ESLURM_ACCESS_DENIED;
user_name = uid_to_string((uid_t) uid);
itr = list_iterator_create(wckey_list);
while ((object = list_next(itr))) {
if (!object->cluster || !object->cluster[0]
|| !object->user || !object->user[0]
|| !object->name) {
error("We need a wckey name (%s), cluster (%s), "
"and user (%s) to add.",
object->name, object->cluster, object->user);
rc = SLURM_ERROR;
continue;
}
if (!added_user_list)
added_user_list = list_create(NULL);
list_append(added_user_list, object->user);
xstrcat(cols, "creation_time, mod_time, user");
xstrfmtcat(vals, "%ld, %ld, '%s'",
now, now, object->user);
xstrfmtcat(extra, ", mod_time=%ld, user='******'",
now, object->user);
if (object->name) {
xstrcat(cols, ", wckey_name");
xstrfmtcat(vals, ", '%s'", object->name);
xstrfmtcat(extra, ", wckey_name='%s'", object->name);
}
/* When adding, if this isn't a default might as well
force it to be 0 to avoid confusion since
uninitialized it is NO_VAL.
*/
if (object->is_def == 1) {
xstrcat(cols, ", is_def");
xstrcat(vals, ", 1");
xstrcat(extra, ", is_def=1");
} else {
object->is_def = 0;
xstrcat(cols, ", is_def");
xstrcat(vals, ", 0");
xstrcat(extra, ", is_def=0");
}
xstrfmtcat(query,
"insert into \"%s_%s\" (%s) values (%s) "
"on duplicate key update deleted=0, "
"id_wckey=LAST_INSERT_ID(id_wckey)%s;",
object->cluster, wckey_table, cols, vals, extra);
if (debug_flags & DEBUG_FLAG_DB_WCKEY)
DB_DEBUG(mysql_conn->conn, "query\n%s", query);
object->id = mysql_db_insert_ret_id(mysql_conn, query);
xfree(query);
if (!object->id) {
error("Couldn't add wckey %s", object->name);
added=0;
xfree(cols);
xfree(extra);
xfree(vals);
break;
}
affect_rows = last_affected_rows(mysql_conn);
if (!affect_rows) {
debug2("nothing changed %d", affect_rows);
xfree(cols);
xfree(extra);
xfree(vals);
continue;
}
/* we always have a ', ' as the first 2 chars */
tmp_extra = slurm_add_slash_to_quotes(extra+2);
xstrfmtcat(query,
"insert into %s "
"(timestamp, action, name, actor, info, cluster) "
"values (%ld, %u, 'id_wckey=%d', '%s', '%s', '%s');",
txn_table,
now, DBD_ADD_WCKEYS, object->id, user_name,
tmp_extra, object->cluster);
xfree(tmp_extra);
xfree(cols);
xfree(extra);
xfree(vals);
debug4("query\n%s",query);
rc = mysql_db_query(mysql_conn, query);
xfree(query);
if (rc != SLURM_SUCCESS) {
error("Couldn't add txn");
} else {
if (addto_update_list(mysql_conn->update_list,
SLURMDB_ADD_WCKEY,
object) == SLURM_SUCCESS)
list_remove(itr);
added++;
}
}
list_iterator_destroy(itr);
xfree(user_name);
if (!added) {
reset_mysql_conn(mysql_conn);
goto end_it;
}
/* now reset all the other defaults accordingly. (if needed) */
itr = list_iterator_create(wckey_list);
while ((object = list_next(itr))) {
if ((object->is_def != 1) || !object->cluster
|| !object->user || !object->name)
continue;
if ((rc = _reset_default_wckey(mysql_conn, object)
!= SLURM_SUCCESS))
break;
}
list_iterator_destroy(itr);
end_it:
if (rc == SLURM_SUCCESS)
_make_sure_users_have_default(mysql_conn, added_user_list);
if (added_user_list)
list_destroy(added_user_list);
return rc;
}
extern List as_mysql_modify_clusters(mysql_conn_t *mysql_conn, uint32_t uid,
slurmdb_cluster_cond_t *cluster_cond,
slurmdb_cluster_rec_t *cluster)
{
List ret_list = NULL;
int rc = SLURM_SUCCESS;
char *object = NULL;
char *vals = NULL, *extra = NULL, *query = NULL,
*name_char = NULL, *send_char = NULL;
time_t now = time(NULL);
char *user_name = NULL;
int set = 0;
MYSQL_RES *result = NULL;
MYSQL_ROW row;
bool clust_reg = false;
/* If you need to alter the default values of the cluster use
* modify_assocs since this is used only for registering
* the controller when it loads
*/
if (!cluster_cond || !cluster) {
error("we need something to change");
return NULL;
}
if (check_connection(mysql_conn) != SLURM_SUCCESS)
return NULL;
if (!is_user_min_admin_level(mysql_conn, uid,
SLURMDB_ADMIN_SUPER_USER)) {
errno = ESLURM_ACCESS_DENIED;
return NULL;
}
/* force to only do non-deleted clusters */
cluster_cond->with_deleted = 0;
_setup_cluster_cond_limits(cluster_cond, &extra);
/* Needed if talking to older SLURM versions < 2.2 */
if (!mysql_conn->cluster_name && cluster_cond->cluster_list
&& list_count(cluster_cond->cluster_list))
mysql_conn->cluster_name =
xstrdup(list_peek(cluster_cond->cluster_list));
set = 0;
if (cluster->control_host) {
xstrfmtcat(vals, ", control_host='%s'", cluster->control_host);
set++;
clust_reg = true;
}
if (cluster->control_port) {
xstrfmtcat(vals, ", control_port=%u, last_port=%u",
cluster->control_port, cluster->control_port);
set++;
clust_reg = true;
}
if (cluster->rpc_version) {
xstrfmtcat(vals, ", rpc_version=%u", cluster->rpc_version);
set++;
clust_reg = true;
}
if (cluster->dimensions) {
xstrfmtcat(vals, ", dimensions=%u", cluster->dimensions);
clust_reg = true;
}
if (cluster->plugin_id_select) {
xstrfmtcat(vals, ", plugin_id_select=%u",
cluster->plugin_id_select);
clust_reg = true;
}
if (cluster->flags != NO_VAL) {
xstrfmtcat(vals, ", flags=%u", cluster->flags);
clust_reg = true;
}
if (cluster->classification) {
xstrfmtcat(vals, ", classification=%u",
cluster->classification);
}
if (!vals) {
xfree(extra);
errno = SLURM_NO_CHANGE_IN_DATA;
error("Nothing to change");
return NULL;
} else if (clust_reg && (set != 3)) {
xfree(vals);
xfree(extra);
errno = EFAULT;
error("Need control host, port and rpc version "
"to register a cluster");
return NULL;
}
xstrfmtcat(query, "select name, control_port from %s%s;",
cluster_table, 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);
error("no result given for %s", extra);
xfree(extra);
return NULL;
}
xfree(extra);
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(name_char);
xfree(vals);
xfree(query);
return ret_list;
}
xfree(query);
if (vals) {
send_char = xstrdup_printf("(%s)", name_char);
user_name = uid_to_string((uid_t) uid);
rc = modify_common(mysql_conn, DBD_MODIFY_CLUSTERS, now,
user_name, cluster_table,
send_char, vals, NULL);
xfree(user_name);
if (rc == SLURM_ERROR) {
error("Couldn't modify cluster 1");
FREE_NULL_LIST(ret_list);
ret_list = NULL;
goto end_it;
}
}
end_it:
xfree(name_char);
xfree(vals);
xfree(send_char);
return ret_list;
}
extern List as_mysql_modify_wckeys(mysql_conn_t *mysql_conn,
uint32_t uid,
slurmdb_wckey_cond_t *wckey_cond,
slurmdb_wckey_rec_t *wckey)
{
List ret_list = NULL;
int rc = SLURM_SUCCESS;
char *extra = NULL, *object = NULL, *vals = NULL;
char *user_name = NULL;
List use_cluster_list = as_mysql_cluster_list;
ListIterator itr;
if (!wckey_cond || !wckey) {
error("we need something to change");
return NULL;
}
if (check_connection(mysql_conn) != SLURM_SUCCESS)
return NULL;
if (!is_user_min_admin_level(mysql_conn, uid, SLURMDB_ADMIN_OPERATOR)) {
if (wckey_cond->user_list
&& (list_count(wckey_cond->user_list) == 1)) {
uid_t pw_uid;
char *name;
name = list_peek(wckey_cond->user_list);
if ((uid_from_string (name, &pw_uid) >= 0)
&& (pw_uid == uid)) {
/* Make sure they aren't trying to
change something else and then set
this association as a default.
*/
slurmdb_init_wckey_rec(wckey, 1);
wckey->is_def = 1;
goto is_same_user;
}
}
error("Only admins can modify wckeys");
errno = ESLURM_ACCESS_DENIED;
return NULL;
}
is_same_user:
(void) _setup_wckey_cond_limits(wckey_cond, &extra);
if (wckey->is_def == 1)
xstrcat(vals, ", is_def=1");
if (!extra || !vals) {
error("Nothing to modify '%s' '%s'", extra, vals);
return NULL;
}
if (wckey_cond->cluster_list && list_count(wckey_cond->cluster_list))
use_cluster_list = wckey_cond->cluster_list;
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_modify_wckeys(
mysql_conn, wckey, object,
extra, vals, 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);
ret_list = NULL;
}
return ret_list;
}
extern List as_mysql_get_accts(mysql_conn_t *mysql_conn, uid_t uid,
slurmdb_account_cond_t *acct_cond)
{
char *query = NULL;
char *extra = NULL;
char *tmp = NULL;
List acct_list = NULL;
ListIterator itr = NULL;
char *object = NULL;
int set = 0;
int i=0, is_admin=1;
MYSQL_RES *result = NULL;
MYSQL_ROW row;
uint16_t private_data = 0;
slurmdb_user_rec_t user;
/* if this changes you will need to edit the corresponding enum */
char *acct_req_inx[] = {
"name",
"description",
"organization"
};
enum {
SLURMDB_REQ_NAME,
SLURMDB_REQ_DESC,
SLURMDB_REQ_ORG,
SLURMDB_REQ_COUNT
};
if (check_connection(mysql_conn) != SLURM_SUCCESS)
return NULL;
memset(&user, 0, sizeof(slurmdb_user_rec_t));
user.uid = uid;
private_data = slurm_get_private_data();
if (private_data & PRIVATE_DATA_ACCOUNTS) {
if (!(is_admin = is_user_min_admin_level(
mysql_conn, uid, SLURMDB_ADMIN_OPERATOR))) {
if (!is_user_any_coord(mysql_conn, &user)) {
error("Only admins/coordinators "
"can look at account usage");
errno = ESLURM_ACCESS_DENIED;
return NULL;
}
}
}
if (!acct_cond) {
xstrcat(extra, "where deleted=0");
goto empty;
}
if (acct_cond->with_deleted)
xstrcat(extra, "where (deleted=0 || deleted=1)");
else
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, ")");
}
empty:
xfree(tmp);
xstrfmtcat(tmp, "%s", acct_req_inx[i]);
for(i=1; i<SLURMDB_REQ_COUNT; i++) {
xstrfmtcat(tmp, ", %s", acct_req_inx[i]);
}
/* This is here to make sure we are looking at only this user
* if this flag is set. We also include any accounts they may be
* coordinator of.
*/
if (!is_admin && (private_data & PRIVATE_DATA_ACCOUNTS)) {
slurmdb_coord_rec_t *coord = NULL;
set = 0;
itr = list_iterator_create(user.coord_accts);
while ((coord = list_next(itr))) {
if (set) {
xstrfmtcat(extra, " || name='%s'",
coord->name);
} else {
set = 1;
xstrfmtcat(extra, " && (name='%s'",
coord->name);
}
}
list_iterator_destroy(itr);
if (set)
xstrcat(extra,")");
}
query = xstrdup_printf("select %s from %s %s", tmp, acct_table, extra);
xfree(tmp);
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);
return NULL;
}
xfree(query);
acct_list = list_create(slurmdb_destroy_account_rec);
if (acct_cond && acct_cond->assoc_cond && acct_cond->with_assocs) {
/* We are going to be freeing the inners of
this list in the acct->name so we don't
free it here
*/
if (acct_cond->assoc_cond->acct_list)
list_destroy(acct_cond->assoc_cond->acct_list);
acct_cond->assoc_cond->acct_list = list_create(NULL);
acct_cond->assoc_cond->with_deleted = acct_cond->with_deleted;
}
while ((row = mysql_fetch_row(result))) {
slurmdb_account_rec_t *acct =
xmalloc(sizeof(slurmdb_account_rec_t));
list_append(acct_list, acct);
acct->name = xstrdup(row[SLURMDB_REQ_NAME]);
acct->description = xstrdup(row[SLURMDB_REQ_DESC]);
acct->organization = xstrdup(row[SLURMDB_REQ_ORG]);
if (acct_cond && acct_cond->with_coords) {
_get_account_coords(mysql_conn, acct);
}
if (acct_cond && acct_cond->with_assocs) {
if (!acct_cond->assoc_cond) {
acct_cond->assoc_cond = xmalloc(
sizeof(slurmdb_association_cond_t));
}
list_append(acct_cond->assoc_cond->acct_list,
acct->name);
}
}
mysql_free_result(result);
if (acct_cond && acct_cond->with_assocs && acct_cond->assoc_cond
&& list_count(acct_cond->assoc_cond->acct_list)) {
ListIterator assoc_itr = NULL;
slurmdb_account_rec_t *acct = NULL;
slurmdb_association_rec_t *assoc = NULL;
List assoc_list = as_mysql_get_assocs(
mysql_conn, uid, acct_cond->assoc_cond);
if (!assoc_list) {
error("no associations");
return acct_list;
}
itr = list_iterator_create(acct_list);
assoc_itr = list_iterator_create(assoc_list);
while ((acct = list_next(itr))) {
while ((assoc = list_next(assoc_itr))) {
if (strcmp(assoc->acct, acct->name))
continue;
if (!acct->assoc_list)
acct->assoc_list = list_create(
slurmdb_destroy_association_rec);
list_append(acct->assoc_list, assoc);
list_remove(assoc_itr);
}
list_iterator_reset(assoc_itr);
if (!acct->assoc_list)
list_remove(itr);
}
list_iterator_destroy(itr);
list_iterator_destroy(assoc_itr);
list_destroy(assoc_list);
}
return acct_list;
}
/* The assoc_mgr locks should be unlocked before coming here. */
extern int as_mysql_get_usage(mysql_conn_t *mysql_conn, uid_t uid,
void *in, slurmdbd_msg_type_t type,
time_t start, time_t end)
{
int rc = SLURM_SUCCESS;
int is_admin=1;
char *my_usage_table = NULL;
slurmdb_assoc_rec_t *slurmdb_assoc = in;
slurmdb_wckey_rec_t *slurmdb_wckey = in;
char *username = NULL;
uint16_t private_data = 0;
List *my_list = NULL;
char *cluster_name = NULL;
char *id_str = NULL;
if (check_connection(mysql_conn) != SLURM_SUCCESS)
return ESLURM_DB_CONNECTION;
switch (type) {
case DBD_GET_ASSOC_USAGE:
if (!slurmdb_assoc->id) {
error("We need an id to set data for getting usage");
return SLURM_ERROR;
}
id_str = xstrdup_printf("t3.id_assoc=%u", slurmdb_assoc->id);
cluster_name = slurmdb_assoc->cluster;
username = slurmdb_assoc->user;
my_list = &slurmdb_assoc->accounting_list;
my_usage_table = assoc_day_table;
break;
case DBD_GET_WCKEY_USAGE:
if (!slurmdb_wckey->id) {
error("We need an id to set data for getting usage");
return SLURM_ERROR;
}
id_str = xstrdup_printf("id=%d", slurmdb_wckey->id);
cluster_name = slurmdb_wckey->cluster;
username = slurmdb_wckey->user;
my_list = &slurmdb_wckey->accounting_list;
my_usage_table = wckey_day_table;
break;
case DBD_GET_CLUSTER_USAGE:
rc = _get_cluster_usage(mysql_conn, uid, in,
type, start, end);
return rc;
break;
default:
error("Unknown usage type %d", type);
return SLURM_ERROR;
break;
}
if (!cluster_name) {
error("We need a cluster_name to set data for getting usage");
xfree(id_str);
return SLURM_ERROR;
}
private_data = slurm_get_private_data();
if (private_data & PRIVATE_DATA_USAGE) {
if (!(is_admin = is_user_min_admin_level(
mysql_conn, uid, SLURMDB_ADMIN_OPERATOR))) {
ListIterator itr = NULL;
slurmdb_coord_rec_t *coord = NULL;
slurmdb_user_rec_t user;
bool is_coord;
memset(&user, 0, sizeof(slurmdb_user_rec_t));
user.uid = uid;
is_coord = is_user_any_coord(mysql_conn, &user);
if (username && !strcmp(username, user.name))
goto is_user;
if (type != DBD_GET_ASSOC_USAGE)
goto bad_user;
if (!slurmdb_assoc->acct) {
debug("No account name given "
"in association.");
goto bad_user;
}
if (!is_coord) {
debug4("This user is not a coordinator.");
goto bad_user;
}
/* Existance of user.coord_accts is checked in
is_user_any_coord.
*/
itr = list_iterator_create(user.coord_accts);
while ((coord = list_next(itr)))
if (!strcasecmp(coord->name,
slurmdb_assoc->acct))
break;
list_iterator_destroy(itr);
if (coord)
goto is_user;
bad_user:
errno = ESLURM_ACCESS_DENIED;
xfree(id_str);
return SLURM_ERROR;
}
}
is_user:
if (set_usage_information(&my_usage_table, type, &start, &end)
!= SLURM_SUCCESS) {
xfree(id_str);
return SLURM_ERROR;
}
_get_object_usage(mysql_conn, type, my_usage_table, cluster_name,
id_str, start, end, my_list);
xfree(id_str);
return rc;
}
