/* Prepare cluster_list to be federation centric that will be passed to
* verify_clsuters_exists in federation_functions.c.
*/
static int _verify_fed_clusters(List cluster_list, const char *fed_name,
bool *existing_fed)
{
int rc = SLURM_SUCCESS;
char *tmp_name = NULL;
List tmp_list = list_create(slurmdb_destroy_cluster_rec);
ListIterator itr = list_iterator_create(cluster_list);
while ((tmp_name = list_next(itr))) {
slurmdb_cluster_rec_t *rec =
xmalloc(sizeof(slurmdb_cluster_rec_t));
slurmdb_init_cluster_rec(rec, 0);
rec->name = xstrdup(tmp_name);
list_append(tmp_list, rec);
}
if ((rc = verify_fed_clusters(tmp_list, fed_name, existing_fed)))
goto end_it;
/* have to reconcile lists now, clusters may have been removed from
* tmp_list */
list_iterator_reset(itr);
while ((tmp_name = list_next(itr))) {
if (!list_find_first(tmp_list, _find_cluster_rec_in_list,
tmp_name))
list_delete_item(itr);
}
end_it:
FREE_NULL_LIST(tmp_list);
list_iterator_destroy(itr);
return rc;
}
/* Add clusters to be removed if "setting" a federation to a specific set of
* clusters or clearing all clusters.
*
* IN cluster_list: list of slurmdb_cluster_rec_t's with cluster names set that
* are to be "set" on the federation the federation.
* IN federation: name of the federation that is being added/modified.
*/
static int _add_clusters_to_remove(List cluster_list, const char *federation)
{
List db_list = NULL;
ListIterator db_itr = NULL;
slurmdb_federation_cond_t db_cond;
slurmdb_federation_rec_t *db_rec = NULL;
slurmdb_cluster_rec_t *db_cluster = NULL;
slurmdb_init_federation_cond(&db_cond, 0);
db_cond.federation_list = list_create(slurm_destroy_char);
list_append(db_cond.federation_list, xstrdup(federation));
db_list = acct_storage_g_get_federations(db_conn, my_uid, &db_cond);
if (!db_list || !list_count(db_list)) {
fprintf(stderr, " Problem getting federations "
"from database. Contact your admin.\n");
return SLURM_ERROR;
}
FREE_NULL_LIST(db_cond.federation_list);
db_rec = list_peek(db_list);
db_itr = list_iterator_create(db_rec->cluster_list);
while ((db_cluster = list_next(db_itr))) {
bool found_cluster = false;
slurmdb_cluster_rec_t *orig_cluster = NULL;
ListIterator orig_itr = list_iterator_create(cluster_list);
/* Figure out if cluster in cluster_list is already on the
* federation. If if is, don't add to list to remove */
while ((orig_cluster = list_next(orig_itr))) {
char *db_name = db_cluster->name;
if (*db_name == '+' || *db_name == '-')
++db_name;
if (!xstrcmp(orig_cluster->name, db_name)) {
found_cluster = true;
break;
}
}
list_iterator_destroy(orig_itr);
if (found_cluster)
continue;
slurmdb_cluster_rec_t *cluster =
xmalloc(sizeof(slurmdb_cluster_rec_t));
slurmdb_init_cluster_rec(cluster, 0);
cluster->name = xstrdup_printf("-%s", db_cluster->name);
list_append(cluster_list, cluster);
}
list_iterator_destroy(db_itr);
FREE_NULL_LIST(db_list);
return SLURM_SUCCESS;
}
static void _setup_env_working_cluster(void)
{
char *working_env = NULL;
if ((working_env = xstrdup(getenv("SLURM_WORKING_CLUSTER")))) {
char *addr_ptr, *port_ptr, *rpc_ptr;
if (!(addr_ptr = strchr(working_env, ':')) ||
!(port_ptr = strchr(addr_ptr + 1, ':')) ||
!(rpc_ptr = strchr(port_ptr + 1, ':'))) {
error("malformed cluster addr and port in SLURM_WORKING_CLUSTER env var: '%s'",
working_env);
exit(1);
}
*addr_ptr++ = '\0';
*port_ptr++ = '\0';
*rpc_ptr++ = '\0';
if (strcmp(slurmctld_conf.cluster_name, working_env)) {
working_cluster_rec =
xmalloc(sizeof(slurmdb_cluster_rec_t));
slurmdb_init_cluster_rec(working_cluster_rec, false);
working_cluster_rec->control_host = xstrdup(addr_ptr);;
working_cluster_rec->control_port = strtol(port_ptr,
NULL, 10);
working_cluster_rec->rpc_version = strtol(rpc_ptr,
NULL, 10);
slurm_set_addr(&working_cluster_rec->control_addr,
working_cluster_rec->control_port,
working_cluster_rec->control_host);
}
xfree(working_env);
}
}
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 int sacctmgr_add_cluster(int argc, char **argv)
{
int rc = SLURM_SUCCESS;
int i = 0;
slurmdb_cluster_rec_t *cluster = NULL;
slurmdb_cluster_rec_t *start_cluster =
xmalloc(sizeof(slurmdb_cluster_rec_t));
List name_list = list_create(slurm_destroy_char);
List cluster_list = NULL;
slurmdb_assoc_rec_t start_assoc;
int limit_set = 0;
ListIterator itr = NULL, itr_c = NULL;
char *name = NULL;
slurmdb_init_assoc_rec(&start_assoc, 0);
slurmdb_init_cluster_rec(start_cluster, 0);
for (i=0; i<argc; i++) {
int command_len = strlen(argv[i]);
if (!strncasecmp(argv[i], "Where", MAX(command_len, 5))
|| !strncasecmp(argv[i], "Set", MAX(command_len, 3)))
i++;
limit_set += _set_rec(&i, argc, argv,
name_list, &start_assoc, start_cluster);
}
if (exit_code) {
FREE_NULL_LIST(name_list);
slurmdb_destroy_cluster_rec(start_cluster);
return SLURM_ERROR;
} else if (!list_count(name_list)) {
FREE_NULL_LIST(name_list);
slurmdb_destroy_cluster_rec(start_cluster);
exit_code=1;
fprintf(stderr, " Need name of cluster to add.\n");
return SLURM_ERROR;
} else {
List temp_list = NULL;
slurmdb_cluster_cond_t cluster_cond;
slurmdb_init_cluster_cond(&cluster_cond, 0);
cluster_cond.cluster_list = name_list;
cluster_cond.classification = start_cluster->classification;
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");
slurmdb_destroy_cluster_rec(start_cluster);
return SLURM_ERROR;
}
itr_c = list_iterator_create(name_list);
itr = list_iterator_create(temp_list);
while((name = list_next(itr_c))) {
slurmdb_cluster_rec_t *cluster_rec = NULL;
list_iterator_reset(itr);
while((cluster_rec = list_next(itr))) {
if (!xstrcasecmp(cluster_rec->name, name))
break;
}
if (cluster_rec) {
printf(" This cluster %s already exists. "
"Not adding.\n", name);
list_delete_item(itr_c);
}
}
list_iterator_destroy(itr);
list_iterator_destroy(itr_c);
FREE_NULL_LIST(temp_list);
if (!list_count(name_list)) {
FREE_NULL_LIST(name_list);
slurmdb_destroy_cluster_rec(start_cluster);
return SLURM_ERROR;
}
}
if (start_cluster->fed.name) {
int rc;
List fed_list = list_create(slurm_destroy_char);
list_append(fed_list, xstrdup(start_cluster->fed.name));
rc = verify_federations_exist(fed_list);
FREE_NULL_LIST(fed_list);
if (rc) {
slurmdb_destroy_cluster_rec(start_cluster);
FREE_NULL_LIST(name_list);
return SLURM_ERROR;
}
}
printf(" Adding Cluster(s)\n");
cluster_list = list_create(slurmdb_destroy_cluster_rec);
itr = list_iterator_create(name_list);
while((name = list_next(itr))) {
if (!name[0]) {
exit_code=1;
fprintf(stderr, " No blank names are "
"allowed when adding.\n");
rc = SLURM_ERROR;
continue;
}
cluster = xmalloc(sizeof(slurmdb_cluster_rec_t));
slurmdb_init_cluster_rec(cluster, 0);
list_append(cluster_list, cluster);
slurmdb_copy_cluster_rec(cluster, start_cluster);
cluster->name = xstrdup(name);
printf(" Name = %s\n", cluster->name);
cluster->root_assoc =
xmalloc(sizeof(slurmdb_assoc_rec_t));
slurmdb_init_assoc_rec(cluster->root_assoc, 0);
cluster->root_assoc->def_qos_id = start_assoc.def_qos_id;
cluster->root_assoc->shares_raw = start_assoc.shares_raw;
slurmdb_copy_assoc_rec_limits(
cluster->root_assoc, &start_assoc);
}
list_iterator_destroy(itr);
FREE_NULL_LIST(name_list);
if (limit_set)
printf(" Setting\n");
if (limit_set & CLUS_REC_SET)
sacctmgr_print_cluster(start_cluster);
if (limit_set & CLUS_ASSOC_SET) {
printf(" Default Limits:\n");
sacctmgr_print_assoc_limits(&start_assoc);
FREE_NULL_LIST(start_assoc.qos_list);
}
slurmdb_destroy_cluster_rec(start_cluster);
if (!list_count(cluster_list)) {
printf(" Nothing new added.\n");
rc = SLURM_ERROR;
goto end_it;
}
/* Since we are creating tables with add cluster that can't be
rolled back. So we ask before hand if they are serious
about it so we can rollback if needed.
*/
if (commit_check("Would you like to commit changes?")) {
notice_thread_init();
rc = acct_storage_g_add_clusters(db_conn, my_uid, cluster_list);
notice_thread_fini();
if (rc == SLURM_SUCCESS) {
acct_storage_g_commit(db_conn, 1);
} else {
exit_code=1;
fprintf(stderr, " Problem adding clusters: %s\n",
slurm_strerror(rc));
/* this isn't really needed, but just to be safe */
acct_storage_g_commit(db_conn, 0);
}
} else {
printf(" Changes Discarded\n");
/* this isn't really needed, but just to be safe */
acct_storage_g_commit(db_conn, 0);
}
end_it:
FREE_NULL_LIST(cluster_list);
return rc;
}
static int _set_rec(int *start, int argc, char **argv,
List name_list, slurmdb_federation_rec_t *fed)
{
int i;
int set = 0;
int end = 0;
int command_len = 0;
int option = 0;
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 (!strncasecmp (argv[i], "Where", MAX(command_len, 5))) {
i--;
break;
} else if (!end && !strncasecmp(argv[i], "set",
MAX(command_len, 3))) {
continue;
} else if (!end
|| !strncasecmp (argv[i], "Name",
MAX(command_len, 1))) {
if (name_list)
slurm_addto_char_list(name_list, argv[i]+end);
} else if (!fed) {
continue;
} else if (!strncasecmp (argv[i], "Clusters",
MAX(command_len, 2))) {
char *name = NULL;
ListIterator itr;
if (*(argv[i]+end) == '\0' &&
(option == '+' || option == '-')) {
printf(" You didn't specify any clusters to"
" %s\n",
(option == '-') ? "remove" : "add");
exit_code = 1;
break;
}
List cluster_names = list_create(slurm_destroy_char);
if (slurm_addto_mode_char_list(cluster_names,
argv[i]+end, option) < 0)
{
FREE_NULL_LIST(cluster_names);
exit_code = 1;
break;
}
itr = list_iterator_create(cluster_names);
fed->cluster_list =
list_create(slurmdb_destroy_cluster_rec);
while((name = list_next(itr))) {
if (name[0] == '\0')
continue;
slurmdb_cluster_rec_t *cluster =
xmalloc(sizeof(slurmdb_cluster_rec_t));
slurmdb_init_cluster_rec(cluster, 0);
cluster->name = xstrdup(name);
list_append(fed->cluster_list, cluster);
}
list_iterator_destroy(itr);
FREE_NULL_LIST(cluster_names);
set = 1;
} else if (!strncasecmp (argv[i], "Flags",
MAX(command_len, 2))) {
fed->flags = str_2_federation_flags(argv[i]+end,
option);
if (fed->flags == FEDERATION_FLAG_NOTSET) {
char *tmp_char = NULL;
fed->flags = INFINITE;
fed->flags &= (~FEDERATION_FLAG_NOTSET &
~FEDERATION_FLAG_ADD &
~FEDERATION_FLAG_REMOVE);
tmp_char =
slurmdb_federation_flags_str(
fed->flags);
printf(" Unknown federation flag used in:\n"
" '%s'\n"
" Valid federation flags are\n '%s'\n",
argv[i]+end, tmp_char);
xfree(tmp_char);
exit_code = 1;
} else
set = 1;
} else {
exit_code = 1;
printf(" Unknown option: %s\n"
" Use keyword 'where' to modify condition\n",
argv[i]);
}
}
(*start) = i;
return set;
}
extern int sacctmgr_modify_cluster(int argc, char *argv[])
{
int rc = SLURM_SUCCESS;
int i=0;
slurmdb_association_rec_t *assoc =
xmalloc(sizeof(slurmdb_association_rec_t));
slurmdb_association_cond_t *assoc_cond =
xmalloc(sizeof(slurmdb_association_cond_t));
int cond_set = 0, prev_set = 0, rec_set = 0, set = 0;
List ret_list = NULL;
uint16_t class_rec = 0;
slurmdb_cluster_cond_t cluster_cond;
slurmdb_init_association_rec(assoc, 0);
assoc_cond->cluster_list = list_create(slurm_destroy_char);
assoc_cond->acct_list = list_create(NULL);
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, &class_rec);
rec_set |= prev_set;
} else {
prev_set = _set_cond(&i, argc, argv,
&cluster_cond, NULL);
cond_set |= prev_set;
}
}
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;
}
} else if(exit_code) {
rc = SLURM_ERROR;
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 */
if(assoc_cond->cluster_list)
list_destroy(assoc_cond->cluster_list);
assoc_cond->cluster_list = temp_list;
}
printf(" Setting\n");
if(rec_set) {
printf(" Default Limits =\n");
sacctmgr_print_assoc_limits(assoc);
if(class_rec)
printf(" Cluster Classification = %s\n",
get_classification_str(class_rec));
}
list_append(assoc_cond->acct_list, "root");
notice_thread_init();
ret_list = acct_storage_g_modify_associations(
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");
} else {
exit_code=1;
fprintf(stderr, " Error with request: %s\n",
slurm_strerror(errno));
rc = SLURM_ERROR;
}
if(ret_list)
list_destroy(ret_list);
if(class_rec) {
slurmdb_cluster_rec_t cluster_rec;
slurmdb_init_cluster_rec(&cluster_rec, 0);
/* the class has already returned these clusters so
just go with it */
cluster_rec.classification = class_rec;
ret_list = acct_storage_g_modify_clusters(
db_conn, my_uid, &cluster_cond, &cluster_rec);
if(ret_list && list_count(ret_list)) {
char *object = NULL;
ListIterator itr = list_iterator_create(ret_list);
printf(" Modified cluster classifications...\n");
while((object = list_next(itr))) {
printf(" %s\n", object);
}
list_iterator_destroy(itr);
set = 1;
} else if(ret_list) {
printf(" Nothing modified\n");
} else {
exit_code=1;
fprintf(stderr, " Error with request: %s\n",
slurm_strerror(errno));
rc = SLURM_ERROR;
}
if(ret_list)
list_destroy(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_association_cond(assoc_cond);
slurmdb_destroy_association_rec(assoc);
return rc;
}
