int
hv_to_assoc_cond(HV* hv, slurmdb_assoc_cond_t* assoc_cond)
{
AV* element_av;
SV** svp;
char* str = NULL;
int i, elements = 0;
time_t start_time = 0;
time_t end_time = 0;
if ( (svp = hv_fetch (hv, "usage_start", strlen("usage_start"), FALSE)) ) {
start_time = (time_t) (SV2time_t(*svp));
}
if ( (svp = hv_fetch (hv, "usage_end", strlen("usage_end"), FALSE)) ) {
end_time = (time_t) (SV2time_t(*svp));
}
slurmdb_report_set_start_end_time(&start_time, &end_time);
assoc_cond->usage_start = start_time;
assoc_cond->usage_end = end_time;
assoc_cond->with_usage = 1;
assoc_cond->with_deleted = 0;
assoc_cond->with_raw_qos = 0;
assoc_cond->with_sub_accts = 0;
assoc_cond->without_parent_info = 0;
assoc_cond->without_parent_limits = 0;
FETCH_FIELD(hv, assoc_cond, with_usage, uint16_t, FALSE);
FETCH_FIELD(hv, assoc_cond, with_deleted, uint16_t, FALSE);
FETCH_FIELD(hv, assoc_cond, with_raw_qos, uint16_t, FALSE);
FETCH_FIELD(hv, assoc_cond, with_sub_accts, uint16_t, FALSE);
FETCH_FIELD(hv, assoc_cond, without_parent_info, uint16_t, FALSE);
FETCH_FIELD(hv, assoc_cond, without_parent_limits, uint16_t, FALSE);
FETCH_LIST_FIELD(hv, assoc_cond, acct_list);
FETCH_LIST_FIELD(hv, assoc_cond, cluster_list);
FETCH_LIST_FIELD(hv, assoc_cond, def_qos_id_list);
FETCH_LIST_FIELD(hv, assoc_cond, id_list);
FETCH_LIST_FIELD(hv, assoc_cond, parent_acct_list);
FETCH_LIST_FIELD(hv, assoc_cond, partition_list);
FETCH_LIST_FIELD(hv, assoc_cond, qos_list);
FETCH_LIST_FIELD(hv, assoc_cond, user_list);
return 0;
}
static int _set_wckey_cond(int *start, int argc, char *argv[],
slurmdb_wckey_cond_t *wckey_cond,
List format_list)
{
int i;
int set = 0;
int end = 0;
int command_len = 0;
int local_cluster_flag = all_clusters_flag;
time_t start_time, end_time;
int option = 0;
if(!wckey_cond) {
error("No wckey_cond given");
return -1;
}
wckey_cond->with_usage = 1;
wckey_cond->with_deleted = 1;
if(!wckey_cond->cluster_list)
wckey_cond->cluster_list = list_create(slurm_destroy_char);
for (i=(*start); i<argc; i++) {
end = parse_option_end(argv[i]);
if(!end)
command_len=strlen(argv[i]);
else {
command_len=end-1;
if(argv[i][end] == '=') {
option = (int)argv[i][end-1];
end++;
}
}
if(!end && !strncasecmp(argv[i], "all_clusters",
MAX(command_len, 1))) {
local_cluster_flag = 1;
} else if(!end && !strncasecmp(argv[i], "withdeleted",
MAX(command_len, 5))) {
wckey_cond->with_deleted = 1;
set = 1;
} else if(!end
|| !strncasecmp (argv[i], "WCKeys",
MAX(command_len, 3))) {
if(!wckey_cond->name_list)
wckey_cond->name_list =
list_create(slurm_destroy_char);
if(slurm_addto_char_list(wckey_cond->name_list,
argv[i]+end))
set = 1;
} else if (!strncasecmp (argv[i], "Clusters",
MAX(command_len, 3))) {
if(!wckey_cond->cluster_list)
wckey_cond->cluster_list =
list_create(slurm_destroy_char);
if(slurm_addto_char_list(wckey_cond->cluster_list,
argv[i]+end))
set = 1;
} else if (!strncasecmp (argv[i], "End", MAX(command_len, 1))) {
wckey_cond->usage_end = parse_time(argv[i]+end, 1);
set = 1;
} else if (!strncasecmp (argv[i], "Format",
MAX(command_len, 1))) {
if(format_list)
slurm_addto_char_list(format_list, argv[i]+end);
} else if (!strncasecmp (argv[i], "Start",
MAX(command_len, 1))) {
wckey_cond->usage_start = parse_time(argv[i]+end, 1);
set = 1;
} else if (!strncasecmp (argv[i], "User",
MAX(command_len, 1))) {
if(!wckey_cond->user_list)
wckey_cond->user_list =
list_create(slurm_destroy_char);
if(slurm_addto_char_list(wckey_cond->user_list,
argv[i]+end))
set = 1;
} else {
exit_code=1;
fprintf(stderr, " Unknown condition: %s\n", argv[i]);
}
}
(*start) = i;
if(!local_cluster_flag && !list_count(wckey_cond->cluster_list)) {
char *temp = slurm_get_cluster_name();
if(temp)
list_append(wckey_cond->cluster_list, temp);
}
/* This needs to be done on some systems to make sure
wckey_cond isn't messed. This has happened on some 64
bit machines and this is here to be on the safe side.
*/
start_time = wckey_cond->usage_start;
end_time = wckey_cond->usage_end;
slurmdb_report_set_start_end_time(&start_time, &end_time);
wckey_cond->usage_start = start_time;
wckey_cond->usage_end = end_time;
return set;
}
static int _set_assoc_cond(int *start, int argc, char *argv[],
slurmdb_association_cond_t *assoc_cond,
List format_list)
{
int i;
int set = 0;
int end = 0;
int local_cluster_flag = all_clusters_flag;
time_t start_time, end_time;
int command_len = 0;
int option = 0;
if(!assoc_cond) {
error("We need an slurmdb_association_cond to call this");
return SLURM_ERROR;
}
assoc_cond->with_usage = 1;
assoc_cond->with_deleted = 1;
if(!assoc_cond->cluster_list)
assoc_cond->cluster_list = list_create(slurm_destroy_char);
for (i=(*start); i<argc; i++) {
end = parse_option_end(argv[i]);
if(!end)
command_len=strlen(argv[i]);
else {
command_len=end-1;
if(argv[i][end] == '=') {
option = (int)argv[i][end-1];
end++;
}
}
if(!end && !strncasecmp(argv[i], "all_clusters",
MAX(command_len, 1))) {
local_cluster_flag = 1;
} else if (!end && !strncasecmp (argv[i], "Tree",
MAX(command_len, 4))) {
tree_display = 1;
} else if(!end
|| !strncasecmp (argv[i], "Users",
MAX(command_len, 1))) {
if(!assoc_cond->user_list)
assoc_cond->user_list =
list_create(slurm_destroy_char);
slurm_addto_char_list(assoc_cond->user_list,
argv[i]+end);
set = 1;
} else if (!strncasecmp (argv[i], "Accounts",
MAX(command_len, 2))
|| !strncasecmp(argv[i], "Acct",
MAX(command_len, 4))) {
if(!assoc_cond->acct_list)
assoc_cond->acct_list =
list_create(slurm_destroy_char);
slurm_addto_char_list(assoc_cond->acct_list,
argv[i]+end);
set = 1;
} else if (!strncasecmp (argv[i], "Clusters",
MAX(command_len, 1))) {
slurm_addto_char_list(assoc_cond->cluster_list,
argv[i]+end);
set = 1;
} else if (!strncasecmp (argv[i], "End", MAX(command_len, 1))) {
assoc_cond->usage_end = parse_time(argv[i]+end, 1);
set = 1;
} else if (!strncasecmp (argv[i], "Format",
MAX(command_len, 1))) {
if(format_list)
slurm_addto_char_list(format_list,
argv[i]+end);
} else if (!strncasecmp (argv[i], "Start",
MAX(command_len, 1))) {
assoc_cond->usage_start = parse_time(argv[i]+end, 1);
set = 1;
} else {
exit_code=1;
fprintf(stderr, " Unknown condition: %s\n"
"Use keyword set to modify value\n", argv[i]);
}
}
(*start) = i;
if(!local_cluster_flag && !list_count(assoc_cond->cluster_list)) {
char *temp = slurm_get_cluster_name();
if(temp)
list_append(assoc_cond->cluster_list, temp);
}
/* This needs to be done on some systems to make sure
assoc_cond isn't messed. This has happened on some 64
bit machines and this is here to be on the safe side.
*/
start_time = assoc_cond->usage_start;
end_time = assoc_cond->usage_end;
slurmdb_report_set_start_end_time(&start_time, &end_time);
assoc_cond->usage_start = start_time;
assoc_cond->usage_end = end_time;
return set;
}
static List _process_util_by_report(void *db_conn, char *calling_name,
void *cond, cluster_report_t type)
{ ListIterator itr = NULL;
ListIterator type_itr = NULL;
slurmdb_cluster_cond_t cluster_cond;
List type_list = NULL;
List cluster_list = NULL;
List first_list = NULL;
slurmdb_cluster_rec_t *cluster = NULL;
slurmdb_report_cluster_rec_t *slurmdb_report_cluster = NULL;
time_t start_time, end_time;
int exit_code = 0;
uid_t my_uid = getuid();
List ret_list = list_create(slurmdb_destroy_report_cluster_rec);
slurmdb_init_cluster_cond(&cluster_cond, 0);
cluster_cond.with_deleted = 1;
cluster_cond.with_usage = 1;
if ((type == CLUSTER_REPORT_UA) || (type == CLUSTER_REPORT_AU)) {
start_time = ((slurmdb_assoc_cond_t *)cond)->usage_start;
end_time = ((slurmdb_assoc_cond_t *)cond)->usage_end;
cluster_cond.cluster_list =
((slurmdb_assoc_cond_t *)cond)->cluster_list;
} else if ((type == CLUSTER_REPORT_UW) || (type == CLUSTER_REPORT_WU)) {
start_time = ((slurmdb_wckey_cond_t *)cond)->usage_start;
end_time = ((slurmdb_wckey_cond_t *)cond)->usage_end;
cluster_cond.cluster_list =
((slurmdb_wckey_cond_t *)cond)->cluster_list;
} else {
error("unknown report type %d", type);
return NULL;
}
/* This needs to be done on some systems to make sure
cluster_cond isn't messed. This has happened on some 64
bit machines and this is here to be on the safe side.
*/
slurmdb_report_set_start_end_time(&start_time, &end_time);
cluster_cond.usage_end = end_time;
cluster_cond.usage_start = start_time;
cluster_list = acct_storage_g_get_clusters(
db_conn, my_uid, &cluster_cond);
if (!cluster_list) {
exit_code=1;
fprintf(stderr, "%s: Problem with cluster query.\n",
calling_name);
goto end_it;
}
if ((type == CLUSTER_REPORT_UA) || (type == CLUSTER_REPORT_AU)) {
((slurmdb_assoc_cond_t *)cond)->usage_start = start_time;
((slurmdb_assoc_cond_t *)cond)->usage_end = end_time;
type_list = acct_storage_g_get_assocs(
db_conn, my_uid, cond);
} else if ((type == CLUSTER_REPORT_UW) || (type == CLUSTER_REPORT_WU)) {
((slurmdb_wckey_cond_t *)cond)->usage_start = start_time;
((slurmdb_wckey_cond_t *)cond)->usage_end = end_time;
type_list = acct_storage_g_get_wckeys(
db_conn, my_uid, cond);
}
if (!type_list) {
exit_code=1;
fprintf(stderr, "%s: Problem with get query.\n", calling_name);
goto end_it;
}
if ((type == CLUSTER_REPORT_UA) || (type == CLUSTER_REPORT_AU)) {
first_list = type_list;
type_list = slurmdb_get_hierarchical_sorted_assoc_list(
first_list, true);
}
/* set up the structures for easy retrieval later */
itr = list_iterator_create(cluster_list);
type_itr = list_iterator_create(type_list);
while((cluster = list_next(itr))) {
/* check to see if this cluster is around during the
time we are looking at */
if (!cluster->accounting_list
|| !list_count(cluster->accounting_list))
continue;
slurmdb_report_cluster = slurmdb_cluster_rec_2_report(cluster);
list_append(ret_list, slurmdb_report_cluster);
if ((type == CLUSTER_REPORT_UA) || (type == CLUSTER_REPORT_UW))
slurmdb_report_cluster->user_list =
list_create(slurmdb_destroy_report_user_rec);
else if ((type == CLUSTER_REPORT_AU)
|| (type == CLUSTER_REPORT_WU))
slurmdb_report_cluster->assoc_list =
list_create(slurmdb_destroy_report_assoc_rec);
if ((type == CLUSTER_REPORT_UA) || (type == CLUSTER_REPORT_AU))
_process_assoc_type(type_itr, slurmdb_report_cluster,
cluster->name, type);
else if ((type == CLUSTER_REPORT_UW)
|| (type == CLUSTER_REPORT_WU))
_process_wckey_type(type_itr, slurmdb_report_cluster,
cluster->name, type);
list_iterator_reset(type_itr);
}
list_iterator_destroy(type_itr);
list_iterator_destroy(itr);
end_it:
FREE_NULL_LIST(type_list);
FREE_NULL_LIST(first_list);
FREE_NULL_LIST(cluster_list);
if (exit_code)
FREE_NULL_LIST(ret_list);
return ret_list;
}
int
hv_to_job_cond(HV* hv, slurmdb_job_cond_t* job_cond)
{
AV* element_av;
SV** svp;
char* str = NULL;
int i, elements = 0;
time_t start_time = 0;
time_t end_time = 0;
if ( (svp = hv_fetch (hv, "step_list", strlen("step_list"), FALSE)) ) {
char *jobids = (char *) (SvPV_nolen(*svp));
if (!job_cond->step_list)
job_cond->step_list =
slurm_list_create(slurmdb_destroy_selected_step);
slurm_addto_step_list(job_cond->step_list, jobids);
}
if ( (svp = hv_fetch (hv, "usage_start", strlen("usage_start"), FALSE)) ) {
start_time = (time_t) (SV2time_t(*svp));
}
if ( (svp = hv_fetch (hv, "usage_end", strlen("usage_end"), FALSE)) ) {
end_time = (time_t) (SV2time_t(*svp));
}
slurmdb_report_set_start_end_time(&start_time, &end_time);
job_cond->usage_start = start_time;
job_cond->usage_end = end_time;
job_cond->cpus_max = 0;
job_cond->cpus_min = 0;
job_cond->duplicates = 0;
job_cond->nodes_max = 0;
job_cond->nodes_min = 0;
job_cond->used_nodes = NULL;
job_cond->without_steps = 0;
job_cond->without_usage_truncation = 0;
FETCH_FIELD(hv, job_cond, cpus_max, uint32_t, FALSE);
FETCH_FIELD(hv, job_cond, cpus_min, uint32_t, FALSE);
FETCH_FIELD(hv, job_cond, duplicates, uint16_t, FALSE);
FETCH_FIELD(hv, job_cond, exitcode, int32_t, FALSE);
FETCH_FIELD(hv, job_cond, nodes_max, uint32_t, FALSE);
FETCH_FIELD(hv, job_cond, nodes_min, uint32_t, FALSE);
FETCH_FIELD(hv, job_cond, timelimit_max, uint32_t, FALSE);
FETCH_FIELD(hv, job_cond, timelimit_min, uint32_t, FALSE);
FETCH_FIELD(hv, job_cond, usage_end, time_t, FALSE);
FETCH_FIELD(hv, job_cond, usage_start, time_t, FALSE);
FETCH_FIELD(hv, job_cond, used_nodes, charp, FALSE);
FETCH_FIELD(hv, job_cond, without_steps, uint16_t, FALSE);
FETCH_FIELD(hv, job_cond, without_usage_truncation, uint16_t, FALSE);
FETCH_LIST_FIELD(hv, job_cond, acct_list);
FETCH_LIST_FIELD(hv, job_cond, associd_list);
FETCH_LIST_FIELD(hv, job_cond, cluster_list);
FETCH_LIST_FIELD(hv, job_cond, groupid_list);
FETCH_LIST_FIELD(hv, job_cond, jobname_list);
FETCH_LIST_FIELD(hv, job_cond, partition_list);
FETCH_LIST_FIELD(hv, job_cond, qos_list);
FETCH_LIST_FIELD(hv, job_cond, resv_list);
FETCH_LIST_FIELD(hv, job_cond, resvid_list);
FETCH_LIST_FIELD(hv, job_cond, state_list);
FETCH_LIST_FIELD(hv, job_cond, userid_list);
FETCH_LIST_FIELD(hv, job_cond, wckey_list);
return 0;
}
extern List slurmdb_report_user_top_usage(void *db_conn,
slurmdb_user_cond_t *user_cond,
bool group_accounts)
{
List cluster_list = NULL;
ListIterator itr = NULL;
ListIterator itr2 = NULL;
ListIterator itr3 = NULL;
ListIterator cluster_itr = NULL;
slurmdb_cluster_cond_t cluster_cond;
List user_list = NULL;
List usage_cluster_list = NULL;
char *object = NULL;
int exit_code = 0;
slurmdb_user_rec_t *user = NULL;
slurmdb_cluster_rec_t *cluster = NULL;
slurmdb_assoc_rec_t *assoc = NULL;
slurmdb_report_user_rec_t *slurmdb_report_user = NULL;
slurmdb_report_cluster_rec_t *slurmdb_report_cluster = NULL;
uid_t my_uid = getuid();
bool delete_user_cond = 0, delete_assoc_cond = 0,
delete_cluster_list = 0;
time_t start_time, end_time;
if (!user_cond) {
delete_user_cond = 1;
user_cond = xmalloc(sizeof(slurmdb_user_cond_t));
}
if (!user_cond->assoc_cond) {
delete_assoc_cond = 1;
user_cond->assoc_cond =
xmalloc(sizeof(slurmdb_assoc_cond_t));
}
if (!user_cond->assoc_cond->cluster_list) {
delete_cluster_list = 1;
user_cond->assoc_cond->cluster_list =
list_create(slurm_destroy_char);
}
user_cond->with_deleted = 1;
user_cond->with_assocs = 1;
user_cond->assoc_cond->with_usage = 1;
user_cond->assoc_cond->without_parent_info = 1;
/* This needs to be done on some systems to make sure
assoc_cond isn't messed up. This has happened on some 64
bit machines and this is here to be on the safe side.
*/
start_time = user_cond->assoc_cond->usage_start;
end_time = user_cond->assoc_cond->usage_end;
slurmdb_report_set_start_end_time(&start_time, &end_time);
user_cond->assoc_cond->usage_start = start_time;
user_cond->assoc_cond->usage_end = end_time;
user_list = acct_storage_g_get_users(db_conn, my_uid, user_cond);
if (!user_list) {
exit_code=1;
fprintf(stderr, " Problem with user query.\n");
goto end_it;
}
/* We have to get the clusters here or we will be unable to
get the correct total time for the cluster if associations
are not enforced.
*/
slurmdb_init_cluster_cond(&cluster_cond, 0);
cluster_cond.with_usage = 1;
cluster_cond.with_deleted = 1;
cluster_cond.usage_end = user_cond->assoc_cond->usage_end;
cluster_cond.usage_start = user_cond->assoc_cond->usage_start;
cluster_cond.cluster_list = user_cond->assoc_cond->cluster_list;
usage_cluster_list = acct_storage_g_get_clusters(
db_conn, my_uid, &cluster_cond);
if (!usage_cluster_list) {
exit_code=1;
fprintf(stderr, " Problem with cluster query.\n");
goto end_it;
}
cluster_list = list_create(slurmdb_destroy_report_cluster_rec);
itr = list_iterator_create(usage_cluster_list);
while((cluster = list_next(itr))) {
/* check to see if this cluster is around during the
time we are looking at */
if (!cluster->accounting_list
|| !list_count(cluster->accounting_list))
continue;
slurmdb_report_cluster = slurmdb_cluster_rec_2_report(cluster);
list_append(cluster_list, slurmdb_report_cluster);
slurmdb_report_cluster->user_list =
list_create(slurmdb_destroy_report_user_rec);
}
list_iterator_destroy(itr);
list_destroy(usage_cluster_list);
itr = list_iterator_create(user_list);
cluster_itr = list_iterator_create(cluster_list);
while((user = list_next(itr))) {
struct passwd *passwd_ptr = NULL;
if (!user->assoc_list || !list_count(user->assoc_list))
continue;
passwd_ptr = getpwnam(user->name);
if (passwd_ptr)
user->uid = passwd_ptr->pw_uid;
else
user->uid = (uint32_t)NO_VAL;
itr2 = list_iterator_create(user->assoc_list);
while((assoc = list_next(itr2))) {
if (!assoc->accounting_list
|| !list_count(assoc->accounting_list))
continue;
while((slurmdb_report_cluster =
list_next(cluster_itr))) {
if (!strcmp(slurmdb_report_cluster->name,
assoc->cluster)) {
ListIterator user_itr = NULL;
if (!group_accounts) {
slurmdb_report_user = NULL;
goto new_user;
}
user_itr = list_iterator_create(
slurmdb_report_cluster->
user_list);
while((slurmdb_report_user
= list_next(user_itr))) {
if (slurmdb_report_user->uid
!= NO_VAL) {
if (slurmdb_report_user->
uid
== user->uid)
break;
} else if (slurmdb_report_user->
name
&& !strcasecmp(
slurmdb_report_user->
name,
user->name))
break;
}
list_iterator_destroy(user_itr);
new_user:
if (!slurmdb_report_user) {
slurmdb_report_user = xmalloc(
sizeof
(slurmdb_report_user_rec_t));
slurmdb_report_user->name =
xstrdup(assoc->user);
slurmdb_report_user->uid =
user->uid;
slurmdb_report_user->acct_list =
list_create
(slurm_destroy_char);
list_append(slurmdb_report_cluster->
user_list,
slurmdb_report_user);
}
break;
}
}
if (!slurmdb_report_cluster) {
error("This cluster '%s' hasn't "
"registered yet, but we have jobs "
"that ran?", assoc->cluster);
slurmdb_report_cluster =
xmalloc(sizeof(slurmdb_report_cluster_rec_t));
list_append(cluster_list, slurmdb_report_cluster);
slurmdb_report_cluster->name = xstrdup(assoc->cluster);
slurmdb_report_cluster->user_list =
list_create(slurmdb_destroy_report_user_rec);
slurmdb_report_user =
xmalloc(sizeof(slurmdb_report_user_rec_t));
slurmdb_report_user->name = xstrdup(assoc->user);
slurmdb_report_user->uid = user->uid;
slurmdb_report_user->acct_list =
list_create(slurm_destroy_char);
list_append(slurmdb_report_cluster->user_list,
slurmdb_report_user);
}
list_iterator_reset(cluster_itr);
itr3 = list_iterator_create(
slurmdb_report_user->acct_list);
while((object = list_next(itr3))) {
if (!strcmp(object, assoc->acct))
break;
}
list_iterator_destroy(itr3);
if (!object)
list_append(slurmdb_report_user->acct_list,
xstrdup(assoc->acct));
slurmdb_transfer_acct_list_2_tres(
assoc->accounting_list,
&slurmdb_report_user->tres_list);
}
list_iterator_destroy(itr2);
}
list_iterator_destroy(itr);
list_iterator_destroy(cluster_itr);
end_it:
if (delete_cluster_list) {
list_destroy(user_cond->assoc_cond->cluster_list);
user_cond->assoc_cond->cluster_list = NULL;
}
if (delete_assoc_cond) {
slurmdb_destroy_assoc_cond(user_cond->assoc_cond);
user_cond->assoc_cond = NULL;
}
if (delete_user_cond) {
slurmdb_destroy_user_cond(user_cond);
user_cond = NULL;
}
if (user_list) {
list_destroy(user_list);
user_list = NULL;
}
if (exit_code) {
if (cluster_list) {
list_destroy(cluster_list);
cluster_list = NULL;
}
}
return cluster_list;
}
