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; }