extern int sacctmgr_modify_cluster(int argc, char **argv) { int rc = SLURM_SUCCESS; int i=0; slurmdb_cluster_rec_t *cluster = xmalloc(sizeof(slurmdb_cluster_rec_t)); slurmdb_assoc_rec_t *assoc = xmalloc(sizeof(slurmdb_assoc_rec_t)); slurmdb_assoc_cond_t *assoc_cond = xmalloc(sizeof(slurmdb_assoc_cond_t)); int cond_set = 0, prev_set = 0, rec_set = 0, set = 0; List ret_list = NULL; slurmdb_cluster_cond_t cluster_cond; bool existing_fed = false; slurmdb_init_assoc_rec(assoc, 0); assoc_cond->cluster_list = list_create(slurm_destroy_char); assoc_cond->acct_list = list_create(NULL); slurmdb_init_cluster_rec(cluster, 0); slurmdb_init_cluster_cond(&cluster_cond, 0); cluster_cond.cluster_list = assoc_cond->cluster_list; for (i=0; i<argc; i++) { int command_len = strlen(argv[i]); if (!strncasecmp(argv[i], "Where", MAX(command_len, 5))) { i++; prev_set = _set_cond(&i, argc, argv, &cluster_cond, NULL); cond_set |= prev_set; } else if (!strncasecmp(argv[i], "Set", MAX(command_len, 3))) { i++; prev_set = _set_rec(&i, argc, argv, NULL, assoc, cluster); rec_set |= prev_set; } else { prev_set = _set_cond(&i, argc, argv, &cluster_cond, NULL); cond_set |= prev_set; } } if (exit_code) { rc = SLURM_ERROR; goto end_it; } else if (!rec_set) { exit_code=1; fprintf(stderr, " You didn't give me anything to set\n"); rc = SLURM_ERROR; goto end_it; } else if (!cond_set) { if (!commit_check("You didn't set any conditions with 'WHERE'.\n" "Are you sure you want to continue?")) { printf("Aborted\n"); rc = SLURM_SUCCESS; goto end_it; } } if (cluster->fed.name && cluster->fed.name[0]) { int rc; /* Make sure federation exists. */ List fed_list = list_create(slurm_destroy_char); list_append(fed_list, xstrdup(cluster->fed.name)); rc = verify_federations_exist(fed_list); FREE_NULL_LIST(fed_list); if (rc) goto end_it; /* See if cluster is assigned to another federation already. */ if (list_count(cluster_cond.cluster_list)) { if (_verify_fed_clusters(cluster_cond.cluster_list, cluster->fed.name, &existing_fed)) goto end_it; else if (!list_count(cluster_cond.cluster_list)) { /* irrelevant changes have been removed and * nothing to change now. */ printf("Nothing to change\n"); rc = SLURM_ERROR; (void)rc; /* CLANG false positive */ goto end_it; } else if (existing_fed) { char *warning = "\nAre you sure you want to continue?"; if (!commit_check(warning)) { rc = SLURM_ERROR; (void)rc; /* CLANG false positive */ goto end_it; } } } } if (cond_set & 1) { List temp_list = NULL; temp_list = acct_storage_g_get_clusters(db_conn, my_uid, &cluster_cond); if (!temp_list) { exit_code=1; fprintf(stderr, " Problem getting clusters from database. " "Contact your admin.\n"); rc = SLURM_ERROR; goto end_it; } else if (!list_count(temp_list)) { fprintf(stderr, " Query didn't return any clusters.\n"); rc = SLURM_ERROR; goto end_it; } /* we are only looking for the clusters returned from this query, so we free the cluster_list and replace it */ FREE_NULL_LIST(assoc_cond->cluster_list); assoc_cond->cluster_list = temp_list; } printf(" Setting\n"); if (rec_set & CLUS_REC_SET) sacctmgr_print_cluster(cluster); if (rec_set & CLUS_ASSOC_SET) { printf(" Default Limits:\n"); sacctmgr_print_assoc_limits(assoc); } if (rec_set & CLUS_REC_SET) { notice_thread_init(); ret_list = acct_storage_g_modify_clusters( db_conn, my_uid, &cluster_cond, cluster); if (ret_list && list_count(ret_list)) { char *object = NULL; ListIterator itr = list_iterator_create(ret_list); printf(" Modified cluster...\n"); while((object = list_next(itr))) { printf(" %s\n", object); } list_iterator_destroy(itr); set = 1; } else if (ret_list) { printf(" Nothing modified\n"); rc = SLURM_ERROR; } else { exit_code=1; fprintf(stderr, " Error with request: %s\n", slurm_strerror(errno)); rc = SLURM_ERROR; } FREE_NULL_LIST(ret_list); notice_thread_fini(); } if (rec_set & CLUS_ASSOC_SET) { list_append(assoc_cond->acct_list, "root"); notice_thread_init(); ret_list = acct_storage_g_modify_assocs(db_conn, my_uid, assoc_cond, assoc); if (ret_list && list_count(ret_list)) { char *object = NULL; ListIterator itr = list_iterator_create(ret_list); printf(" Modified cluster defaults for " "associations...\n"); while((object = list_next(itr))) { printf(" %s\n", object); } list_iterator_destroy(itr); set = 1; } else if (ret_list) { printf(" Nothing modified\n"); rc = SLURM_ERROR; } else { exit_code=1; fprintf(stderr, " Error with request: %s\n", slurm_strerror(errno)); rc = SLURM_ERROR; } FREE_NULL_LIST(ret_list); notice_thread_fini(); } if (set) { if (commit_check("Would you like to commit changes?")) acct_storage_g_commit(db_conn, 1); else { printf(" Changes Discarded\n"); acct_storage_g_commit(db_conn, 0); } } end_it: slurmdb_destroy_assoc_cond(assoc_cond); slurmdb_destroy_assoc_rec(assoc); slurmdb_destroy_cluster_rec(cluster); return rc; }
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; }