static char *_get_user_from_associd(mysql_conn_t *mysql_conn,
char *cluster, uint32_t associd)
{
char *user = NULL;
char *query = NULL;
MYSQL_RES *result = NULL;
MYSQL_ROW row;
/* Just so we don't have to keep a
cache of the associations around we
will just query the db for the user
name of the association id. Since
this should sort of be a rare case
this isn't too bad.
*/
query = xstrdup_printf("select user from \"%s_%s\" where id_assoc=%u",
cluster, assoc_table, associd);
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 NULL;
}
xfree(query);
if ((row = mysql_fetch_row(result)))
user = xstrdup(row[0]);
mysql_free_result(result);
return user;
}
/* Used in job functions for getting the database index based off the
* submit time, job and assoc id. 0 is returned if none is found
*/
static int _get_db_index(mysql_conn_t *mysql_conn,
time_t submit, uint32_t jobid, uint32_t associd)
{
MYSQL_RES *result = NULL;
MYSQL_ROW row;
int db_index = 0;
char *query = xstrdup_printf("select job_db_inx from \"%s_%s\" where "
"time_submit=%d and id_job=%u "
"and id_assoc=%u",
mysql_conn->cluster_name, job_table,
(int)submit, jobid, associd);
if (!(result = mysql_db_query_ret(mysql_conn, query, 0))) {
xfree(query);
return 0;
}
xfree(query);
row = mysql_fetch_row(result);
if (!row) {
mysql_free_result(result);
debug4("We can't get a db_index for this combo, "
"time_submit=%d and id_job=%u and id_assoc=%u. "
"We must not have heard about the start yet, "
"no big deal, we will get one right after this.",
(int)submit, jobid, associd);
return 0;
}
db_index = slurm_atoul(row[0]);
mysql_free_result(result);
return db_index;
}
static int _reset_default_wckey(mysql_conn_t *mysql_conn,
slurmdb_wckey_rec_t *wckey)
{
time_t now = time(NULL);
int rc = SLURM_SUCCESS;
char *query = NULL;
MYSQL_RES *result = NULL;
MYSQL_ROW row;
if ((wckey->is_def != 1)
|| !wckey->cluster || !wckey->user || !wckey->name)
return SLURM_ERROR;
xstrfmtcat(query, "update \"%s_%s\" set is_def=0, mod_time=%ld "
"where (user='******' && wckey_name!='%s' && is_def=1);"
"select id_wckey from \"%s_%s\" "
"where (user='******' && wckey_name!='%s' && is_def=1);",
wckey->cluster, wckey_table, (long)now,
wckey->user, wckey->name,
wckey->cluster, wckey_table,
wckey->user, wckey->name);
if (debug_flags & DEBUG_FLAG_DB_WCKEY)
DB_DEBUG(mysql_conn->conn, "query\n%s", query);
if (!(result = mysql_db_query_ret(mysql_conn, query, 1))) {
xfree(query);
rc = SLURM_ERROR;
goto end_it;
}
xfree(query);
while ((row = mysql_fetch_row(result))) {
slurmdb_wckey_rec_t *mod_wckey =
xmalloc(sizeof(slurmdb_wckey_rec_t));
slurmdb_init_wckey_rec(mod_wckey, 0);
mod_wckey->id = slurm_atoul(row[0]);
mod_wckey->is_def = 0;
if (addto_update_list(mysql_conn->update_list,
SLURMDB_MODIFY_WCKEY,
mod_wckey)
!= SLURM_SUCCESS) {
slurmdb_destroy_wckey_rec(mod_wckey);
error("couldn't add to the update list");
rc = SLURM_ERROR;
break;
}
}
mysql_free_result(result);
end_it:
return rc;
}
static local_cluster_usage_t *_setup_cluster_usage(mysql_conn_t *mysql_conn,
char *cluster_name,
time_t curr_start,
time_t curr_end,
List cluster_down_list)
{
local_cluster_usage_t *c_usage = NULL;
char *query = NULL;
MYSQL_RES *result = NULL;
MYSQL_ROW row;
int i = 0;
ListIterator c_itr = NULL;
local_cluster_usage_t *loc_c_usage;
char *event_req_inx[] = {
"node_name",
"cpu_count",
"time_start",
"time_end",
"state",
};
char *event_str = NULL;
enum {
EVENT_REQ_NAME,
EVENT_REQ_CPU,
EVENT_REQ_START,
EVENT_REQ_END,
EVENT_REQ_STATE,
EVENT_REQ_COUNT
};
xstrfmtcat(event_str, "%s", event_req_inx[i]);
for(i=1; i<EVENT_REQ_COUNT; i++) {
xstrfmtcat(event_str, ", %s", event_req_inx[i]);
}
/* first get the events during this time. All that is
* except things with the maintainance flag set in the
* state. We handle those later with the reservations.
*/
query = xstrdup_printf("select %s from \"%s_%s\" where "
"!(state & %d) && (time_start < %ld "
"&& (time_end >= %ld "
"|| time_end = 0)) "
"order by node_name, time_start",
event_str, cluster_name, event_table,
NODE_STATE_MAINT,
curr_end, curr_start);
xfree(event_str);
if (debug_flags & DEBUG_FLAG_DB_USAGE)
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);
c_itr = list_iterator_create(cluster_down_list);
while ((row = mysql_fetch_row(result))) {
time_t row_start = slurm_atoul(row[EVENT_REQ_START]);
time_t row_end = slurm_atoul(row[EVENT_REQ_END]);
uint32_t row_cpu = slurm_atoul(row[EVENT_REQ_CPU]);
uint16_t state = slurm_atoul(row[EVENT_REQ_STATE]);
if (row_start < curr_start)
row_start = curr_start;
if (!row_end || row_end > curr_end)
row_end = curr_end;
/* Don't worry about it if the time is less
* than 1 second.
*/
if ((row_end - row_start) < 1)
continue;
/* this means we are a cluster registration
entry */
if (!row[EVENT_REQ_NAME][0]) {
/* if the cpu count changes we will
* only care about the last cpu count but
* we will keep a total of the time for
* all cpus to get the correct cpu time
* for the entire period.
*/
if (state || !c_usage) {
loc_c_usage = xmalloc(
sizeof(local_cluster_usage_t));
loc_c_usage->cpu_count = row_cpu;
loc_c_usage->total_time =
(row_end - row_start) * row_cpu;
loc_c_usage->start = row_start;
loc_c_usage->end = row_end;
/* If this has a state it
means the slurmctld went
down and we should put this
on the list and remove any
jobs from this time that
were running later.
*/
if (state)
list_append(cluster_down_list,
loc_c_usage);
else
c_usage = loc_c_usage;
loc_c_usage = NULL;
} else {
c_usage->cpu_count = row_cpu;
c_usage->total_time +=
(row_end - row_start) * row_cpu;
c_usage->end = row_end;
}
continue;
}
/* only record down time for the cluster we
are looking for. If it was during this
time period we would already have it.
*/
if (c_usage) {
time_t local_start = row_start;
time_t local_end = row_end;
int seconds;
if (c_usage->start > local_start)
local_start = c_usage->start;
if (c_usage->end < local_end)
local_end = c_usage->end;
seconds = (local_end - local_start);
if (seconds > 0) {
/* info("%p node %s adds " */
/* "(%d)(%ld-%ld) * %d = %"PRIu64" " */
/* "to %"PRIu64" (%s - %s)", */
/* c_usage, */
/* row[EVENT_REQ_NAME], */
/* seconds, */
/* local_end, local_start, */
/* row_cpu, */
/* seconds * (uint64_t)row_cpu, */
/* c_usage->d_cpu, */
/* slurm_ctime(&local_start), */
/* slurm_ctime(&local_end)); */
c_usage->d_cpu += seconds * (uint64_t)row_cpu;
/* Now remove this time if there was a
disconnected slurmctld during the
down time.
*/
list_iterator_reset(c_itr);
while ((loc_c_usage = list_next(c_itr))) {
int temp_end = row_end;
int temp_start = row_start;
if (loc_c_usage->start > local_start)
temp_start = loc_c_usage->start;
if (loc_c_usage->end < temp_end)
temp_end = loc_c_usage->end;
seconds = (temp_end - temp_start);
if (seconds < 1)
continue;
seconds *= row_cpu;
if (seconds >= loc_c_usage->total_time)
loc_c_usage->total_time = 0;
else
loc_c_usage->total_time -=
seconds;
/* info("Node %s was down for " */
/* "%d seconds while " */
/* "cluster %s's slurmctld " */
/* "wasn't responding %"PRIu64, */
/* row[EVENT_REQ_NAME], */
/* seconds, cluster_name, */
/* loc_c_usage->total_time); */
}
}
}
}
mysql_free_result(result);
list_iterator_destroy(c_itr);
return c_usage;
}
/* Fill in all the users that are coordinator for this account. This
* will fill in if there are coordinators from a parent account also.
*/
static int _get_account_coords(mysql_conn_t *mysql_conn,
slurmdb_account_rec_t *acct)
{
char *query = NULL, *cluster_name = NULL;
slurmdb_coord_rec_t *coord = NULL;
MYSQL_RES *result = NULL;
MYSQL_ROW row;
ListIterator itr;
if (!acct) {
error("We need a account to fill in.");
return SLURM_ERROR;
}
if (!acct->coordinators)
acct->coordinators = list_create(slurmdb_destroy_coord_rec);
query = xstrdup_printf(
"select user from %s where acct='%s' && deleted=0",
acct_coord_table, acct->name);
if (!(result =
mysql_db_query_ret(mysql_conn, query, 0))) {
xfree(query);
return SLURM_ERROR;
}
xfree(query);
while ((row = mysql_fetch_row(result))) {
coord = xmalloc(sizeof(slurmdb_coord_rec_t));
list_append(acct->coordinators, coord);
coord->name = xstrdup(row[0]);
coord->direct = 1;
}
mysql_free_result(result);
slurm_mutex_lock(&as_mysql_cluster_list_lock);
itr = list_iterator_create(as_mysql_cluster_list);
while ((cluster_name = list_next(itr))) {
if (query)
xstrcat(query, " union ");
xstrfmtcat(query,
"select distinct t0.user from %s as t0, "
"\"%s_%s\" as t1, \"%s_%s\" as t2 "
"where t0.acct=t1.acct && "
"t1.lft<t2.lft && t1.rgt>t2.lft && "
"t1.user='' && t2.acct='%s' "
"&& t1.acct!='%s' && !t0.deleted",
acct_coord_table, cluster_name, assoc_table,
cluster_name, assoc_table,
acct->name, acct->name);
}
list_iterator_destroy(itr);
slurm_mutex_unlock(&as_mysql_cluster_list_lock);
if (!query) {
error("No clusters defined? How could there be accts?");
return SLURM_SUCCESS;
}
xstrcat(query, ";");
if (!(result = mysql_db_query_ret(mysql_conn, query, 0))) {
xfree(query);
return SLURM_ERROR;
}
xfree(query);
while ((row = mysql_fetch_row(result))) {
coord = xmalloc(sizeof(slurmdb_coord_rec_t));
list_append(acct->coordinators, coord);
coord->name = xstrdup(row[0]);
coord->direct = 0;
}
mysql_free_result(result);
return SLURM_SUCCESS;
}
extern List as_mysql_modify_accts(mysql_conn_t *mysql_conn, uint32_t uid,
slurmdb_account_cond_t *acct_cond,
slurmdb_account_rec_t *acct)
{
ListIterator itr = NULL;
List ret_list = NULL;
int rc = SLURM_SUCCESS;
char *object = NULL;
char *vals = NULL, *extra = NULL, *query = NULL, *name_char = NULL;
time_t now = time(NULL);
char *user_name = NULL;
int set = 0;
MYSQL_RES *result = NULL;
MYSQL_ROW row;
if (!acct_cond || !acct) {
error("we need something to change");
return NULL;
}
if (check_connection(mysql_conn) != SLURM_SUCCESS)
return NULL;
xstrcat(extra, "where deleted=0");
if (acct_cond->assoc_cond
&& acct_cond->assoc_cond->acct_list
&& list_count(acct_cond->assoc_cond->acct_list)) {
set = 0;
xstrcat(extra, " && (");
itr = list_iterator_create(acct_cond->assoc_cond->acct_list);
while ((object = list_next(itr))) {
if (set)
xstrcat(extra, " || ");
xstrfmtcat(extra, "name='%s'", object);
set = 1;
}
list_iterator_destroy(itr);
xstrcat(extra, ")");
}
if (acct_cond->description_list
&& list_count(acct_cond->description_list)) {
set = 0;
xstrcat(extra, " && (");
itr = list_iterator_create(acct_cond->description_list);
while ((object = list_next(itr))) {
if (set)
xstrcat(extra, " || ");
xstrfmtcat(extra, "description='%s'", object);
set = 1;
}
list_iterator_destroy(itr);
xstrcat(extra, ")");
}
if (acct_cond->organization_list
&& list_count(acct_cond->organization_list)) {
set = 0;
xstrcat(extra, " && (");
itr = list_iterator_create(acct_cond->organization_list);
while ((object = list_next(itr))) {
if (set)
xstrcat(extra, " || ");
xstrfmtcat(extra, "organization='%s'", object);
set = 1;
}
list_iterator_destroy(itr);
xstrcat(extra, ")");
}
if (acct->description)
xstrfmtcat(vals, ", description='%s'", acct->description);
if (acct->organization)
xstrfmtcat(vals, ", organization='%s'", acct->organization);
if (!extra || !vals) {
errno = SLURM_NO_CHANGE_IN_DATA;
error("Nothing to change");
return NULL;
}
query = xstrdup_printf("select name from %s %s;", acct_table, extra);
xfree(extra);
if (debug_flags & DEBUG_FLAG_DB_ASSOC)
DB_DEBUG(mysql_conn->conn, "query\n%s", query);
if (!(result = mysql_db_query_ret(
mysql_conn, query, 0))) {
xfree(query);
xfree(vals);
return NULL;
}
rc = 0;
ret_list = list_create(slurm_destroy_char);
while ((row = mysql_fetch_row(result))) {
object = xstrdup(row[0]);
list_append(ret_list, object);
if (!rc) {
xstrfmtcat(name_char, "(name='%s'", object);
rc = 1;
} else {
xstrfmtcat(name_char, " || name='%s'", object);
}
}
mysql_free_result(result);
if (!list_count(ret_list)) {
errno = SLURM_NO_CHANGE_IN_DATA;
if (debug_flags & DEBUG_FLAG_DB_ASSOC)
DB_DEBUG(mysql_conn->conn,
"didn't effect anything\n%s", query);
xfree(query);
xfree(vals);
return ret_list;
}
xfree(query);
xstrcat(name_char, ")");
user_name = uid_to_string((uid_t) uid);
rc = modify_common(mysql_conn, DBD_MODIFY_ACCOUNTS, now,
user_name, acct_table, name_char, vals, NULL);
xfree(user_name);
if (rc == SLURM_ERROR) {
error("Couldn't modify accounts");
list_destroy(ret_list);
errno = SLURM_ERROR;
ret_list = NULL;
}
xfree(name_char);
xfree(vals);
return ret_list;
}
extern List as_mysql_get_clusters(mysql_conn_t *mysql_conn, uid_t uid,
slurmdb_cluster_cond_t *cluster_cond)
{
char *query = NULL;
char *extra = NULL;
char *tmp = NULL;
List cluster_list = NULL;
ListIterator itr = NULL;
int i=0;
MYSQL_RES *result = NULL;
MYSQL_ROW row;
slurmdb_assoc_cond_t assoc_cond;
ListIterator assoc_itr = NULL;
slurmdb_cluster_rec_t *cluster = NULL;
slurmdb_assoc_rec_t *assoc = NULL;
List assoc_list = NULL;
/* if this changes you will need to edit the corresponding enum */
char *cluster_req_inx[] = {
"name",
"classification",
"control_host",
"control_port",
"rpc_version",
"dimensions",
"flags",
"plugin_id_select"
};
enum {
CLUSTER_REQ_NAME,
CLUSTER_REQ_CLASS,
CLUSTER_REQ_CH,
CLUSTER_REQ_CP,
CLUSTER_REQ_VERSION,
CLUSTER_REQ_DIMS,
CLUSTER_REQ_FLAGS,
CLUSTER_REQ_PI_SELECT,
CLUSTER_REQ_COUNT
};
if (check_connection(mysql_conn) != SLURM_SUCCESS)
return NULL;
if (!cluster_cond) {
xstrcat(extra, " where deleted=0");
goto empty;
}
_setup_cluster_cond_limits(cluster_cond, &extra);
empty:
xfree(tmp);
i=0;
xstrfmtcat(tmp, "%s", cluster_req_inx[i]);
for(i=1; i<CLUSTER_REQ_COUNT; i++) {
xstrfmtcat(tmp, ", %s", cluster_req_inx[i]);
}
query = xstrdup_printf("select %s from %s%s",
tmp, cluster_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);
cluster_list = list_create(slurmdb_destroy_cluster_rec);
memset(&assoc_cond, 0, sizeof(slurmdb_assoc_cond_t));
if (cluster_cond) {
/* I don't think we want the with_usage flag here.
* We do need the with_deleted though. */
//assoc_cond.with_usage = cluster_cond->with_usage;
assoc_cond.with_deleted = cluster_cond->with_deleted;
}
assoc_cond.cluster_list = list_create(NULL);
while ((row = mysql_fetch_row(result))) {
MYSQL_RES *result2 = NULL;
MYSQL_ROW row2;
cluster = xmalloc(sizeof(slurmdb_cluster_rec_t));
list_append(cluster_list, cluster);
cluster->name = xstrdup(row[CLUSTER_REQ_NAME]);
list_append(assoc_cond.cluster_list, cluster->name);
cluster->classification = slurm_atoul(row[CLUSTER_REQ_CLASS]);
cluster->control_host = xstrdup(row[CLUSTER_REQ_CH]);
cluster->control_port = slurm_atoul(row[CLUSTER_REQ_CP]);
cluster->rpc_version = slurm_atoul(row[CLUSTER_REQ_VERSION]);
cluster->dimensions = slurm_atoul(row[CLUSTER_REQ_DIMS]);
cluster->flags = slurm_atoul(row[CLUSTER_REQ_FLAGS]);
cluster->plugin_id_select =
slurm_atoul(row[CLUSTER_REQ_PI_SELECT]);
query = xstrdup_printf(
"select tres, cluster_nodes from "
"\"%s_%s\" where time_end=0 and node_name='' limit 1",
cluster->name, event_table);
if (debug_flags & DEBUG_FLAG_DB_TRES)
DB_DEBUG(mysql_conn->conn, "query\n%s", query);
if (!(result2 = mysql_db_query_ret(mysql_conn, query, 0))) {
xfree(query);
continue;
}
xfree(query);
if ((row2 = mysql_fetch_row(result2))) {
cluster->tres_str = xstrdup(row2[0]);
if (row2[1] && row2[1][0])
cluster->nodes = xstrdup(row2[1]);
}
mysql_free_result(result2);
/* get the usage if requested */
if (cluster_cond && cluster_cond->with_usage) {
as_mysql_get_usage(
mysql_conn, uid, cluster,
DBD_GET_CLUSTER_USAGE,
cluster_cond->usage_start,
cluster_cond->usage_end);
}
}
mysql_free_result(result);
if (!list_count(assoc_cond.cluster_list)) {
FREE_NULL_LIST(assoc_cond.cluster_list);
return cluster_list;
}
assoc_cond.acct_list = list_create(NULL);
list_append(assoc_cond.acct_list, "root");
assoc_cond.user_list = list_create(NULL);
list_append(assoc_cond.user_list, "");
assoc_list = as_mysql_get_assocs(mysql_conn, uid, &assoc_cond);
FREE_NULL_LIST(assoc_cond.cluster_list);
FREE_NULL_LIST(assoc_cond.acct_list);
FREE_NULL_LIST(assoc_cond.user_list);
if (!assoc_list)
return cluster_list;
itr = list_iterator_create(cluster_list);
assoc_itr = list_iterator_create(assoc_list);
while ((cluster = list_next(itr))) {
while ((assoc = list_next(assoc_itr))) {
if (strcmp(assoc->cluster, cluster->name))
continue;
if (cluster->root_assoc) {
debug("This cluster %s already has "
"an association.", cluster->name);
continue;
}
cluster->root_assoc = assoc;
list_remove(assoc_itr);
}
list_iterator_reset(assoc_itr);
}
list_iterator_destroy(itr);
list_iterator_destroy(assoc_itr);
if (list_count(assoc_list))
error("I have %d left over associations",
list_count(assoc_list));
FREE_NULL_LIST(assoc_list);
return cluster_list;
}
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 int as_mysql_node_down(mysql_conn_t *mysql_conn,
struct node_record *node_ptr,
time_t event_time, char *reason,
uint32_t reason_uid)
{
int rc = SLURM_SUCCESS;
char *query = NULL;
char *my_reason;
MYSQL_RES *result = NULL;
MYSQL_ROW row;
if (check_connection(mysql_conn) != SLURM_SUCCESS)
return ESLURM_DB_CONNECTION;
if (!mysql_conn->cluster_name) {
error("%s:%d no cluster name", THIS_FILE, __LINE__);
return SLURM_ERROR;
}
if (!node_ptr) {
error("No node_ptr given!");
return SLURM_ERROR;
}
if (!node_ptr->tres_str) {
error("node ptr has no tres_list!");
return SLURM_ERROR;
}
query = xstrdup_printf("select state, reason from \"%s_%s\" where "
"time_end=0 and node_name='%s';",
mysql_conn->cluster_name, event_table,
node_ptr->name);
/* info("%d(%s:%d) query\n%s", */
/* mysql_conn->conn, THIS_FILE, __LINE__, query); */
result = mysql_db_query_ret(mysql_conn, query, 0);
xfree(query);
if (!result)
return SLURM_ERROR;
if (reason)
my_reason = slurm_add_slash_to_quotes(reason);
else
my_reason = slurm_add_slash_to_quotes(node_ptr->reason);
row = mysql_fetch_row(result);
if (row && (node_ptr->node_state == slurm_atoul(row[0])) &&
my_reason && row[1] &&
!strcasecmp(my_reason, row[1])) {
debug("as_mysql_node_down: no change needed %u == %s "
"and %s == %s",
node_ptr->node_state, row[0], my_reason, row[1]);
xfree(my_reason);
mysql_free_result(result);
return SLURM_SUCCESS;
}
mysql_free_result(result);
debug2("inserting %s(%s) with tres of '%s'",
node_ptr->name, mysql_conn->cluster_name, node_ptr->tres_str);
query = xstrdup_printf(
"update \"%s_%s\" set time_end=%ld where "
"time_end=0 and node_name='%s';",
mysql_conn->cluster_name, event_table,
event_time, node_ptr->name);
/* If you are clean-restarting the controller over and over again you
* could get records that are duplicates in the database. If
* this is the case we will zero out the time_end we are
* just filled in. This will cause the last time to be erased
* from the last restart, but if you are restarting things
* this often the pervious one didn't mean anything anyway.
* This way we only get one for the last time we let it run.
*/
xstrfmtcat(query,
"insert into \"%s_%s\" "
"(node_name, state, tres, time_start, "
"reason, reason_uid) "
"values ('%s', %u, '%s', %ld, '%s', %u) "
"on duplicate key update time_end=0;",
mysql_conn->cluster_name, event_table,
node_ptr->name, node_ptr->node_state,
node_ptr->tres_str, event_time, my_reason, reason_uid);
debug2("%d(%s:%d) query\n%s",
mysql_conn->conn, THIS_FILE, __LINE__, query);
rc = mysql_db_query(mysql_conn, query);
xfree(query);
xfree(my_reason);
return rc;
}
extern List as_mysql_modify_users(mysql_conn_t *mysql_conn, uint32_t uid,
slurmdb_user_cond_t *user_cond,
slurmdb_user_rec_t *user)
{
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 (!user_cond || !user) {
error("we need something to change");
return NULL;
}
if (check_connection(mysql_conn) != SLURM_SUCCESS)
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);
ret_list = _get_other_user_names_to_mod(mysql_conn, uid, user_cond);
if (user->name)
xstrfmtcat(vals, ", name='%s'", user->name);
if (user->admin_level != SLURMDB_ADMIN_NOTSET)
xstrfmtcat(vals, ", admin_level=%u", user->admin_level);
if ((!extra && !ret_list)
|| (!vals && !user->default_acct && !user->default_wckey)) {
errno = SLURM_NO_CHANGE_IN_DATA;
error("Nothing to change");
return NULL;
}
if (!extra) {
/* means we got a ret_list and don't need to look at
the user_table. */
goto no_user_table;
}
query = xstrdup_printf(
"select distinct name from %s where deleted=0 %s;",
user_table, extra);
xfree(extra);
if (!(result = mysql_db_query_ret(
mysql_conn, query, 0))) {
xfree(query);
if (ret_list)
list_destroy(ret_list);
return NULL;
}
if (!ret_list)
ret_list = list_create(slurm_destroy_char);
while ((row = mysql_fetch_row(result))) {
slurmdb_user_rec_t *user_rec = NULL;
object = row[0];
slurm_addto_char_list(ret_list, object);
if (!name_char)
xstrfmtcat(name_char, "(name='%s'", object);
else
xstrfmtcat(name_char, " || name='%s'", object);
user_rec = xmalloc(sizeof(slurmdb_user_rec_t));
if (!user->name)
user_rec->name = xstrdup(object);
else {
user_rec->name = xstrdup(user->name);
user_rec->old_name = xstrdup(object);
if (_change_user_name(mysql_conn, user_rec)
!= SLURM_SUCCESS)
break;
}
user_rec->admin_level = user->admin_level;
if (addto_update_list(mysql_conn->update_list,
SLURMDB_MODIFY_USER, user_rec)
!= SLURM_SUCCESS)
slurmdb_destroy_user_rec(user_rec);
}
mysql_free_result(result);
no_user_table:
if (!list_count(ret_list)) {
errno = SLURM_NO_CHANGE_IN_DATA;
debug3("didn't effect anything\n%s", query);
xfree(vals);
xfree(query);
return ret_list;
} else if (user->name && (list_count(ret_list) != 1)) {
errno = ESLURM_ONE_CHANGE;
xfree(vals);
xfree(query);
if (ret_list)
list_destroy(ret_list);
return NULL;
}
xfree(query);
if (name_char && vals) {
xstrcat(name_char, ")");
user_name = uid_to_string((uid_t) uid);
rc = modify_common(mysql_conn, DBD_MODIFY_USERS, now,
user_name, user_table, name_char,
vals, NULL);
xfree(user_name);
}
xfree(name_char);
xfree(vals);
if (rc == SLURM_ERROR) {
error("Couldn't modify users");
list_destroy(ret_list);
ret_list = NULL;
}
if (user->default_acct) {
slurmdb_association_cond_t assoc_cond;
slurmdb_association_rec_t assoc;
List tmp_list = NULL;
memset(&assoc_cond, 0, sizeof(slurmdb_association_cond_t));
slurmdb_init_association_rec(&assoc, 0);
assoc.is_def = 1;
assoc_cond.acct_list = list_create(NULL);
list_append(assoc_cond.acct_list, user->default_acct);
assoc_cond.user_list = ret_list;
if (user_cond->assoc_cond
&& user_cond->assoc_cond->cluster_list)
assoc_cond.cluster_list =
user_cond->assoc_cond->cluster_list;
tmp_list = as_mysql_modify_assocs(mysql_conn, uid,
&assoc_cond, &assoc);
list_destroy(assoc_cond.acct_list);
if (!tmp_list) {
list_destroy(ret_list);
ret_list = NULL;
goto end_it;
}
/* char *names = NULL; */
/* ListIterator itr = list_iterator_create(tmp_list); */
/* while ((names = list_next(itr))) { */
/* info("%s", names); */
/* } */
/* list_iterator_destroy(itr); */
list_destroy(tmp_list);
}
if (user->default_wckey) {
slurmdb_wckey_cond_t wckey_cond;
slurmdb_wckey_rec_t wckey;
List tmp_list = NULL;
memset(&wckey_cond, 0, sizeof(slurmdb_wckey_cond_t));
slurmdb_init_wckey_rec(&wckey, 0);
wckey.is_def = 1;
wckey_cond.name_list = list_create(NULL);
list_append(wckey_cond.name_list, user->default_wckey);
wckey_cond.user_list = ret_list;
if (user_cond->assoc_cond
&& user_cond->assoc_cond->cluster_list)
wckey_cond.cluster_list =
user_cond->assoc_cond->cluster_list;
tmp_list = as_mysql_modify_wckeys(mysql_conn, uid,
&wckey_cond, &wckey);
list_destroy(wckey_cond.name_list);
if (!tmp_list) {
list_destroy(ret_list);
ret_list = NULL;
goto end_it;
}
/* char *names = NULL; */
/* ListIterator itr = list_iterator_create(tmp_list); */
/* while ((names = list_next(itr))) { */
/* info("%s", names); */
/* } */
/* list_iterator_destroy(itr); */
list_destroy(tmp_list);
}
end_it:
return ret_list;
}
/* Fill in all the accounts this user is coordinator over. This
* will fill in all the sub accounts they are coordinator over also.
*/
static int _get_user_coords(mysql_conn_t *mysql_conn, slurmdb_user_rec_t *user)
{
char *query = NULL;
slurmdb_coord_rec_t *coord = NULL;
MYSQL_RES *result = NULL;
MYSQL_ROW row;
ListIterator itr = NULL, itr2 = NULL;
char *cluster_name = NULL;
if (!user) {
error("We need a user to fill in.");
return SLURM_ERROR;
}
if (!user->coord_accts)
user->coord_accts = list_create(slurmdb_destroy_coord_rec);
query = xstrdup_printf(
"select acct from %s where user='******' && deleted=0",
acct_coord_table, user->name);
if (!(result =
mysql_db_query_ret(mysql_conn, query, 0))) {
xfree(query);
return SLURM_ERROR;
}
xfree(query);
while ((row = mysql_fetch_row(result))) {
coord = xmalloc(sizeof(slurmdb_coord_rec_t));
list_append(user->coord_accts, coord);
coord->name = xstrdup(row[0]);
coord->direct = 1;
}
mysql_free_result(result);
if (!list_count(user->coord_accts))
return SLURM_SUCCESS;
slurm_mutex_lock(&as_mysql_cluster_list_lock);
itr2 = list_iterator_create(as_mysql_cluster_list);
itr = list_iterator_create(user->coord_accts);
while ((cluster_name = list_next(itr2))) {
int set = 0;
if (query)
xstrcat(query, " union ");
while ((coord = list_next(itr))) {
if (set)
xstrcat(query, " || ");
else
xstrfmtcat(query,
"select distinct t1.acct from "
"\"%s_%s\" as t1, \"%s_%s\" "
"as t2 where t1.deleted=0 && (",
cluster_name, assoc_table,
cluster_name, assoc_table);
/* Make sure we don't get the same
* account back since we want to keep
* track of the sub-accounts.
*/
xstrfmtcat(query, "(t2.acct='%s' "
"&& t1.lft between t2.lft "
"and t2.rgt && t1.user='' "
"&& t1.acct!='%s')",
coord->name, coord->name);
set = 1;
}
list_iterator_reset(itr);
if (set)
xstrcat(query, ")");
}
list_iterator_destroy(itr2);
slurm_mutex_unlock(&as_mysql_cluster_list_lock);
if (query) {
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);
while ((row = mysql_fetch_row(result))) {
list_iterator_reset(itr);
while ((coord = list_next(itr))) {
if (!strcmp(coord->name, row[0]))
break;
}
if (coord)
continue;
coord = xmalloc(sizeof(slurmdb_coord_rec_t));
list_append(user->coord_accts, coord);
coord->name = xstrdup(row[0]);
coord->direct = 0;
}
mysql_free_result(result);
}
list_iterator_destroy(itr);
return SLURM_SUCCESS;
}
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;
}
/* NOTE: Insure that mysql_conn->lock is NOT set on function entry */
static int _mysql_make_table_current(mysql_conn_t *mysql_conn, char *table_name,
storage_field_t *fields, char *ending)
{
char *query = NULL;
char *correct_query = NULL;
MYSQL_RES *result = NULL;
MYSQL_ROW row;
int i = 0;
List columns = NULL;
ListIterator itr = NULL;
char *col = NULL;
int adding = 0;
int run_update = 0;
char *primary_key = NULL;
char *unique_index = NULL;
int old_primary = 0;
char *old_index = NULL;
char *temp = NULL, *temp2 = NULL;
List keys_list = NULL;
db_key_t *db_key = NULL;
DEF_TIMERS;
/* figure out the unique keys in the table */
query = xstrdup_printf("show index from %s where non_unique=0",
table_name);
if (!(result = mysql_db_query_ret(mysql_conn, query, 0))) {
xfree(query);
return SLURM_ERROR;
}
xfree(query);
while ((row = mysql_fetch_row(result))) {
// row[2] is the key name
if (!strcasecmp(row[2], "PRIMARY"))
old_primary = 1;
else if (!old_index)
old_index = xstrdup(row[2]);
}
mysql_free_result(result);
/* figure out the non-unique keys in the table */
query = xstrdup_printf("show index from %s where non_unique=1",
table_name);
if (!(result = mysql_db_query_ret(mysql_conn, query, 0))) {
xfree(query);
return SLURM_ERROR;
}
xfree(query);
itr = NULL;
keys_list = list_create(_destroy_db_key);
while ((row = mysql_fetch_row(result))) {
if (!itr)
itr = list_iterator_create(keys_list);
else
list_iterator_reset(itr);
while ((db_key = list_next(itr))) {
if (!strcmp(db_key->name, row[2]))
break;
}
if (db_key) {
xstrfmtcat(db_key->columns, ", %s", row[4]);
} else {
db_key = xmalloc(sizeof(db_key_t));
db_key->name = xstrdup(row[2]); // name
db_key->columns = xstrdup(row[4]); // column name
list_append(keys_list, db_key); // don't use list_push
}
}
mysql_free_result(result);
if (itr) {
list_iterator_destroy(itr);
itr = NULL;
}
/* figure out the existing columns in the table */
query = xstrdup_printf("show columns from %s", table_name);
if (!(result = mysql_db_query_ret(mysql_conn, query, 0))) {
xfree(query);
xfree(old_index);
FREE_NULL_LIST(keys_list);
return SLURM_ERROR;
}
xfree(query);
columns = list_create(slurm_destroy_char);
while ((row = mysql_fetch_row(result))) {
col = xstrdup(row[0]); //Field
list_append(columns, col);
}
mysql_free_result(result);
itr = list_iterator_create(columns);
query = xstrdup_printf("alter ignore table %s", table_name);
correct_query = xstrdup_printf("alter ignore table %s", table_name);
START_TIMER;
while (fields[i].name) {
int found = 0;
list_iterator_reset(itr);
while ((col = list_next(itr))) {
if (!strcmp(col, fields[i].name)) {
xstrfmtcat(query, " modify `%s` %s,",
fields[i].name,
fields[i].options);
xstrfmtcat(correct_query, " modify `%s` %s,",
fields[i].name,
fields[i].options);
list_delete_item(itr);
found = 1;
break;
}
}
if (!found) {
if (i) {
info("adding column %s after %s in table %s",
fields[i].name,
fields[i-1].name,
table_name);
xstrfmtcat(query, " add `%s` %s after %s,",
fields[i].name,
fields[i].options,
fields[i-1].name);
xstrfmtcat(correct_query, " modify `%s` %s,",
fields[i].name,
fields[i].options);
} else {
info("adding column %s at the beginning "
"of table %s",
fields[i].name,
table_name);
xstrfmtcat(query, " add `%s` %s first,",
fields[i].name,
fields[i].options);
xstrfmtcat(correct_query, " modify `%s` %s,",
fields[i].name,
fields[i].options);
}
adding = 1;
}
i++;
}
list_iterator_reset(itr);
while ((col = list_next(itr))) {
adding = 1;
info("dropping column %s from table %s", col, table_name);
xstrfmtcat(query, " drop %s,", col);
}
list_iterator_destroy(itr);
list_destroy(columns);
if ((temp = strstr(ending, "primary key ("))) {
int open = 0, close =0;
int end = 0;
while (temp[end++]) {
if (temp[end] == '(')
open++;
else if (temp[end] == ')')
close++;
else
continue;
if (open == close)
break;
}
if (temp[end]) {
end++;
primary_key = xstrndup(temp, end);
if (old_primary) {
xstrcat(query, " drop primary key,");
xstrcat(correct_query, " drop primary key,");
}
xstrfmtcat(query, " add %s,", primary_key);
xstrfmtcat(correct_query, " add %s,", primary_key);
xfree(primary_key);
}
}
if ((temp = strstr(ending, "unique index ("))) {
int open = 0, close =0;
int end = 0;
while (temp[end++]) {
if (temp[end] == '(')
open++;
else if (temp[end] == ')')
close++;
else
continue;
if (open == close)
break;
}
if (temp[end]) {
end++;
unique_index = xstrndup(temp, end);
if (old_index) {
xstrfmtcat(query, " drop index %s,",
old_index);
xstrfmtcat(correct_query, " drop index %s,",
old_index);
}
xstrfmtcat(query, " add %s,", unique_index);
xstrfmtcat(correct_query, " add %s,", unique_index);
xfree(unique_index);
}
}
xfree(old_index);
temp2 = ending;
itr = list_iterator_create(keys_list);
while ((temp = strstr(temp2, ", key "))) {
int open = 0, close = 0, name_end = 0;
int end = 5;
char *new_key_name = NULL, *new_key = NULL;
while (temp[end++]) {
if (!name_end && (temp[end] == ' ')) {
name_end = end;
continue;
} else if (temp[end] == '(') {
open++;
if (!name_end)
name_end = end;
} else if (temp[end] == ')')
close++;
else
continue;
if (open == close)
break;
}
if (temp[end]) {
end++;
new_key_name = xstrndup(temp+6, name_end-6);
new_key = xstrndup(temp+2, end-2); // skip ', '
while ((db_key = list_next(itr))) {
if (!strcmp(db_key->name, new_key_name)) {
list_remove(itr);
break;
}
}
list_iterator_reset(itr);
if (db_key) {
xstrfmtcat(query,
" drop key %s,", db_key->name);
xstrfmtcat(correct_query,
" drop key %s,", db_key->name);
_destroy_db_key(db_key);
} else
info("adding %s to table %s",
new_key, table_name);
xstrfmtcat(query, " add %s,", new_key);
xstrfmtcat(correct_query, " add %s,", new_key);
xfree(new_key);
xfree(new_key_name);
}
temp2 = temp + end;
}
/* flush extra (old) keys */
while ((db_key = list_next(itr))) {
info("dropping key %s from table %s", db_key->name, table_name);
xstrfmtcat(query, " drop key %s,", db_key->name);
}
list_iterator_destroy(itr);
list_destroy(keys_list);
query[strlen(query)-1] = ';';
correct_query[strlen(correct_query)-1] = ';';
//info("%d query\n%s", __LINE__, query);
/* see if we have already done this definition */
if (!adding) {
char *quoted = slurm_add_slash_to_quotes(query);
char *query2 = xstrdup_printf("select table_name from "
"%s where definition='%s'",
table_defs_table, quoted);
MYSQL_RES *result = NULL;
MYSQL_ROW row;
xfree(quoted);
run_update = 1;
if ((result = mysql_db_query_ret(mysql_conn, query2, 0))) {
if ((row = mysql_fetch_row(result)))
run_update = 0;
mysql_free_result(result);
}
xfree(query2);
if (run_update) {
run_update = 2;
query2 = xstrdup_printf("select table_name from "
"%s where table_name='%s'",
table_defs_table, table_name);
if ((result = mysql_db_query_ret(
mysql_conn, query2, 0))) {
if ((row = mysql_fetch_row(result)))
run_update = 1;
mysql_free_result(result);
}
xfree(query2);
}
}
/* if something has changed run the alter line */
if (run_update || adding) {
time_t now = time(NULL);
char *query2 = NULL;
char *quoted = NULL;
if (run_update == 2)
debug4("Table %s doesn't exist, adding", table_name);
else
debug("Table %s has changed. Updating...", table_name);
if (mysql_db_query(mysql_conn, query)) {
xfree(query);
return SLURM_ERROR;
}
quoted = slurm_add_slash_to_quotes(correct_query);
query2 = xstrdup_printf("insert into %s (creation_time, "
"mod_time, table_name, definition) "
"values (%ld, %ld, '%s', '%s') "
"on duplicate key update "
"definition='%s', mod_time=%ld;",
table_defs_table, now, now,
table_name, quoted,
quoted, now);
xfree(quoted);
if (mysql_db_query(mysql_conn, query2)) {
xfree(query2);
return SLURM_ERROR;
}
xfree(query2);
}
xfree(query);
xfree(correct_query);
query = xstrdup_printf("make table current %s", table_name);
END_TIMER2(query);
xfree(query);
return SLURM_SUCCESS;
}
extern int as_mysql_user_no_assocs_or_no_uid(
mysql_conn_t *mysql_conn,
slurmdb_assoc_cond_t *assoc_cond,
List ret_list)
{
int rc = SLURM_SUCCESS;
char *query = NULL;
MYSQL_RES *result = NULL;
MYSQL_ROW row;
List use_cluster_list = as_mysql_cluster_list;
ListIterator itr = NULL;
char *cluster_name = NULL;
xassert(ret_list);
query = xstrdup_printf("select name from %s where deleted=0",
user_table);
if (assoc_cond &&
assoc_cond->user_list && list_count(assoc_cond->user_list)) {
int set = 0;
char *object = NULL;
xstrcat(query, " && (");
itr = list_iterator_create(assoc_cond->user_list);
while ((object = list_next(itr))) {
if (set)
xstrcat(query, " || ");
xstrfmtcat(query, "name='%s'", object);
set = 1;
}
list_iterator_destroy(itr);
xstrcat(query, ")");
}
if (!(result = mysql_db_query_ret(
mysql_conn, query, 0))) {
xfree(query);
return SLURM_ERROR;
}
xfree(query);
if (assoc_cond &&
assoc_cond->cluster_list && list_count(assoc_cond->cluster_list))
use_cluster_list = assoc_cond->cluster_list;
else
slurm_mutex_lock(&as_mysql_cluster_list_lock);
itr = list_iterator_create(use_cluster_list);
while ((row = mysql_fetch_row(result))) {
MYSQL_RES *result2 = NULL;
int cnt = 0;
slurmdb_assoc_rec_t *assoc = NULL;
uid_t pw_uid;
if (uid_from_string (row[0], &pw_uid) < 0) {
assoc = xmalloc(sizeof(slurmdb_assoc_rec_t));
list_append(ret_list, assoc);
assoc->id = SLURMDB_PROBLEM_USER_NO_UID;
assoc->user = xstrdup(row[0]);
continue;
}
/* See if we have at least 1 association in the system */
while ((cluster_name = list_next(itr))) {
if (query)
xstrcat(query, " union ");
xstrfmtcat(query,
"select distinct id_assoc from \"%s_%s\" "
"where deleted=0 && "
"user='******'",
cluster_name, assoc_table, row[0]);
}
list_iterator_reset(itr);
if (query)
xstrcat(query, " limit 1");
if (!(result2 = mysql_db_query_ret(
mysql_conn, query, 0))) {
xfree(query);
rc = SLURM_ERROR;
break;
}
xfree(query);
cnt = mysql_num_rows(result2);
mysql_free_result(result2);
if (cnt)
continue;
assoc = xmalloc(sizeof(slurmdb_assoc_rec_t));
list_append(ret_list, assoc);
assoc->id = SLURMDB_PROBLEM_USER_NO_ASSOC;
assoc->user = xstrdup(row[0]);
}
mysql_free_result(result);
list_iterator_destroy(itr);
if (use_cluster_list == as_mysql_cluster_list)
slurm_mutex_unlock(&as_mysql_cluster_list_lock);
return rc;
}
extern int as_mysql_acct_no_users(mysql_conn_t *mysql_conn,
slurmdb_assoc_cond_t *assoc_cond,
List ret_list)
{
int rc = SLURM_SUCCESS;
char *query = NULL, *tmp = NULL;
char *extra = NULL;
int i = 0;
MYSQL_RES *result = NULL;
MYSQL_ROW row;
List use_cluster_list = as_mysql_cluster_list;
ListIterator itr = NULL;
char *cluster_name;
xassert(ret_list);
_setup_assoc_cond_limits(assoc_cond, &extra, 0);
/* if this changes you will need to edit the corresponding enum */
char *assoc_req_inx[] = {
"id_assoc",
"user",
"acct",
"`partition`",
"parent_acct",
};
enum {
ASSOC_REQ_ID,
ASSOC_REQ_USER,
ASSOC_REQ_ACCT,
ASSOC_REQ_PART,
ASSOC_REQ_PARENT,
ASSOC_REQ_COUNT
};
xfree(tmp);
xstrfmtcat(tmp, "%s", assoc_req_inx[i]);
for(i=1; i<ASSOC_REQ_COUNT; i++) {
xstrfmtcat(tmp, ", %s", assoc_req_inx[i]);
}
if (assoc_cond &&
assoc_cond->cluster_list && list_count(assoc_cond->cluster_list))
use_cluster_list = assoc_cond->cluster_list;
else
slurm_mutex_lock(&as_mysql_cluster_list_lock);
itr = list_iterator_create(use_cluster_list);
while ((cluster_name = list_next(itr))) {
/* only get the account associations */
if (query)
xstrcat(query, " union ");
xstrfmtcat(query, "select distinct %s, '%s' as cluster "
"from \"%s_%s\" %s && user='' && lft=(rgt-1) ",
tmp, cluster_name, cluster_name,
assoc_table, 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, acct;");
xfree(tmp);
xfree(extra);
if (debug_flags & DEBUG_FLAG_DB_QUERY)
DB_DEBUG(mysql_conn->conn, "query\n%s", query);
if (!(result = mysql_db_query_ret(
mysql_conn, query, 0))) {
xfree(query);
return SLURM_ERROR;
}
xfree(query);
while ((row = mysql_fetch_row(result))) {
slurmdb_assoc_rec_t *assoc =
xmalloc(sizeof(slurmdb_assoc_rec_t));
list_append(ret_list, assoc);
assoc->id = SLURMDB_PROBLEM_ACCT_NO_USERS;
if (row[ASSOC_REQ_USER][0])
assoc->user = xstrdup(row[ASSOC_REQ_USER]);
assoc->acct = xstrdup(row[ASSOC_REQ_ACCT]);
assoc->cluster = xstrdup(row[ASSOC_REQ_COUNT]);
if (row[ASSOC_REQ_PARENT][0])
assoc->parent_acct = xstrdup(row[ASSOC_REQ_PARENT]);
if (row[ASSOC_REQ_PART][0])
assoc->partition = xstrdup(row[ASSOC_REQ_PART]);
}
mysql_free_result(result);
return rc;
}
static int _cluster_get_jobs(mysql_conn_t *mysql_conn,
slurmdb_user_rec_t *user,
slurmdb_job_cond_t *job_cond,
char *cluster_name,
char *job_fields, char *step_fields,
char *sent_extra,
bool is_admin, int only_pending, List sent_list)
{
char *query = NULL;
char *extra = xstrdup(sent_extra);
uint16_t private_data = slurm_get_private_data();
slurmdb_selected_step_t *selected_step = NULL;
MYSQL_RES *result = NULL, *step_result = NULL;
MYSQL_ROW row, step_row;
slurmdb_job_rec_t *job = NULL;
slurmdb_step_rec_t *step = NULL;
time_t now = time(NULL);
List job_list = list_create(slurmdb_destroy_job_rec);
ListIterator itr = NULL, itr2 = NULL;
List local_cluster_list = NULL;
int set = 0;
char *prefix="t2";
int rc = SLURM_SUCCESS;
int last_id = -1, curr_id = -1;
local_cluster_t *curr_cluster = NULL;
/* 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_JOBS)) {
query = xstrdup_printf("select lft from \"%s_%s\" "
"where user='******'",
cluster_name, assoc_table, user->name);
if (user->coord_accts) {
slurmdb_coord_rec_t *coord = NULL;
itr = list_iterator_create(user->coord_accts);
while ((coord = list_next(itr))) {
xstrfmtcat(query, " || acct='%s'",
coord->name);
}
list_iterator_destroy(itr);
}
if (debug_flags & DEBUG_FLAG_DB_JOB)
DB_DEBUG(mysql_conn->conn, "query\n%s", query);
if (!(result = mysql_db_query_ret(
mysql_conn, query, 0))) {
xfree(extra);
xfree(query);
rc = SLURM_ERROR;
goto end_it;
}
xfree(query);
set = 0;
while ((row = mysql_fetch_row(result))) {
if (set) {
xstrfmtcat(extra,
" || (%s between %s.lft and %s.rgt)",
row[0], prefix, prefix);
} else {
set = 1;
if (extra)
xstrfmtcat(extra,
" && ((%s between %s.lft "
"and %s.rgt)",
row[0], prefix,
prefix);
else
xstrfmtcat(extra,
" where ((%s between %s.lft "
"and %s.rgt)",
row[0], prefix,
prefix);
}
}
mysql_free_result(result);
if (set)
xstrcat(extra, ")");
else {
xfree(extra);
debug("User %s has no assocations, and is not admin, "
"so not returning any jobs.", user->name);
/* This user has no valid associations, so
* they will not have any jobs. */
goto end_it;
}
}
setup_job_cluster_cond_limits(mysql_conn, job_cond,
cluster_name, &extra);
query = xstrdup_printf("select %s from \"%s_%s\" as t1 "
"left join \"%s_%s\" as t2 "
"on t1.id_assoc=t2.id_assoc "
"left join \"%s_%s\" as t3 "
"on t1.id_resv=t3.id_resv && "
"((t1.time_start && "
"(t3.time_start < t1.time_start && "
"(t3.time_end >= t1.time_start || "
"t3.time_end = 0))) || "
"((t3.time_start < t1.time_submit && "
"(t3.time_end >= t1.time_submit || "
"t3.time_end = 0)) || "
"(t3.time_start > t1.time_submit)))",
job_fields, cluster_name, job_table,
cluster_name, assoc_table,
cluster_name, resv_table);
if (extra) {
xstrcat(query, extra);
xfree(extra);
}
/* Here we want to order them this way in such a way so it is
easy to look for duplicates, it is also easy to sort the
resized jobs.
*/
xstrcat(query, " group by id_job, time_submit desc");
if (debug_flags & DEBUG_FLAG_DB_JOB)
DB_DEBUG(mysql_conn->conn, "query\n%s", query);
if (!(result = mysql_db_query_ret(mysql_conn, query, 0))) {
xfree(query);
rc = SLURM_ERROR;
goto end_it;
}
xfree(query);
/* Here we set up environment to check used nodes of jobs.
Since we store the bitmap of the entire cluster we can use
that to set up a hostlist and set up the bitmap to make
things work. This should go before the setup of conds
since we could update the start/end time.
*/
if (job_cond && job_cond->used_nodes) {
local_cluster_list = setup_cluster_list_with_inx(
mysql_conn, job_cond, (void **)&curr_cluster);
if (!local_cluster_list) {
rc = SLURM_ERROR;
goto end_it;
}
}
while ((row = mysql_fetch_row(result))) {
char *id = row[JOB_REQ_ID];
bool job_ended = 0;
int start = slurm_atoul(row[JOB_REQ_START]);
curr_id = slurm_atoul(row[JOB_REQ_JOBID]);
if (job_cond && !job_cond->duplicates
&& (curr_id == last_id)
&& (slurm_atoul(row[JOB_REQ_STATE]) != JOB_RESIZING))
continue;
/* check the bitmap to see if this is one of the jobs
we are looking for */
/* Use start time instead of submit time because node
* indexes are determined at start time and not submit. */
if (!good_nodes_from_inx(local_cluster_list,
(void **)&curr_cluster,
row[JOB_REQ_NODE_INX], start)) {
last_id = curr_id;
continue;
}
job = slurmdb_create_job_rec();
job->state = slurm_atoul(row[JOB_REQ_STATE]);
if (curr_id == last_id)
/* put in reverse so we order by the submit getting
larger which it is given to us in reverse
order from the database */
list_prepend(job_list, job);
else
list_append(job_list, job);
last_id = curr_id;
if (row[JOB_REQ_GRES_ALLOC])
job->alloc_gres = xstrdup(row[JOB_REQ_GRES_ALLOC]);
else
job->alloc_gres = xstrdup("");
job->alloc_nodes = slurm_atoul(row[JOB_REQ_ALLOC_NODES]);
job->associd = slurm_atoul(row[JOB_REQ_ASSOCID]);
job->array_job_id = slurm_atoul(row[JOB_REQ_ARRAYJOBID]);
job->array_task_id = slurm_atoul(row[JOB_REQ_ARRAYTASKID]);
job->resvid = slurm_atoul(row[JOB_REQ_RESVID]);
/* This shouldn't happen with new jobs, but older jobs
* could of been added without a start and so the
* array_task_id would be 0 instead of it's real value */
if (!job->array_job_id && !job->array_task_id)
job->array_task_id = NO_VAL;
if (row[JOB_REQ_RESV_NAME] && row[JOB_REQ_RESV_NAME][0])
job->resv_name = xstrdup(row[JOB_REQ_RESV_NAME]);
job->cluster = xstrdup(cluster_name);
/* we want a blank wckey if the name is null */
if (row[JOB_REQ_WCKEY])
job->wckey = xstrdup(row[JOB_REQ_WCKEY]);
else
job->wckey = xstrdup("");
job->wckeyid = slurm_atoul(row[JOB_REQ_WCKEYID]);
if (row[JOB_REQ_USER_NAME])
job->user = xstrdup(row[JOB_REQ_USER_NAME]);
else
job->uid = slurm_atoul(row[JOB_REQ_UID]);
if (row[JOB_REQ_LFT])
job->lft = slurm_atoul(row[JOB_REQ_LFT]);
if (row[JOB_REQ_ACCOUNT] && row[JOB_REQ_ACCOUNT][0])
job->account = xstrdup(row[JOB_REQ_ACCOUNT]);
else if (row[JOB_REQ_ACCOUNT1] && row[JOB_REQ_ACCOUNT1][0])
job->account = xstrdup(row[JOB_REQ_ACCOUNT1]);
if (row[JOB_REQ_ARRAY_STR] && row[JOB_REQ_ARRAY_STR][0])
job->array_task_str = xstrdup(row[JOB_REQ_ARRAY_STR]);
if (row[JOB_REQ_ARRAY_MAX])
job->array_max_tasks =
slurm_atoul(row[JOB_REQ_ARRAY_MAX]);
if (row[JOB_REQ_BLOCKID])
job->blockid = xstrdup(row[JOB_REQ_BLOCKID]);
job->eligible = slurm_atoul(row[JOB_REQ_ELIGIBLE]);
job->submit = slurm_atoul(row[JOB_REQ_SUBMIT]);
job->start = start;
job->end = slurm_atoul(row[JOB_REQ_END]);
job->timelimit = slurm_atoul(row[JOB_REQ_TIMELIMIT]);
/* since the job->end could be set later end it here */
if (job->end) {
job_ended = 1;
if (!job->start || (job->start > job->end))
job->start = job->end;
}
if (job_cond && !job_cond->without_usage_truncation
&& job_cond->usage_start) {
if (job->start && (job->start < job_cond->usage_start))
job->start = job_cond->usage_start;
if (!job->end || job->end > job_cond->usage_end)
job->end = job_cond->usage_end;
if (!job->start)
job->start = job->end;
job->elapsed = job->end - job->start;
if (row[JOB_REQ_SUSPENDED]) {
MYSQL_RES *result2 = NULL;
MYSQL_ROW row2;
/* get the suspended time for this job */
query = xstrdup_printf(
"select time_start, time_end from "
"\"%s_%s\" where "
"(time_start < %ld && (time_end >= %ld "
"|| time_end = 0)) && job_db_inx=%s "
"order by time_start",
cluster_name, suspend_table,
job_cond->usage_end,
job_cond->usage_start,
id);
debug4("%d(%s:%d) query\n%s",
mysql_conn->conn, THIS_FILE,
__LINE__, query);
if (!(result2 = mysql_db_query_ret(
mysql_conn,
query, 0))) {
FREE_NULL_LIST(job_list);
job_list = NULL;
break;
}
xfree(query);
while ((row2 = mysql_fetch_row(result2))) {
time_t local_start =
slurm_atoul(row2[0]);
time_t local_end =
slurm_atoul(row2[1]);
if (!local_start)
continue;
if (job->start > local_start)
local_start = job->start;
if (job->end < local_end)
local_end = job->end;
if ((local_end - local_start) < 1)
continue;
job->elapsed -=
(local_end - local_start);
job->suspended +=
(local_end - local_start);
}
mysql_free_result(result2);
}
} else {
job->suspended = slurm_atoul(row[JOB_REQ_SUSPENDED]);
/* fix the suspended number to be correct */
if (job->state == JOB_SUSPENDED)
job->suspended = now - job->suspended;
if (!job->start) {
job->elapsed = 0;
} else if (!job->end) {
job->elapsed = now - job->start;
} else {
job->elapsed = job->end - job->start;
}
job->elapsed -= job->suspended;
}
if ((int)job->elapsed < 0)
job->elapsed = 0;
job->jobid = curr_id;
job->jobname = xstrdup(row[JOB_REQ_NAME]);
job->gid = slurm_atoul(row[JOB_REQ_GID]);
job->exitcode = slurm_atoul(row[JOB_REQ_EXIT_CODE]);
job->derived_ec = slurm_atoul(row[JOB_REQ_DERIVED_EC]);
job->derived_es = xstrdup(row[JOB_REQ_DERIVED_ES]);
if (row[JOB_REQ_PARTITION])
job->partition = xstrdup(row[JOB_REQ_PARTITION]);
if (row[JOB_REQ_NODELIST])
job->nodes = xstrdup(row[JOB_REQ_NODELIST]);
if (!job->nodes || !xstrcmp(job->nodes, "(null)")) {
xfree(job->nodes);
job->nodes = xstrdup("(unknown)");
}
job->track_steps = slurm_atoul(row[JOB_REQ_TRACKSTEPS]);
job->priority = slurm_atoul(row[JOB_REQ_PRIORITY]);
job->req_cpus = slurm_atoul(row[JOB_REQ_REQ_CPUS]);
if (row[JOB_REQ_GRES_REQ])
job->req_gres = xstrdup(row[JOB_REQ_GRES_REQ]);
else
job->req_gres = xstrdup("");
job->req_mem = slurm_atoul(row[JOB_REQ_REQ_MEM]);
job->requid = slurm_atoul(row[JOB_REQ_KILL_REQUID]);
job->qosid = slurm_atoul(row[JOB_REQ_QOS]);
job->show_full = 1;
if (row[JOB_REQ_TRESA])
job->tres_alloc_str = xstrdup(row[JOB_REQ_TRESA]);
if (row[JOB_REQ_TRESR])
job->tres_req_str = xstrdup(row[JOB_REQ_TRESR]);
if (only_pending || (job_cond && job_cond->without_steps))
goto skip_steps;
if (job_cond && job_cond->step_list
&& list_count(job_cond->step_list)) {
set = 0;
itr = list_iterator_create(job_cond->step_list);
while ((selected_step = list_next(itr))) {
if ((selected_step->jobid != job->jobid) &&
(selected_step->jobid !=
job->array_job_id)) {
continue;
} else if ((selected_step->array_task_id !=
INFINITE) &&
(selected_step->array_task_id !=
job->array_task_id))
continue;
else if (selected_step->stepid == NO_VAL) {
job->show_full = 1;
break;
} else if (selected_step->stepid == INFINITE)
selected_step->stepid =
SLURM_BATCH_SCRIPT;
if (set)
xstrcat(extra, " || ");
else
xstrcat(extra, " && (");
/* The stepid could be -2 so use %d not %u */
xstrfmtcat(extra, "t1.id_step=%d",
selected_step->stepid);
set = 1;
job->show_full = 0;
/* Set it back just in case we are
looking at a job array.
*/
if (selected_step->stepid == SLURM_BATCH_SCRIPT)
selected_step->stepid = INFINITE;
}
list_iterator_destroy(itr);
if (set)
xstrcat(extra, ")");
}
query = xstrdup_printf("select %s from \"%s_%s\" as t1 "
"where t1.job_db_inx=%s",
step_fields, cluster_name,
step_table, id);
if (extra) {
xstrcat(query, extra);
xfree(extra);
}
if (debug_flags & DEBUG_FLAG_DB_STEP)
DB_DEBUG(mysql_conn->conn, "query\n%s", query);
if (!(step_result = mysql_db_query_ret(
mysql_conn, query, 0))) {
xfree(query);
rc = SLURM_ERROR;
goto end_it;
}
xfree(query);
/* Querying the steps in the fashion was faster than
doing only 1 query and then matching the steps up
later with the job.
*/
while ((step_row = mysql_fetch_row(step_result))) {
/* check the bitmap to see if this is one of the steps
we are looking for */
if (!good_nodes_from_inx(local_cluster_list,
(void **)&curr_cluster,
step_row[STEP_REQ_NODE_INX],
start))
continue;
step = slurmdb_create_step_rec();
step->tot_cpu_sec = 0;
step->tot_cpu_usec = 0;
step->job_ptr = job;
if (!job->first_step_ptr)
job->first_step_ptr = step;
list_append(job->steps, step);
step->stepid = slurm_atoul(step_row[STEP_REQ_STEPID]);
/* info("got step %u.%u", */
/* job->header.jobnum, step->stepnum); */
step->state = slurm_atoul(step_row[STEP_REQ_STATE]);
step->exitcode =
slurm_atoul(step_row[STEP_REQ_EXIT_CODE]);
step->nnodes = slurm_atoul(step_row[STEP_REQ_NODES]);
step->ntasks = slurm_atoul(step_row[STEP_REQ_TASKS]);
step->task_dist =
slurm_atoul(step_row[STEP_REQ_TASKDIST]);
step->start = slurm_atoul(step_row[STEP_REQ_START]);
step->end = slurm_atoul(step_row[STEP_REQ_END]);
/* if the job has ended end the step also */
if (!step->end && job_ended) {
step->end = job->end;
step->state = job->state;
}
if (job_cond && !job_cond->without_usage_truncation
&& job_cond->usage_start) {
if (step->start
&& (step->start < job_cond->usage_start))
step->start = job_cond->usage_start;
if (!step->start && step->end)
step->start = step->end;
if (!step->end
|| (step->end > job_cond->usage_end))
step->end = job_cond->usage_end;
}
/* figure this out by start stop */
step->suspended =
slurm_atoul(step_row[STEP_REQ_SUSPENDED]);
if (!step->start) {
step->elapsed = 0;
} else if (!step->end) {
step->elapsed = now - step->start;
} else {
step->elapsed = step->end - step->start;
}
step->elapsed -= step->suspended;
if ((int)step->elapsed < 0)
step->elapsed = 0;
step->req_cpufreq_min = slurm_atoul(
step_row[STEP_REQ_REQ_CPUFREQ_MIN]);
step->req_cpufreq_max = slurm_atoul(
step_row[STEP_REQ_REQ_CPUFREQ_MAX]);
step->req_cpufreq_gov = slurm_atoul(
step_row[STEP_REQ_REQ_CPUFREQ_GOV]);
step->stepname = xstrdup(step_row[STEP_REQ_NAME]);
step->nodes = xstrdup(step_row[STEP_REQ_NODELIST]);
step->requid =
slurm_atoul(step_row[STEP_REQ_KILL_REQUID]);
step->stats.cpu_min = slurm_atoul(
step_row[STEP_REQ_MIN_CPU]);
if (step->stats.cpu_min != NO_VAL) {
step->user_cpu_sec = slurm_atoul(
step_row[STEP_REQ_USER_SEC]);
step->user_cpu_usec = slurm_atoul(
step_row[STEP_REQ_USER_USEC]);
step->sys_cpu_sec =
slurm_atoul(step_row[STEP_REQ_SYS_SEC]);
step->sys_cpu_usec = slurm_atoul(
step_row[STEP_REQ_SYS_USEC]);
step->tot_cpu_sec +=
step->user_cpu_sec + step->sys_cpu_sec;
step->tot_cpu_usec += step->user_cpu_usec +
step->sys_cpu_usec;
step->stats.disk_read_max =
atof(step_row[STEP_REQ_MAX_DISK_READ]);
step->stats.disk_read_max_taskid = slurm_atoul(
step_row[STEP_REQ_MAX_DISK_READ_TASK]);
step->stats.disk_read_ave =
atof(step_row[STEP_REQ_AVE_DISK_READ]);
step->stats.disk_write_max =
atof(step_row[STEP_REQ_MAX_DISK_WRITE]);
step->stats.disk_write_max_taskid = slurm_atoul(
step_row[STEP_REQ_MAX_DISK_WRITE_TASK]);
step->stats.disk_write_ave =
atof(step_row[STEP_REQ_AVE_DISK_WRITE]);
step->stats.vsize_max = slurm_atoul(
step_row[STEP_REQ_MAX_VSIZE]);
step->stats.vsize_max_taskid = slurm_atoul(
step_row[STEP_REQ_MAX_VSIZE_TASK]);
step->stats.vsize_ave =
atof(step_row[STEP_REQ_AVE_VSIZE]);
step->stats.rss_max =
slurm_atoul(step_row[STEP_REQ_MAX_RSS]);
step->stats.rss_max_taskid = slurm_atoul(
step_row[STEP_REQ_MAX_RSS_TASK]);
step->stats.rss_ave =
atof(step_row[STEP_REQ_AVE_RSS]);
step->stats.pages_max = slurm_atoul(
step_row[STEP_REQ_MAX_PAGES]);
step->stats.pages_max_taskid = slurm_atoul(
step_row[STEP_REQ_MAX_PAGES_TASK]);
step->stats.pages_ave =
atof(step_row[STEP_REQ_AVE_PAGES]);
step->stats.cpu_min_taskid = slurm_atoul(
step_row[STEP_REQ_MIN_CPU_TASK]);
step->stats.cpu_ave =
atof(step_row[STEP_REQ_AVE_CPU]);
step->stats.act_cpufreq =
atof(step_row[STEP_REQ_ACT_CPUFREQ]);
step->stats.consumed_energy = atof(
step_row[STEP_REQ_CONSUMED_ENERGY]);
step->stats.vsize_max_nodeid = slurm_atoul(
step_row[STEP_REQ_MAX_VSIZE_NODE]);
step->stats.rss_max_nodeid = slurm_atoul(
step_row[STEP_REQ_MAX_RSS_NODE]);
step->stats.pages_max_nodeid = slurm_atoul(
step_row[STEP_REQ_MAX_PAGES_NODE]);
step->stats.cpu_min_nodeid = slurm_atoul(
step_row[STEP_REQ_MIN_CPU_NODE]);
}
if (step_row[STEP_REQ_TRES])
step->tres_alloc_str =
xstrdup(step_row[STEP_REQ_TRES]);
}
mysql_free_result(step_result);
if (!job->track_steps) {
uint64_t j_cpus, s_cpus;
/* If we don't have track_steps we want to see
if we have multiple steps. If we only have
1 step check the job name against the step
name in most all cases it will be
different. If it is different print out
the step separate. It could also be a single
step/allocation where the job was allocated more than
the step requested (eg. CR_Socket).
*/
if (list_count(job->steps) > 1)
job->track_steps = 1;
else if (step &&
(xstrcmp(step->stepname, job->jobname) ||
(((j_cpus = slurmdb_find_tres_count_in_string(
job->tres_alloc_str, TRES_CPU))
!= INFINITE64) &&
((s_cpus = slurmdb_find_tres_count_in_string(
step->tres_alloc_str, TRES_CPU))
!= INFINITE64) &&
j_cpus != s_cpus)))
job->track_steps = 1;
}
skip_steps:
/* need to reset here to make the above test valid */
step = NULL;
}
mysql_free_result(result);
end_it:
if (itr2)
list_iterator_destroy(itr2);
FREE_NULL_LIST(local_cluster_list);
if (rc == SLURM_SUCCESS)
list_transfer(sent_list, job_list);
FREE_NULL_LIST(job_list);
return rc;
}
extern List setup_cluster_list_with_inx(mysql_conn_t *mysql_conn,
slurmdb_job_cond_t *job_cond,
void **curr_cluster)
{
List local_cluster_list = NULL;
time_t now = time(NULL);
MYSQL_RES *result = NULL;
MYSQL_ROW row;
hostlist_t temp_hl = NULL;
hostlist_iterator_t h_itr = NULL;
char *query = NULL;
int dims = 0;
if (!job_cond || !job_cond->used_nodes)
return NULL;
if (!job_cond->cluster_list
|| list_count(job_cond->cluster_list) != 1) {
error("If you are doing a query against nodes "
"you must only have 1 cluster "
"you are asking for.");
return NULL;
}
/* get the dimensions of this cluster so we know how to deal
with the hostlists */
query = xstrdup_printf("select dimensions, flags from %s where "
"name='%s'",
cluster_table,
(char *)list_peek(job_cond->cluster_list));
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 NULL;
}
xfree(query);
if (!(row = mysql_fetch_row(result))) {
error("Couldn't get the dimensions of cluster '%s'.",
(char *)list_peek(job_cond->cluster_list));
mysql_free_result(result);
return NULL;
}
/* On a Cray System when dealing with hostlists as we are here
this always needs to be 1.
*/
if (slurm_atoul(row[1]) & CLUSTER_FLAG_CRAY_A)
dims = 1;
else
dims = atoi(row[0]);
mysql_free_result(result);
temp_hl = hostlist_create_dims(job_cond->used_nodes, dims);
if (hostlist_count(temp_hl) <= 0) {
error("we didn't get any real hosts to look for.");
goto no_hosts;
}
h_itr = hostlist_iterator_create(temp_hl);
query = xstrdup_printf("select cluster_nodes, time_start, "
"time_end from \"%s_%s\" where node_name='' "
"&& cluster_nodes !=''",
(char *)list_peek(job_cond->cluster_list),
event_table);
if (job_cond->usage_start) {
if (!job_cond->usage_end)
job_cond->usage_end = now;
xstrfmtcat(query,
" && ((time_start < %ld) "
"&& (time_end >= %ld || time_end = 0))",
job_cond->usage_end, job_cond->usage_start);
}
if (debug_flags & DEBUG_FLAG_DB_JOB)
DB_DEBUG(mysql_conn->conn, "query\n%s", query);
if (!(result = mysql_db_query_ret(mysql_conn, query, 0))) {
xfree(query);
goto no_hosts;
}
xfree(query);
local_cluster_list = list_create(_destroy_local_cluster);
while ((row = mysql_fetch_row(result))) {
char *host = NULL;
int loc = 0;
local_cluster_t *local_cluster =
xmalloc(sizeof(local_cluster_t));
local_cluster->hl = hostlist_create_dims(row[0], dims);
local_cluster->start = slurm_atoul(row[1]);
local_cluster->end = slurm_atoul(row[2]);
local_cluster->asked_bitmap =
bit_alloc(hostlist_count(local_cluster->hl));
while ((host = hostlist_next_dims(h_itr, dims))) {
if ((loc = hostlist_find(
local_cluster->hl, host)) != -1)
bit_set(local_cluster->asked_bitmap, loc);
free(host);
}
hostlist_iterator_reset(h_itr);
if (bit_ffs(local_cluster->asked_bitmap) != -1) {
list_append(local_cluster_list, local_cluster);
if (local_cluster->end == 0) {
local_cluster->end = now;
(*curr_cluster) = local_cluster;
} else if (!(*curr_cluster)
|| (((local_cluster_t *)(*curr_cluster))->end
< local_cluster->end)) {
(*curr_cluster) = local_cluster;
}
} else
_destroy_local_cluster(local_cluster);
}
mysql_free_result(result);
if (!list_count(local_cluster_list)) {
FREE_NULL_LIST(local_cluster_list);
local_cluster_list = NULL;
goto no_hosts;
}
no_hosts:
hostlist_iterator_destroy(h_itr);
hostlist_destroy(temp_hl);
return local_cluster_list;
}
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_association_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 (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;
debug3("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_association_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);
if (coord_list)
list_destroy(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);
if (coord_list)
list_destroy(coord_list);
list_destroy(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) {
list_destroy(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");
list_destroy(ret_list);
return NULL;
}
if (jobs_running)
errno = ESLURM_JOBS_RUNNING_ON_ASSOC;
else
errno = SLURM_SUCCESS;
return ret_list;
}
extern int as_mysql_cluster_tres(mysql_conn_t *mysql_conn,
char *cluster_nodes, char **tres_str_in,
time_t event_time)
{
char* query;
int rc = SLURM_SUCCESS;
int first = 0;
MYSQL_RES *result = NULL;
MYSQL_ROW row;
xassert(tres_str_in);
if (check_connection(mysql_conn) != SLURM_SUCCESS)
return ESLURM_DB_CONNECTION;
if (!mysql_conn->cluster_name) {
error("%s:%d no cluster name", THIS_FILE, __LINE__);
return SLURM_ERROR;
}
/* Record the processor count */
query = xstrdup_printf(
"select tres, cluster_nodes from \"%s_%s\" where "
"time_end=0 and node_name='' and state=0 limit 1",
mysql_conn->cluster_name, event_table);
if (!(result = mysql_db_query_ret(mysql_conn, query, 0))) {
xfree(query);
if (mysql_errno(mysql_conn->db_conn) == ER_NO_SUCH_TABLE)
rc = ESLURM_ACCESS_DENIED;
else
rc = SLURM_ERROR;
return rc;
}
xfree(query);
/* we only are checking the first one here */
if (!(row = mysql_fetch_row(result))) {
debug("We don't have an entry for this machine %s "
"most likely a first time running.",
mysql_conn->cluster_name);
/* Get all nodes in a down state and jobs pending or running.
* This is for the first time a cluster registers
*
* We will return ACCOUNTING_FIRST_REG so this
* is taken care of since the message thread
* may not be up when we run this in the controller or
* in the slurmdbd.
*/
if (!*tres_str_in) {
rc = 0;
goto end_it;
}
first = 1;
goto add_it;
}
/* If tres is NULL we want to return the tres for this cluster */
if (!*tres_str_in) {
*tres_str_in = xstrdup(row[0]);
goto end_it;
} else if (xstrcmp(*tres_str_in, row[0])) {
debug("%s has changed tres from %s to %s",
mysql_conn->cluster_name,
row[0], *tres_str_in);
} else {
if (debug_flags & DEBUG_FLAG_DB_EVENT)
DB_DEBUG(mysql_conn->conn,
"We have the same tres as before for %s, "
"no need to update the database.",
mysql_conn->cluster_name);
if (cluster_nodes) {
if (!row[1][0]) {
debug("Adding cluster nodes '%s' to "
"last instance of cluster '%s'.",
cluster_nodes, mysql_conn->cluster_name);
query = xstrdup_printf(
"update \"%s_%s\" set "
"cluster_nodes='%s' "
"where time_end=0 and node_name=''",
mysql_conn->cluster_name,
event_table, cluster_nodes);
(void) mysql_db_query(mysql_conn, query);
xfree(query);
goto update_it;
} else if (!strcmp(cluster_nodes, row[1])) {
if (debug_flags & DEBUG_FLAG_DB_EVENT)
DB_DEBUG(mysql_conn->conn,
"we have the same nodes "
"in the cluster "
"as before no need to "
"update the database.");
goto update_it;
}
}
goto end_it;
}
/* reset all the entries for this cluster since the tres
changed some of the downed nodes may have gone away.
Request them again with ACCOUNTING_FIRST_REG */
query = xstrdup_printf(
"update \"%s_%s\" set time_end=%ld where time_end=0",
mysql_conn->cluster_name, event_table, event_time);
rc = mysql_db_query(mysql_conn, query);
xfree(query);
first = 1;
if (rc != SLURM_SUCCESS)
goto end_it;
add_it:
query = xstrdup_printf(
"insert into \"%s_%s\" (cluster_nodes, tres, "
"time_start, reason) "
"values ('%s', '%s', %ld, 'Cluster Registered TRES');",
mysql_conn->cluster_name, event_table,
cluster_nodes, *tres_str_in, event_time);
(void) mysql_db_query(mysql_conn, query);
xfree(query);
update_it:
query = xstrdup_printf(
"update \"%s_%s\" set time_end=%ld where time_end=0 "
"and state=%u and node_name='';",
mysql_conn->cluster_name, event_table, event_time,
NODE_STATE_DOWN);
rc = mysql_db_query(mysql_conn, query);
xfree(query);
end_it:
mysql_free_result(result);
if (first && rc == SLURM_SUCCESS)
rc = ACCOUNTING_FIRST_REG;
return rc;
}
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 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_modify_resv(mysql_conn_t *mysql_conn,
slurmdb_reservation_rec_t *resv)
{
MYSQL_RES *result = NULL;
MYSQL_ROW row;
int rc = SLURM_SUCCESS;
char *cols = NULL, *vals = NULL, *extra = NULL,
*query = NULL;
time_t start = 0, now = time(NULL);
int i;
int set = 0;
char *resv_req_inx[] = {
"assoclist",
"time_start",
"time_end",
"resv_name",
"nodelist",
"node_inx",
"flags",
"tres"
};
enum {
RESV_ASSOCS,
RESV_START,
RESV_END,
RESV_NAME,
RESV_NODES,
RESV_NODE_INX,
RESV_FLAGS,
RESV_TRES,
RESV_COUNT
};
if (!resv) {
error("No reservation was given to edit");
return SLURM_ERROR;
}
if (!resv->id) {
error("We need an id to edit a reservation.");
return SLURM_ERROR;
}
if (!resv->time_start) {
error("We need a start time to edit a reservation.");
return SLURM_ERROR;
}
if (!resv->cluster || !resv->cluster[0]) {
error("We need a cluster name to edit a reservation.");
return SLURM_ERROR;
}
if (!resv->time_start_prev) {
error("We need a time to check for last "
"start of reservation.");
return SLURM_ERROR;
}
xstrfmtcat(cols, "%s", resv_req_inx[0]);
for (i=1; i<RESV_COUNT; i++) {
xstrfmtcat(cols, ", %s", resv_req_inx[i]);
}
/* check for both the last start and the start because most
likely the start time hasn't changed, but something else
may have since the last time we did an update to the
reservation. */
query = xstrdup_printf("select %s from \"%s_%s\" where id_resv=%u "
"and (time_start=%ld || time_start=%ld) "
"and deleted=0 order by time_start desc "
"limit 1 FOR UPDATE;",
cols, resv->cluster, resv_table, resv->id,
resv->time_start, resv->time_start_prev);
try_again:
debug4("%d(%s:%d) query\n%s",
mysql_conn->conn, THIS_FILE, __LINE__, query);
if (!(result = mysql_db_query_ret(
mysql_conn, query, 0))) {
rc = SLURM_ERROR;
goto end_it;
}
if (!(row = mysql_fetch_row(result))) {
rc = SLURM_ERROR;
mysql_free_result(result);
error("There is no reservation by id %u, "
"time_start %ld, and cluster '%s'", resv->id,
resv->time_start_prev, resv->cluster);
if (!set && resv->time_end) {
/* This should never really happen,
but just incase the controller and the
database get out of sync we check
to see if there is a reservation
not deleted that hasn't ended yet. */
xfree(query);
query = xstrdup_printf(
"select %s from \"%s_%s\" where id_resv=%u "
"and time_start <= %ld and deleted=0 "
"order by time_start desc "
"limit 1;",
cols, resv->cluster, resv_table, resv->id,
resv->time_end);
set = 1;
goto try_again;
}
goto end_it;
}
start = slurm_atoul(row[RESV_START]);
xfree(query);
xfree(cols);
set = 0;
/* check differences here */
if (!resv->name
&& row[RESV_NAME] && row[RESV_NAME][0])
// if this changes we just update the
// record, no need to create a new one since
// this doesn't really effect the
// reservation accounting wise
resv->name = xstrdup(row[RESV_NAME]);
if (resv->assocs)
set = 1;
else if (row[RESV_ASSOCS] && row[RESV_ASSOCS][0])
resv->assocs = xstrdup(row[RESV_ASSOCS]);
if (resv->flags != NO_VAL)
set = 1;
else
resv->flags = slurm_atoul(row[RESV_FLAGS]);
if (resv->nodes)
set = 1;
else if (row[RESV_NODES] && row[RESV_NODES][0]) {
resv->nodes = xstrdup(row[RESV_NODES]);
resv->node_inx = xstrdup(row[RESV_NODE_INX]);
}
if (!resv->time_end)
resv->time_end = slurm_atoul(row[RESV_END]);
if (resv->tres_str)
set = 1;
else if (row[RESV_TRES] && row[RESV_TRES][0])
resv->tres_str = xstrdup(row[RESV_TRES]);
mysql_free_result(result);
_setup_resv_limits(resv, &cols, &vals, &extra);
/* use start below instead of resv->time_start_prev
* just incase we have a different one from being out
* of sync
*/
if ((start > now) || !set) {
/* we haven't started the reservation yet, or
we are changing the associations or end
time which we can just update it */
query = xstrdup_printf("update \"%s_%s\" set deleted=0%s "
"where deleted=0 and id_resv=%u "
"and time_start=%ld;",
resv->cluster, resv_table,
extra, resv->id, start);
} else {
/* time_start is already done above and we
* changed something that is in need on a new
* entry. */
query = xstrdup_printf("update \"%s_%s\" set time_end=%ld "
"where deleted=0 && id_resv=%u "
"and time_start=%ld;",
resv->cluster, resv_table,
resv->time_start-1,
resv->id, start);
xstrfmtcat(query,
"insert into \"%s_%s\" (id_resv%s) "
"values (%u%s) "
"on duplicate key update deleted=0%s;",
resv->cluster, resv_table, cols, resv->id,
vals, extra);
}
if (debug_flags & DEBUG_FLAG_DB_RESV)
DB_DEBUG(mysql_conn->conn, "query\n%s", query);
rc = mysql_db_query(mysql_conn, query);
end_it:
xfree(query);
xfree(cols);
xfree(vals);
xfree(extra);
return rc;
}
extern List as_mysql_get_cluster_events(mysql_conn_t *mysql_conn, uint32_t uid,
slurmdb_event_cond_t *event_cond)
{
char *query = NULL;
char *extra = NULL;
char *tmp = NULL;
List ret_list = NULL;
ListIterator itr = NULL;
char *object = NULL;
int set = 0;
int i=0;
MYSQL_RES *result = NULL;
MYSQL_ROW row;
time_t now = time(NULL);
List use_cluster_list = as_mysql_cluster_list;
/* if this changes you will need to edit the corresponding enum */
char *event_req_inx[] = {
"cluster_nodes",
"node_name",
"state",
"time_start",
"time_end",
"reason",
"reason_uid",
"tres",
};
enum {
EVENT_REQ_CNODES,
EVENT_REQ_NODE,
EVENT_REQ_STATE,
EVENT_REQ_START,
EVENT_REQ_END,
EVENT_REQ_REASON,
EVENT_REQ_REASON_UID,
EVENT_REQ_TRES,
EVENT_REQ_COUNT
};
if (check_connection(mysql_conn) != SLURM_SUCCESS)
return NULL;
if (!event_cond)
goto empty;
if (event_cond->cpus_min) {
if (extra)
xstrcat(extra, " && (");
else
xstrcat(extra, " where (");
if (event_cond->cpus_max) {
xstrfmtcat(extra, "count between %u and %u)",
event_cond->cpus_min, event_cond->cpus_max);
} else {
xstrfmtcat(extra, "count='%u')",
event_cond->cpus_min);
}
}
switch(event_cond->event_type) {
case SLURMDB_EVENT_ALL:
break;
case SLURMDB_EVENT_CLUSTER:
if (extra)
xstrcat(extra, " && (");
else
xstrcat(extra, " where (");
xstrcat(extra, "node_name = '')");
break;
case SLURMDB_EVENT_NODE:
if (extra)
xstrcat(extra, " && (");
else
xstrcat(extra, " where (");
xstrcat(extra, "node_name != '')");
break;
default:
error("Unknown event %u doing all", event_cond->event_type);
break;
}
if (event_cond->node_list
&& list_count(event_cond->node_list)) {
set = 0;
if (extra)
xstrcat(extra, " && (");
else
xstrcat(extra, " where (");
itr = list_iterator_create(event_cond->node_list);
while ((object = list_next(itr))) {
if (set)
xstrcat(extra, " || ");
xstrfmtcat(extra, "node_name='%s'", object);
set = 1;
}
list_iterator_destroy(itr);
xstrcat(extra, ")");
}
if (event_cond->period_start) {
if (!event_cond->period_end)
event_cond->period_end = now;
if (extra)
xstrcat(extra, " && (");
else
xstrcat(extra, " where (");
xstrfmtcat(extra,
"(time_start < %ld) "
"&& (time_end >= %ld || time_end = 0))",
event_cond->period_end, event_cond->period_start);
}
if (event_cond->reason_list
&& list_count(event_cond->reason_list)) {
set = 0;
if (extra)
xstrcat(extra, " && (");
else
xstrcat(extra, " where (");
itr = list_iterator_create(event_cond->reason_list);
while ((object = list_next(itr))) {
if (set)
xstrcat(extra, " || ");
xstrfmtcat(extra, "reason like '%%%s%%'", object);
set = 1;
}
list_iterator_destroy(itr);
xstrcat(extra, ")");
}
if (event_cond->reason_uid_list
&& list_count(event_cond->reason_uid_list)) {
set = 0;
if (extra)
xstrcat(extra, " && (");
else
xstrcat(extra, " where (");
itr = list_iterator_create(event_cond->reason_uid_list);
while ((object = list_next(itr))) {
if (set)
xstrcat(extra, " || ");
xstrfmtcat(extra, "reason_uid='%s'", object);
set = 1;
}
list_iterator_destroy(itr);
xstrcat(extra, ")");
}
if (event_cond->state_list
&& list_count(event_cond->state_list)) {
set = 0;
if (extra)
xstrcat(extra, " && (");
else
xstrcat(extra, " where (");
itr = list_iterator_create(event_cond->state_list);
while ((object = list_next(itr))) {
if (set)
xstrcat(extra, " || ");
xstrfmtcat(extra, "state='%s'", object);
set = 1;
}
list_iterator_destroy(itr);
xstrcat(extra, ")");
}
if (event_cond->cluster_list && list_count(event_cond->cluster_list))
use_cluster_list = event_cond->cluster_list;
empty:
xfree(tmp);
xstrfmtcat(tmp, "%s", event_req_inx[0]);
for(i=1; i<EVENT_REQ_COUNT; i++) {
xstrfmtcat(tmp, ", %s", event_req_inx[i]);
}
if (use_cluster_list == as_mysql_cluster_list)
slurm_mutex_lock(&as_mysql_cluster_list_lock);
ret_list = list_create(slurmdb_destroy_event_rec);
itr = list_iterator_create(use_cluster_list);
while ((object = list_next(itr))) {
query = xstrdup_printf("select %s from \"%s_%s\"",
tmp, object, event_table);
if (extra)
xstrfmtcat(query, " %s", 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);
if (mysql_errno(mysql_conn->db_conn)
!= ER_NO_SUCH_TABLE) {
FREE_NULL_LIST(ret_list);
ret_list = NULL;
}
break;
}
xfree(query);
while ((row = mysql_fetch_row(result))) {
slurmdb_event_rec_t *event =
xmalloc(sizeof(slurmdb_event_rec_t));
list_append(ret_list, event);
event->cluster = xstrdup(object);
if (row[EVENT_REQ_NODE] && row[EVENT_REQ_NODE][0]) {
event->node_name = xstrdup(row[EVENT_REQ_NODE]);
event->event_type = SLURMDB_EVENT_NODE;
} else
event->event_type = SLURMDB_EVENT_CLUSTER;
event->state = slurm_atoul(row[EVENT_REQ_STATE]);
event->period_start = slurm_atoul(row[EVENT_REQ_START]);
event->period_end = slurm_atoul(row[EVENT_REQ_END]);
if (row[EVENT_REQ_REASON] && row[EVENT_REQ_REASON][0])
event->reason = xstrdup(row[EVENT_REQ_REASON]);
event->reason_uid =
slurm_atoul(row[EVENT_REQ_REASON_UID]);
if (row[EVENT_REQ_CNODES] && row[EVENT_REQ_CNODES][0])
event->cluster_nodes =
xstrdup(row[EVENT_REQ_CNODES]);
if (row[EVENT_REQ_TRES] && row[EVENT_REQ_TRES][0])
event->tres_str = xstrdup(row[EVENT_REQ_TRES]);
}
mysql_free_result(result);
}
list_iterator_destroy(itr);
xfree(tmp);
xfree(extra);
if (use_cluster_list == as_mysql_cluster_list)
slurm_mutex_unlock(&as_mysql_cluster_list_lock);
return ret_list;
}
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_remove_accts(mysql_conn_t *mysql_conn, uint32_t uid,
slurmdb_account_cond_t *acct_cond)
{
ListIterator itr = NULL;
List ret_list = NULL;
List coord_list = NULL;
int rc = SLURM_SUCCESS;
char *object = NULL;
char *extra = NULL, *query = NULL,
*name_char = NULL, *assoc_char = NULL;
time_t now = time(NULL);
char *user_name = NULL;
int set = 0;
MYSQL_RES *result = NULL;
MYSQL_ROW row;
bool jobs_running = 0;
if (!acct_cond) {
error("we need something to change");
return NULL;
}
if (check_connection(mysql_conn) != SLURM_SUCCESS)
return NULL;
xstrcat(extra, "where deleted=0");
if (acct_cond->assoc_cond
&& acct_cond->assoc_cond->acct_list
&& list_count(acct_cond->assoc_cond->acct_list)) {
set = 0;
xstrcat(extra, " && (");
itr = list_iterator_create(acct_cond->assoc_cond->acct_list);
while ((object = list_next(itr))) {
if (!object[0])
continue;
if (set)
xstrcat(extra, " || ");
xstrfmtcat(extra, "name='%s'", object);
set = 1;
}
list_iterator_destroy(itr);
xstrcat(extra, ")");
}
if (acct_cond->description_list
&& list_count(acct_cond->description_list)) {
set = 0;
xstrcat(extra, " && (");
itr = list_iterator_create(acct_cond->description_list);
while ((object = list_next(itr))) {
if (set)
xstrcat(extra, " || ");
xstrfmtcat(extra, "description='%s'", object);
set = 1;
}
list_iterator_destroy(itr);
xstrcat(extra, ")");
}
if (acct_cond->organization_list
&& list_count(acct_cond->organization_list)) {
set = 0;
xstrcat(extra, " && (");
itr = list_iterator_create(acct_cond->organization_list);
while ((object = list_next(itr))) {
if (set)
xstrcat(extra, " || ");
xstrfmtcat(extra, "organization='%s'", object);
set = 1;
}
list_iterator_destroy(itr);
xstrcat(extra, ")");
}
if (!extra) {
error("Nothing to remove");
return NULL;
}
query = xstrdup_printf("select name from %s %s;", acct_table, extra);
xfree(extra);
if (!(result = mysql_db_query_ret(
mysql_conn, query, 0))) {
xfree(query);
return NULL;
}
rc = 0;
ret_list = list_create(slurm_destroy_char);
while ((row = mysql_fetch_row(result))) {
char *object = xstrdup(row[0]);
list_append(ret_list, object);
if (!rc) {
xstrfmtcat(name_char, "name='%s'", object);
xstrfmtcat(assoc_char, "t2.acct='%s'", object);
rc = 1;
} else {
xstrfmtcat(name_char, " || name='%s'", object);
xstrfmtcat(assoc_char, " || t2.acct='%s'", object);
}
}
mysql_free_result(result);
if (!list_count(ret_list)) {
errno = SLURM_NO_CHANGE_IN_DATA;
if (debug_flags & DEBUG_FLAG_DB_ASSOC)
DB_DEBUG(mysql_conn->conn,
"didn't effect anything\n%s", query);
xfree(query);
return ret_list;
}
xfree(query);
/* We need to remove these accounts from the coord's that have it */
coord_list = as_mysql_remove_coord(
mysql_conn, uid, ret_list, NULL);
if (coord_list)
list_destroy(coord_list);
user_name = uid_to_string((uid_t) uid);
slurm_mutex_lock(&as_mysql_cluster_list_lock);
itr = list_iterator_create(as_mysql_cluster_list);
while ((object = list_next(itr))) {
if ((rc = remove_common(mysql_conn, DBD_REMOVE_ACCOUNTS, now,
user_name, acct_table, name_char,
assoc_char, object, ret_list,
&jobs_running))
!= SLURM_SUCCESS)
break;
}
list_iterator_destroy(itr);
slurm_mutex_unlock(&as_mysql_cluster_list_lock);
xfree(user_name);
xfree(name_char);
xfree(assoc_char);
if (rc == SLURM_ERROR) {
list_destroy(ret_list);
return NULL;
}
if (jobs_running)
errno = ESLURM_JOBS_RUNNING_ON_ASSOC;
else
errno = SLURM_SUCCESS;
return ret_list;
}
extern int setup_job_cluster_cond_limits(mysql_conn_t *mysql_conn,
slurmdb_job_cond_t *job_cond,
char *cluster_name, char **extra)
{
int set = 0;
ListIterator itr = NULL;
char *object = NULL;
if (!job_cond)
return SLURM_SUCCESS;
/* this must be done before resvid_list since we set
resvid_list up here */
if (job_cond->resv_list && list_count(job_cond->resv_list)) {
char *query = xstrdup_printf(
"select distinct job_db_inx from \"%s_%s\" where (",
cluster_name, job_table);
int my_set = 0;
MYSQL_RES *result = NULL;
MYSQL_ROW row;
itr = list_iterator_create(job_cond->resv_list);
while ((object = list_next(itr))) {
if (my_set)
xstrcat(query, " || ");
xstrfmtcat(query, "resv_name='%s'", object);
my_set = 1;
}
list_iterator_destroy(itr);
xstrcat(query, ")");
if (!(result = mysql_db_query_ret(
mysql_conn, query, 0))) {
xfree(query);
error("couldn't query the database");
goto no_resv;
}
xfree(query);
if (!job_cond->resvid_list)
job_cond->resvid_list = list_create(slurm_destroy_char);
while ((row = mysql_fetch_row(result))) {
list_append(job_cond->resvid_list, xstrdup(row[0]));
}
mysql_free_result(result);
}
no_resv:
if (job_cond->resvid_list && list_count(job_cond->resvid_list)) {
set = 0;
if (*extra)
xstrcat(*extra, " && (");
else
xstrcat(*extra, " where (");
itr = list_iterator_create(job_cond->resvid_list);
while ((object = list_next(itr))) {
if (set)
xstrcat(*extra, " || ");
xstrfmtcat(*extra, "t1.id_resv='%s'", object);
set = 1;
}
list_iterator_destroy(itr);
xstrcat(*extra, ")");
}
if (job_cond->state_list && list_count(job_cond->state_list)) {
itr = list_iterator_create(job_cond->state_list);
while ((object = list_next(itr))) {
uint32_t state = (uint32_t)slurm_atoul(object);
state &= JOB_STATE_BASE;
if (state == JOB_SUSPENDED)
break;
}
list_iterator_destroy(itr);
if (object) {
MYSQL_RES *result = NULL;
MYSQL_ROW row;
char *query = xstrdup_printf(
"select job_db_inx from \"%s_%s\"",
cluster_name, suspend_table);
if (job_cond->usage_start) {
if (!job_cond->usage_end) {
xstrfmtcat(query,
" where (!time_end "
"|| (%d between "
"time_start and time_end))",
(int)job_cond->usage_start);
} else {
xstrfmtcat(query,
" where (!time_end "
"|| (time_start && "
"((%d between time_start "
"and time_end) "
"|| (time_start between "
"%d and %d))))",
(int)job_cond->usage_start,
(int)job_cond->usage_start,
(int)job_cond->usage_end);
}
} else if (job_cond->usage_end) {
xstrfmtcat(query, " where (time_start && "
"time_start < %d)",
(int)job_cond->usage_end);
}
debug3("%d(%s:%d) query\n%s",
mysql_conn->conn, THIS_FILE, __LINE__, query);
result = mysql_db_query_ret(mysql_conn, query, 0);
xfree(query);
if (!result)
return SLURM_ERROR;
set = 0;
while ((row = mysql_fetch_row(result))) {
if (set)
xstrfmtcat(*extra,
" || t1.job_db_inx=%s",
row[0]);
else {
set = 1;
if (*extra)
xstrfmtcat(
*extra,
" || (t1.job_db_inx=%s",
row[0]);
else
xstrfmtcat(*extra, " where "
"(t1.job_db_inx=%s",
row[0]);
}
}
mysql_free_result(result);
if (set)
xstrcat(*extra, ")");
}
}
return SLURM_SUCCESS;
}
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;
}
extern List as_mysql_get_txn(mysql_conn_t *mysql_conn, uid_t uid,
slurmdb_txn_cond_t *txn_cond)
{
char *query = NULL;
char *assoc_extra = NULL;
char *name_extra = NULL;
char *extra = NULL;
char *tmp = NULL;
List txn_list = NULL;
ListIterator itr = NULL;
char *object = NULL;
int set = 0;
int i=0;
MYSQL_RES *result = NULL;
MYSQL_ROW row;
List use_cluster_list = as_mysql_cluster_list;
bool locked = 0;
/* if this changes you will need to edit the corresponding enum */
char *txn_req_inx[] = {
"id",
"timestamp",
"action",
"name",
"actor",
"info",
"cluster"
};
enum {
TXN_REQ_ID,
TXN_REQ_TS,
TXN_REQ_ACTION,
TXN_REQ_NAME,
TXN_REQ_ACTOR,
TXN_REQ_INFO,
TXN_REQ_CLUSTER,
TXN_REQ_COUNT
};
if (check_connection(mysql_conn) != SLURM_SUCCESS)
return NULL;
if (!txn_cond)
goto empty;
/* handle query for associations first */
if (txn_cond->acct_list && list_count(txn_cond->acct_list)) {
set = 0;
if (assoc_extra)
xstrcat(assoc_extra, " && (");
else
xstrcat(assoc_extra, " where (");
if (name_extra)
xstrcat(name_extra, " && (");
else
xstrcat(name_extra, " (");
itr = list_iterator_create(txn_cond->acct_list);
while ((object = list_next(itr))) {
if (set) {
xstrcat(assoc_extra, " || ");
xstrcat(name_extra, " || ");
}
xstrfmtcat(assoc_extra, "acct='%s'", object);
xstrfmtcat(name_extra, "(name like '%%\\'%s\\'%%'"
" || name='%s')"
" || (info like '%%acct=\\'%s\\'%%')",
object, object, object);
set = 1;
}
list_iterator_destroy(itr);
xstrcat(assoc_extra, ")");
xstrcat(name_extra, ")");
}
if (txn_cond->cluster_list && list_count(txn_cond->cluster_list)) {
set = 0;
if (name_extra)
xstrcat(name_extra, " && (");
else
xstrcat(name_extra, "(");
itr = list_iterator_create(txn_cond->cluster_list);
while ((object = list_next(itr))) {
if (set) {
xstrcat(name_extra, " || ");
}
xstrfmtcat(name_extra, "(cluster='%s' || "
"name like '%%\\'%s\\'%%' || name='%s')"
" || (info like '%%cluster=\\'%s\\'%%')",
object, object, object, object);
set = 1;
}
list_iterator_destroy(itr);
xstrcat(name_extra, ")");
use_cluster_list = txn_cond->cluster_list;
}
if (txn_cond->user_list && list_count(txn_cond->user_list)) {
set = 0;
if (assoc_extra)
xstrcat(assoc_extra, " && (");
else
xstrcat(assoc_extra, " where (");
if (name_extra)
xstrcat(name_extra, " && (");
else
xstrcat(name_extra, "(");
itr = list_iterator_create(txn_cond->user_list);
while ((object = list_next(itr))) {
if (set) {
xstrcat(assoc_extra, " || ");
xstrcat(name_extra, " || ");
}
xstrfmtcat(assoc_extra, "user='******'", object);
xstrfmtcat(name_extra, "(name like '%%\\'%s\\'%%'"
" || name='%s')"
" || (info like '%%user=\\'%s\\'%%')",
object, object, object);
set = 1;
}
list_iterator_destroy(itr);
xstrcat(assoc_extra, ")");
xstrcat(name_extra, ")");
}
if (assoc_extra) {
if (!locked && (use_cluster_list == as_mysql_cluster_list)) {
slurm_mutex_lock(&as_mysql_cluster_list_lock);
locked = 1;
}
itr = list_iterator_create(use_cluster_list);
while ((object = list_next(itr))) {
xstrfmtcat(query, "select id_assoc from \"%s_%s\"%s",
object, assoc_table, assoc_extra);
if (debug_flags & DEBUG_FLAG_DB_QUERY)
DB_DEBUG(mysql_conn->conn, "query\n%s", query);
if (!(result = mysql_db_query_ret(
mysql_conn, query, 0))) {
xfree(query);
break;
}
xfree(query);
if (mysql_num_rows(result)) {
if (extra)
xstrfmtcat(extra,
" || (cluster='%s' && (",
object);
else
xstrfmtcat(extra,
" where (cluster='%s' && (",
object);
set = 0;
while ((row = mysql_fetch_row(result))) {
if (set)
xstrcat(extra, " || ");
xstrfmtcat(extra,
"(name like "
"'%%id_assoc=%s %%' "
"|| name like "
"'%%id_assoc=%s)')",
row[0], row[0]);
set = 1;
}
xstrcat(extra, "))");
}
mysql_free_result(result);
}
list_iterator_destroy(itr);
xfree(assoc_extra);
}
if (name_extra) {
if (extra)
xstrfmtcat(extra, " && (%s)", name_extra);
else
xstrfmtcat(extra, " where (%s)", name_extra);
xfree(name_extra);
}
/*******************************************/
if (txn_cond->action_list && list_count(txn_cond->action_list)) {
set = 0;
if (extra)
xstrcat(extra, " && (");
else
xstrcat(extra, " where (");
itr = list_iterator_create(txn_cond->action_list);
while ((object = list_next(itr))) {
if (set)
xstrcat(extra, " || ");
xstrfmtcat(extra, "action='%s'", object);
set = 1;
}
list_iterator_destroy(itr);
xstrcat(extra, ")");
}
if (txn_cond->actor_list && list_count(txn_cond->actor_list)) {
set = 0;
if (extra)
xstrcat(extra, " && (");
else
xstrcat(extra, " where (");
itr = list_iterator_create(txn_cond->actor_list);
while ((object = list_next(itr))) {
if (set)
xstrcat(extra, " || ");
xstrfmtcat(extra, "actor='%s'", object);
set = 1;
}
list_iterator_destroy(itr);
xstrcat(extra, ")");
}
if (txn_cond->id_list && list_count(txn_cond->id_list)) {
set = 0;
if (extra)
xstrcat(extra, " && (");
else
xstrcat(extra, " where (");
itr = list_iterator_create(txn_cond->id_list);
while ((object = list_next(itr))) {
char *ptr = NULL;
long num = strtol(object, &ptr, 10);
if ((num == 0) && ptr && ptr[0]) {
error("Invalid value for txn id (%s)",
object);
xfree(extra);
list_iterator_destroy(itr);
goto end_it;
}
if (set)
xstrcat(extra, " || ");
xstrfmtcat(extra, "id=%s", object);
set = 1;
}
list_iterator_destroy(itr);
xstrcat(extra, ")");
}
if (txn_cond->info_list && list_count(txn_cond->info_list)) {
set = 0;
if (extra)
xstrcat(extra, " && (");
else
xstrcat(extra, " where (");
itr = list_iterator_create(txn_cond->info_list);
while ((object = list_next(itr))) {
if (set)
xstrcat(extra, " || ");
xstrfmtcat(extra, "info like '%%%s%%'", object);
set = 1;
}
list_iterator_destroy(itr);
xstrcat(extra, ")");
}
if (txn_cond->name_list && list_count(txn_cond->name_list)) {
set = 0;
if (extra)
xstrcat(extra, " && (");
else
xstrcat(extra, " where (");
itr = list_iterator_create(txn_cond->name_list);
while ((object = list_next(itr))) {
if (set)
xstrcat(extra, " || ");
xstrfmtcat(extra, "name like '%%%s%%'", object);
set = 1;
}
list_iterator_destroy(itr);
xstrcat(extra, ")");
}
if (txn_cond->time_start && txn_cond->time_end) {
if (extra)
xstrcat(extra, " && (");
else
xstrcat(extra, " where (");
xstrfmtcat(extra, "timestamp < %ld && timestamp >= %ld)",
txn_cond->time_end, txn_cond->time_start);
} else if (txn_cond->time_start) {
if (extra)
xstrcat(extra, " && (");
else
xstrcat(extra, " where (");
xstrfmtcat(extra, "timestamp >= %ld)", txn_cond->time_start);
} else if (txn_cond->time_end) {
if (extra)
xstrcat(extra, " && (");
else
xstrcat(extra, " where (");
xstrfmtcat(extra, "timestamp < %ld)", txn_cond->time_end);
}
/* make sure we can get the max length out of the database
* when grouping the names
*/
if (txn_cond->with_assoc_info)
mysql_db_query(mysql_conn,
"set session group_concat_max_len=65536;");
empty:
if (!locked && (use_cluster_list == as_mysql_cluster_list)) {
slurm_mutex_lock(&as_mysql_cluster_list_lock);
locked = 1;
}
xfree(tmp);
xstrfmtcat(tmp, "%s", txn_req_inx[i]);
for(i=1; i<TXN_REQ_COUNT; i++) {
xstrfmtcat(tmp, ", %s", txn_req_inx[i]);
}
query = xstrdup_printf("select %s from %s", tmp, txn_table);
if (extra) {
xstrfmtcat(query, "%s", extra);
xfree(extra);
}
xstrcat(query, " order by timestamp;");
xfree(tmp);
if (debug_flags & DEBUG_FLAG_DB_QUERY)
DB_DEBUG(mysql_conn->conn, "query\n%s", query);
if (!(result = mysql_db_query_ret(
mysql_conn, query, 0))) {
xfree(query);
goto end_it;
}
xfree(query);
txn_list = list_create(slurmdb_destroy_txn_rec);
while ((row = mysql_fetch_row(result))) {
slurmdb_txn_rec_t *txn = xmalloc(sizeof(slurmdb_txn_rec_t));
list_append(txn_list, txn);
txn->action = slurm_atoul(row[TXN_REQ_ACTION]);
txn->actor_name = xstrdup(row[TXN_REQ_ACTOR]);
txn->id = slurm_atoul(row[TXN_REQ_ID]);
txn->set_info = xstrdup(row[TXN_REQ_INFO]);
txn->timestamp = slurm_atoul(row[TXN_REQ_TS]);
txn->where_query = xstrdup(row[TXN_REQ_NAME]);
txn->clusters = xstrdup(row[TXN_REQ_CLUSTER]);
if (txn_cond && txn_cond->with_assoc_info
&& (txn->action == DBD_ADD_ASSOCS
|| txn->action == DBD_MODIFY_ASSOCS
|| txn->action == DBD_REMOVE_ASSOCS)) {
MYSQL_RES *result2 = NULL;
MYSQL_ROW row2;
if (txn->clusters) {
query = xstrdup_printf(
"select "
"group_concat(distinct user "
"order by user), "
"group_concat(distinct acct "
"order by acct) "
"from \"%s_%s\" where %s",
txn->clusters, assoc_table,
row[TXN_REQ_NAME]);
debug4("%d(%s:%d) query\n%s", mysql_conn->conn,
THIS_FILE, __LINE__, query);
if (!(result2 = mysql_db_query_ret(
mysql_conn, query, 0))) {
xfree(query);
continue;
}
xfree(query);
if ((row2 = mysql_fetch_row(result2))) {
if (row2[0] && row2[0][0])
txn->users = xstrdup(row2[0]);
if (row2[1] && row2[1][0])
txn->accts = xstrdup(row2[1]);
}
mysql_free_result(result2);
} else {
error("We can't handle associations "
"from action %s yet.",
slurmdbd_msg_type_2_str(txn->action, 1));
}
}
}
mysql_free_result(result);
end_it:
if (locked)
slurm_mutex_unlock(&as_mysql_cluster_list_lock);
return txn_list;
}
extern int as_mysql_hourly_rollup(mysql_conn_t *mysql_conn,
char *cluster_name,
time_t start, time_t end,
uint16_t archive_data)
{
int rc = SLURM_SUCCESS;
int add_sec = 3600;
int i=0;
time_t now = time(NULL);
time_t curr_start = start;
time_t curr_end = curr_start + add_sec;
char *query = NULL;
MYSQL_RES *result = NULL;
MYSQL_ROW row;
ListIterator a_itr = NULL;
ListIterator c_itr = NULL;
ListIterator w_itr = NULL;
ListIterator r_itr = NULL;
List assoc_usage_list = list_create(_destroy_local_id_usage);
List cluster_down_list = list_create(_destroy_local_cluster_usage);
List wckey_usage_list = list_create(_destroy_local_id_usage);
List resv_usage_list = list_create(_destroy_local_resv_usage);
uint16_t track_wckey = slurm_get_track_wckey();
/* char start_char[20], end_char[20]; */
char *job_req_inx[] = {
"job.job_db_inx",
"job.id_job",
"job.id_assoc",
"job.id_wckey",
"job.array_task_pending",
"job.time_eligible",
"job.time_start",
"job.time_end",
"job.time_suspended",
"job.cpus_alloc",
"job.cpus_req",
"job.id_resv",
"SUM(step.consumed_energy)"
};
char *job_str = NULL;
enum {
JOB_REQ_DB_INX,
JOB_REQ_JOBID,
JOB_REQ_ASSOCID,
JOB_REQ_WCKEYID,
JOB_REQ_ARRAY_PENDING,
JOB_REQ_ELG,
JOB_REQ_START,
JOB_REQ_END,
JOB_REQ_SUSPENDED,
JOB_REQ_ACPU,
JOB_REQ_RCPU,
JOB_REQ_RESVID,
JOB_REQ_ENERGY,
JOB_REQ_COUNT
};
char *suspend_req_inx[] = {
"time_start",
"time_end"
};
char *suspend_str = NULL;
enum {
SUSPEND_REQ_START,
SUSPEND_REQ_END,
SUSPEND_REQ_COUNT
};
char *resv_req_inx[] = {
"id_resv",
"assoclist",
"cpus",
"flags",
"time_start",
"time_end"
};
char *resv_str = NULL;
enum {
RESV_REQ_ID,
RESV_REQ_ASSOCS,
RESV_REQ_CPU,
RESV_REQ_FLAGS,
RESV_REQ_START,
RESV_REQ_END,
RESV_REQ_COUNT
};
i=0;
xstrfmtcat(job_str, "%s", job_req_inx[i]);
for(i=1; i<JOB_REQ_COUNT; i++) {
xstrfmtcat(job_str, ", %s", job_req_inx[i]);
}
i=0;
xstrfmtcat(suspend_str, "%s", suspend_req_inx[i]);
for(i=1; i<SUSPEND_REQ_COUNT; i++) {
xstrfmtcat(suspend_str, ", %s", suspend_req_inx[i]);
}
i=0;
xstrfmtcat(resv_str, "%s", resv_req_inx[i]);
for(i=1; i<RESV_REQ_COUNT; i++) {
xstrfmtcat(resv_str, ", %s", resv_req_inx[i]);
}
/* info("begin start %s", slurm_ctime(&curr_start)); */
/* info("begin end %s", slurm_ctime(&curr_end)); */
a_itr = list_iterator_create(assoc_usage_list);
c_itr = list_iterator_create(cluster_down_list);
w_itr = list_iterator_create(wckey_usage_list);
r_itr = list_iterator_create(resv_usage_list);
while (curr_start < end) {
int last_id = -1;
int last_wckeyid = -1;
int seconds = 0;
int tot_time = 0;
local_cluster_usage_t *loc_c_usage = NULL;
local_cluster_usage_t *c_usage = NULL;
local_resv_usage_t *r_usage = NULL;
local_id_usage_t *a_usage = NULL;
local_id_usage_t *w_usage = NULL;
if (debug_flags & DEBUG_FLAG_DB_USAGE)
DB_DEBUG(mysql_conn->conn,
"%s curr hour is now %ld-%ld",
cluster_name, curr_start, curr_end);
/* info("start %s", slurm_ctime(&curr_start)); */
/* info("end %s", slurm_ctime(&curr_end)); */
c_usage = _setup_cluster_usage(mysql_conn, cluster_name,
curr_start, curr_end,
cluster_down_list);
// now get the reservations during this time
/* If a reservation has the IGNORE_JOBS flag we don't
* have an easy way to distinguish the cpus a job not
* running in the reservation, but on it's cpus.
* So we will just ignore these reservations for
* accounting purposes.
*/
query = xstrdup_printf("select %s from \"%s_%s\" where "
"(time_start < %ld && time_end >= %ld) "
"&& !(flags & %u)"
"order by time_start",
resv_str, cluster_name, resv_table,
curr_end, curr_start,
RESERVE_FLAG_IGN_JOBS);
if (debug_flags & DEBUG_FLAG_DB_USAGE)
DB_DEBUG(mysql_conn->conn, "query\n%s", query);
if (!(result = mysql_db_query_ret(
mysql_conn, query, 0))) {
xfree(query);
_destroy_local_cluster_usage(c_usage);
return SLURM_ERROR;
}
xfree(query);
/* If a reservation overlaps another reservation we
total up everything here as if they didn't but when
calculating the total time for a cluster we will
remove the extra time received. This may result in
unexpected results with association based reports
since the association is given the total amount of
time of each reservation, thus equaling more time
than is available. Job/Cluster/Reservation reports
should be fine though since we really don't over
allocate resources. The issue with us not being
able to handle overlapping reservations here is
unless the reservation completely overlaps the
other reservation we have no idea how many cpus
should be removed since this could be a
heterogeneous system. This same problem exists
when a reservation is created with the ignore_jobs
option which will allow jobs to continue to run in the
reservation that aren't suppose to.
*/
while ((row = mysql_fetch_row(result))) {
time_t row_start = slurm_atoul(row[RESV_REQ_START]);
time_t row_end = slurm_atoul(row[RESV_REQ_END]);
uint32_t row_cpu = slurm_atoul(row[RESV_REQ_CPU]);
uint32_t row_flags = slurm_atoul(row[RESV_REQ_FLAGS]);
if (row_start < curr_start)
row_start = curr_start;
if (!row_end || row_end > curr_end)
row_end = curr_end;
/* Don't worry about it if the time is less
* than 1 second.
*/
if ((row_end - row_start) < 1)
continue;
r_usage = xmalloc(sizeof(local_resv_usage_t));
r_usage->id = slurm_atoul(row[RESV_REQ_ID]);
r_usage->local_assocs = list_create(slurm_destroy_char);
slurm_addto_char_list(r_usage->local_assocs,
row[RESV_REQ_ASSOCS]);
r_usage->total_time = (row_end - row_start) * row_cpu;
r_usage->start = row_start;
r_usage->end = row_end;
list_append(resv_usage_list, r_usage);
/* Since this reservation was added to the
cluster and only certain people could run
there we will use this as allocated time on
the system. If the reservation was a
maintenance then we add the time to planned
down time.
*/
/* only record time for the clusters that have
registered. This continue should rarely if
ever happen.
*/
if (!c_usage)
continue;
else if (row_flags & RESERVE_FLAG_MAINT)
c_usage->pd_cpu += r_usage->total_time;
else
c_usage->a_cpu += r_usage->total_time;
/* slurm_make_time_str(&r_usage->start, start_char, */
/* sizeof(start_char)); */
/* slurm_make_time_str(&r_usage->end, end_char, */
/* sizeof(end_char)); */
/* info("adding this much %lld to cluster %s " */
/* "%d %d %s - %s", */
/* r_usage->total_time, c_usage->name, */
/* (row_flags & RESERVE_FLAG_MAINT), */
/* r_usage->id, start_char, end_char); */
}
mysql_free_result(result);
/* now get the jobs during this time only */
query = xstrdup_printf("select %s from \"%s_%s\" as job "
"left outer join \"%s_%s\" as step on "
"job.job_db_inx=step.job_db_inx "
"and (step.id_step>=0) "
"where (job.time_eligible < %ld && "
"(job.time_end >= %ld || "
"job.time_end = 0)) "
"group by job.job_db_inx "
"order by job.id_assoc, "
"job.time_eligible",
job_str, cluster_name, job_table,
cluster_name, step_table,
curr_end, curr_start);
if (debug_flags & DEBUG_FLAG_DB_USAGE)
DB_DEBUG(mysql_conn->conn, "query\n%s", query);
if (!(result = mysql_db_query_ret(
mysql_conn, query, 0))) {
xfree(query);
_destroy_local_cluster_usage(c_usage);
return SLURM_ERROR;
}
xfree(query);
while ((row = mysql_fetch_row(result))) {
uint32_t job_id = slurm_atoul(row[JOB_REQ_JOBID]);
uint32_t assoc_id = slurm_atoul(row[JOB_REQ_ASSOCID]);
uint32_t wckey_id = slurm_atoul(row[JOB_REQ_WCKEYID]);
uint32_t array_pending =
slurm_atoul(row[JOB_REQ_ARRAY_PENDING]);
uint32_t resv_id = slurm_atoul(row[JOB_REQ_RESVID]);
time_t row_eligible = slurm_atoul(row[JOB_REQ_ELG]);
time_t row_start = slurm_atoul(row[JOB_REQ_START]);
time_t row_end = slurm_atoul(row[JOB_REQ_END]);
uint32_t row_acpu = slurm_atoul(row[JOB_REQ_ACPU]);
uint32_t row_rcpu = slurm_atoul(row[JOB_REQ_RCPU]);
uint64_t row_energy = 0;
int loc_seconds = 0;
seconds = 0;
if (row[JOB_REQ_ENERGY])
row_energy = slurm_atoull(row[JOB_REQ_ENERGY]);
if (row_start && (row_start < curr_start))
row_start = curr_start;
if (!row_start && row_end)
row_start = row_end;
if (!row_end || row_end > curr_end)
row_end = curr_end;
if (!row_start || ((row_end - row_start) < 1))
goto calc_cluster;
seconds = (row_end - row_start);
if (slurm_atoul(row[JOB_REQ_SUSPENDED])) {
MYSQL_RES *result2 = NULL;
MYSQL_ROW row2;
/* get the suspended time for this job */
query = xstrdup_printf(
"select %s from \"%s_%s\" where "
"(time_start < %ld && (time_end >= %ld "
"|| time_end = 0)) && job_db_inx=%s "
"order by time_start",
suspend_str, cluster_name,
suspend_table,
curr_end, curr_start,
row[JOB_REQ_DB_INX]);
debug4("%d(%s:%d) query\n%s",
mysql_conn->conn, THIS_FILE,
__LINE__, query);
if (!(result2 = mysql_db_query_ret(
mysql_conn,
query, 0))) {
xfree(query);
_destroy_local_cluster_usage(c_usage);
return SLURM_ERROR;
}
xfree(query);
while ((row2 = mysql_fetch_row(result2))) {
time_t local_start = slurm_atoul(
row2[SUSPEND_REQ_START]);
time_t local_end = slurm_atoul(
row2[SUSPEND_REQ_END]);
if (!local_start)
continue;
if (row_start > local_start)
local_start = row_start;
if (row_end < local_end)
local_end = row_end;
tot_time = (local_end - local_start);
if (tot_time < 1)
continue;
seconds -= tot_time;
}
mysql_free_result(result2);
}
if (seconds < 1) {
debug4("This job (%u) was suspended "
"the entire hour", job_id);
continue;
}
if (last_id != assoc_id) {
a_usage = xmalloc(sizeof(local_id_usage_t));
a_usage->id = assoc_id;
list_append(assoc_usage_list, a_usage);
last_id = assoc_id;
}
a_usage->a_cpu += seconds * row_acpu;
a_usage->energy += row_energy;
if (!track_wckey)
goto calc_cluster;
/* do the wckey calculation */
if (last_wckeyid != wckey_id) {
list_iterator_reset(w_itr);
while ((w_usage = list_next(w_itr)))
if (w_usage->id == wckey_id)
break;
if (!w_usage) {
w_usage = xmalloc(
sizeof(local_id_usage_t));
w_usage->id = wckey_id;
list_append(wckey_usage_list,
w_usage);
}
last_wckeyid = wckey_id;
}
w_usage->a_cpu += seconds * row_acpu;
w_usage->energy += row_energy;
/* do the cluster allocated calculation */
calc_cluster:
/* Now figure out there was a disconnected
slurmctld durning this job.
*/
list_iterator_reset(c_itr);
while ((loc_c_usage = list_next(c_itr))) {
int temp_end = row_end;
int temp_start = row_start;
if (loc_c_usage->start > temp_start)
temp_start = loc_c_usage->start;
if (loc_c_usage->end < temp_end)
temp_end = loc_c_usage->end;
loc_seconds = (temp_end - temp_start);
if (loc_seconds < 1)
continue;
loc_seconds *= row_acpu;
/* info(" Job %u was running for " */
/* "%d seconds while " */
/* "cluster %s's slurmctld " */
/* "wasn't responding", */
/* job_id, loc_seconds, cluster_name); */
if (loc_seconds >= loc_c_usage->total_time)
loc_c_usage->total_time = 0;
else {
loc_c_usage->total_time -=
loc_seconds * row_acpu;
}
}
/* first figure out the reservation */
if (resv_id) {
if (seconds <= 0)
continue;
/* Since we have already added the
entire reservation as used time on
the cluster we only need to
calculate the used time for the
reservation and then divy up the
unused time over the associations
able to run in the reservation.
Since the job was to run, or ran a
reservation we don't care about
eligible time since that could
totally skew the clusters reserved time
since the job may be able to run
outside of the reservation. */
list_iterator_reset(r_itr);
while ((r_usage = list_next(r_itr))) {
/* since the reservation could
have changed in some way,
thus making a new
reservation record in the
database, we have to make
sure all the reservations
are checked to see if such
a thing has happened */
if (r_usage->id == resv_id) {
int temp_end = row_end;
int temp_start = row_start;
if (r_usage->start > temp_start)
temp_start =
r_usage->start;
if (r_usage->end < temp_end)
temp_end = r_usage->end;
if ((temp_end - temp_start)
> 0) {
r_usage->a_cpu +=
(temp_end
- temp_start)
* row_acpu;
}
}
}
continue;
}
/* only record time for the clusters that have
registered. This continue should rarely if
ever happen.
*/
if (!c_usage)
continue;
if (row_start && (seconds > 0)) {
/* info("%d assoc %d adds " */
/* "(%d)(%d-%d) * %d = %d " */
/* "to %d", */
/* job_id, */
/* a_usage->id, */
/* seconds, */
/* row_end, row_start, */
/* row_acpu, */
/* seconds * row_acpu, */
/* row_acpu); */
c_usage->a_cpu += seconds * row_acpu;
c_usage->energy += row_energy;
}
/* now reserved time */
if (!row_start || (row_start >= c_usage->start)) {
int temp_end = row_start;
int temp_start = row_eligible;
if (c_usage->start > temp_start)
temp_start = c_usage->start;
if (c_usage->end < temp_end)
temp_end = c_usage->end;
loc_seconds = (temp_end - temp_start);
if (loc_seconds > 0) {
/* If we have pending jobs in
an array they haven't been
inserted into the database
yet as proper job records,
so handle them here.
*/
if (array_pending)
loc_seconds *= array_pending;
/* info("%d assoc %d reserved " */
/* "(%d)(%d-%d) * %d * %d = %d " */
/* "to %d", */
/* job_id, */
/* assoc_id, */
/* temp_end - temp_start, */
/* temp_end, temp_start, */
/* row_rcpu, */
/* array_pending, */
/* loc_seconds, */
/* row_rcpu); */
c_usage->r_cpu +=
loc_seconds * row_rcpu;
}
}
}
mysql_free_result(result);
/* now figure out how much more to add to the
associations that could had run in the reservation
*/
list_iterator_reset(r_itr);
while ((r_usage = list_next(r_itr))) {
int64_t idle = r_usage->total_time - r_usage->a_cpu;
char *assoc = NULL;
ListIterator tmp_itr = NULL;
if (idle <= 0)
continue;
/* now divide that time by the number of
associations in the reservation and add
them to each association */
seconds = idle / list_count(r_usage->local_assocs);
/* info("resv %d got %d for seconds for %d assocs", */
/* r_usage->id, seconds, */
/* list_count(r_usage->local_assocs)); */
tmp_itr = list_iterator_create(r_usage->local_assocs);
while ((assoc = list_next(tmp_itr))) {
uint32_t associd = slurm_atoul(assoc);
if (last_id != associd) {
list_iterator_reset(a_itr);
while ((a_usage = list_next(a_itr))) {
if (a_usage->id == associd) {
last_id = a_usage->id;
break;
}
}
}
if (!a_usage) {
a_usage = xmalloc(
sizeof(local_id_usage_t));
a_usage->id = associd;
list_append(assoc_usage_list, a_usage);
last_id = associd;
}
a_usage->a_cpu += seconds;
}
list_iterator_destroy(tmp_itr);
}
/* now apply the down time from the slurmctld disconnects */
if (c_usage) {
list_iterator_reset(c_itr);
while ((loc_c_usage = list_next(c_itr)))
c_usage->d_cpu += loc_c_usage->total_time;
if ((rc = _process_cluster_usage(
mysql_conn, cluster_name, curr_start,
curr_end, now, c_usage))
!= SLURM_SUCCESS) {
_destroy_local_cluster_usage(c_usage);
goto end_it;
}
}
list_iterator_reset(a_itr);
while ((a_usage = list_next(a_itr))) {
/* info("association (%d) %d alloc %d", */
/* a_usage->id, last_id, */
/* a_usage->a_cpu); */
if (query) {
xstrfmtcat(query,
", (%ld, %ld, %d, %ld, %"PRIu64", "
"%"PRIu64")",
now, now,
a_usage->id, curr_start,
a_usage->a_cpu, a_usage->energy);
} else {
xstrfmtcat(query,
"insert into \"%s_%s\" "
"(creation_time, "
"mod_time, id_assoc, time_start, "
"alloc_cpu_secs, consumed_energy) "
"values "
"(%ld, %ld, %d, %ld, %"PRIu64", "
"%"PRIu64")",
cluster_name, assoc_hour_table,
now, now,
a_usage->id, curr_start,
a_usage->a_cpu, a_usage->energy);
}
}
if (query) {
xstrfmtcat(query,
" on duplicate key update "
"mod_time=%ld, "
"alloc_cpu_secs=VALUES(alloc_cpu_secs), "
"consumed_energy=VALUES(consumed_energy);",
now);
if (debug_flags & DEBUG_FLAG_DB_USAGE)
DB_DEBUG(mysql_conn->conn, "query\n%s", query);
rc = mysql_db_query(mysql_conn, query);
xfree(query);
if (rc != SLURM_SUCCESS) {
error("Couldn't add assoc hour rollup");
_destroy_local_cluster_usage(c_usage);
goto end_it;
}
}
if (!track_wckey)
goto end_loop;
list_iterator_reset(w_itr);
while ((w_usage = list_next(w_itr))) {
/* info("association (%d) %d alloc %d", */
/* w_usage->id, last_id, */
/* w_usage->a_cpu); */
if (query) {
xstrfmtcat(query,
", (%ld, %ld, %d, %ld, "
"%"PRIu64", %"PRIu64")",
now, now,
w_usage->id, curr_start,
w_usage->a_cpu, w_usage->energy);
} else {
xstrfmtcat(query,
"insert into \"%s_%s\" "
"(creation_time, "
"mod_time, id_wckey, time_start, "
"alloc_cpu_secs, consumed_energy) "
"values "
"(%ld, %ld, %d, %ld, "
"%"PRIu64", %"PRIu64")",
cluster_name, wckey_hour_table,
now, now,
w_usage->id, curr_start,
w_usage->a_cpu, w_usage->energy);
}
}
if (query) {
xstrfmtcat(query,
" on duplicate key update "
"mod_time=%ld, "
"alloc_cpu_secs=VALUES(alloc_cpu_secs), "
"consumed_energy=VALUES(consumed_energy);",
now);
if (debug_flags & DEBUG_FLAG_DB_USAGE)
DB_DEBUG(mysql_conn->conn, "query\n%s", query);
rc = mysql_db_query(mysql_conn, query);
xfree(query);
if (rc != SLURM_SUCCESS) {
error("Couldn't add wckey hour rollup");
_destroy_local_cluster_usage(c_usage);
goto end_it;
}
}
end_loop:
_destroy_local_cluster_usage(c_usage);
list_flush(assoc_usage_list);
list_flush(cluster_down_list);
list_flush(wckey_usage_list);
list_flush(resv_usage_list);
curr_start = curr_end;
curr_end = curr_start + add_sec;
}
end_it:
xfree(suspend_str);
xfree(job_str);
xfree(resv_str);
list_iterator_destroy(a_itr);
list_iterator_destroy(c_itr);
list_iterator_destroy(w_itr);
list_iterator_destroy(r_itr);
list_destroy(assoc_usage_list);
list_destroy(cluster_down_list);
list_destroy(wckey_usage_list);
list_destroy(resv_usage_list);
/* info("stop start %s", slurm_ctime(&curr_start)); */
/* info("stop end %s", slurm_ctime(&curr_end)); */
/* go check to see if we archive and purge */
if (rc == SLURM_SUCCESS)
rc = _process_purge(mysql_conn, cluster_name, archive_data,
SLURMDB_PURGE_HOURS);
return rc;
}
extern int setup_job_cluster_cond_limits(mysql_conn_t *mysql_conn,
slurmdb_job_cond_t *job_cond,
char *cluster_name, char **extra)
{
int set = 0;
ListIterator itr = NULL;
char *object = NULL;
if (!job_cond)
return SLURM_SUCCESS;
/* this must be done before resvid_list since we set
resvid_list up here */
if (job_cond->resv_list && list_count(job_cond->resv_list)) {
char *query = xstrdup_printf(
"select distinct job_db_inx from \"%s_%s\" where (",
cluster_name, job_table);
int my_set = 0;
MYSQL_RES *result = NULL;
MYSQL_ROW row;
itr = list_iterator_create(job_cond->resv_list);
while ((object = list_next(itr))) {
if (my_set)
xstrcat(query, " || ");
xstrfmtcat(query, "resv_name='%s'", object);
my_set = 1;
}
list_iterator_destroy(itr);
xstrcat(query, ")");
if (!(result = mysql_db_query_ret(
mysql_conn, query, 0))) {
xfree(query);
error("couldn't query the database");
goto no_resv;
}
xfree(query);
if (!job_cond->resvid_list)
job_cond->resvid_list = list_create(slurm_destroy_char);
while ((row = mysql_fetch_row(result))) {
list_append(job_cond->resvid_list, xstrdup(row[0]));
}
mysql_free_result(result);
}
no_resv:
if (job_cond->resvid_list && list_count(job_cond->resvid_list)) {
set = 0;
if (*extra)
xstrcat(*extra, " && (");
else
xstrcat(*extra, " where (");
itr = list_iterator_create(job_cond->resvid_list);
while ((object = list_next(itr))) {
if (set)
xstrcat(*extra, " || ");
xstrfmtcat(*extra, "t1.id_resv='%s'", object);
set = 1;
}
list_iterator_destroy(itr);
xstrcat(*extra, ")");
}
if (job_cond->state_list && list_count(job_cond->state_list)) {
set = 0;
if (*extra)
xstrcat(*extra, " && (");
else
xstrcat(*extra, " where (");
itr = list_iterator_create(job_cond->state_list);
while ((object = list_next(itr))) {
if (set)
xstrcat(*extra, " || ");
_state_time_string(extra, cluster_name,
(uint32_t)slurm_atoul(object),
job_cond->usage_start,
job_cond->usage_end);
set = 1;
}
list_iterator_destroy(itr);
xstrcat(*extra, ")");
}
return SLURM_SUCCESS;
}
