/* 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 int _verify_federations(List name_list, bool report_existing)
{
int rc = SLURM_SUCCESS;
char *name = NULL;
List temp_list = NULL;
ListIterator itr = NULL;
ListIterator itr_c = NULL;
slurmdb_federation_cond_t fed_cond;
slurmdb_init_federation_cond(&fed_cond, 0);
fed_cond.federation_list = name_list;
temp_list = acct_storage_g_get_federations(db_conn, my_uid, &fed_cond);
if (!temp_list) {
fprintf(stderr,
" Problem getting federations from database. "
"Contact your admin.\n");
return SLURM_ERROR;
}
itr_c = list_iterator_create(name_list);
itr = list_iterator_create(temp_list);
while((name = list_next(itr_c))) {
slurmdb_federation_rec_t *fed_rec = NULL;
list_iterator_reset(itr);
while((fed_rec = list_next(itr))) {
if (!strcasecmp(fed_rec->name, name))
break;
}
if (fed_rec && report_existing) {
printf(" This federation %s already exists. "
"Not adding.\n", name);
list_delete_item(itr_c);
} else if (!fed_rec && !report_existing) {
printf(" The federation %s doesn't exist.\n", name);
rc = SLURM_ERROR;
}
}
list_iterator_destroy(itr);
list_iterator_destroy(itr_c);
FREE_NULL_LIST(temp_list);
if (!list_count(name_list) || rc != SLURM_SUCCESS) {
return SLURM_ERROR;
}
return SLURM_SUCCESS;
}
/*
* get info from the storage
* IN: slurmdb_federation_cond_t *
* RET: List of slurmdb_federation_rec_t *
* note List needs to be freed when called
*/
extern List slurmdb_get_federations(void *db_conn,
slurmdb_federation_cond_t *fed_cond)
{
return acct_storage_g_get_federations(db_conn, getuid(), fed_cond);
}
extern int sacctmgr_list_federation(int argc, char **argv)
{
int rc = SLURM_SUCCESS;
slurmdb_federation_cond_t *federation_cond =
xmalloc(sizeof(slurmdb_federation_cond_t));
List federation_list;
int i=0;
ListIterator itr = NULL;
ListIterator itr2 = NULL;
slurmdb_federation_rec_t *fed = NULL;
bool print_clusters = false;
int field_count = 0;
print_field_t *field = NULL;
List format_list = list_create(slurm_destroy_char);
List print_fields_list; /* types are of print_field_t */
slurmdb_init_federation_cond(federation_cond, 0);
federation_cond->federation_list = list_create(slurm_destroy_char);
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++;
_set_cond(&i, argc, argv, federation_cond, format_list);
}
if (exit_code) {
slurmdb_destroy_federation_cond(federation_cond);
FREE_NULL_LIST(format_list);
return SLURM_ERROR;
}
if (!list_count(format_list)) {
slurm_addto_char_list(format_list,
"Federation,Cluster,ID%2,"
"Features,FedState");
}
print_fields_list = sacctmgr_process_format_list(format_list);
FREE_NULL_LIST(format_list);
if (exit_code) {
slurmdb_destroy_federation_cond(federation_cond);
FREE_NULL_LIST(print_fields_list);
return SLURM_ERROR;
}
federation_list = acct_storage_g_get_federations(db_conn, my_uid,
federation_cond);
slurmdb_destroy_federation_cond(federation_cond);
if (!federation_list) {
exit_code=1;
fprintf(stderr, " Problem with query.\n");
FREE_NULL_LIST(print_fields_list);
return SLURM_ERROR;
}
itr = list_iterator_create(federation_list);
itr2 = list_iterator_create(print_fields_list);
print_fields_header(print_fields_list);
field_count = list_count(print_fields_list);
/* only print clusters if a cluster field is requested */
while((field = list_next(itr2))) {
switch (field->type) {
case PRINT_CLUSTER:
case PRINT_FEDSTATE:
case PRINT_FEDSTATERAW:
case PRINT_ID:
print_clusters = true;
break;
}
}
list_iterator_reset(itr2);
while ((fed = list_next(itr))) {
int curr_inx = 1;
char *tmp_str = NULL;
uint32_t tmp_uint32 = 0;
slurmdb_cluster_rec_t *tmp_cluster = NULL;
ListIterator itr3 =
list_iterator_create(fed->cluster_list);
if (!tree_display && print_clusters)
tmp_cluster = list_next(itr3);
do {
while((field = list_next(itr2))) {
switch(field->type) {
/* Federation Specific Fields */
case PRINT_FEDERATION:
if (tree_display && tmp_cluster)
tmp_str = NULL;
else
tmp_str = fed->name;
field->print_routine(
field, tmp_str,
(curr_inx == field_count));
break;
case PRINT_FLAGS:
if (tree_display && tmp_cluster)
tmp_str = NULL;
else {
tmp_str =
slurmdb_federation_flags_str(
fed->flags);
}
field->print_routine(
field, tmp_str,
(curr_inx == field_count));
if (tmp_str)
xfree(tmp_str);
break;
/* Cluster Specific Fields */
case PRINT_CLUSTER:
if (!tmp_cluster)
tmp_str = NULL;
else
tmp_str = tmp_cluster->name;
field->print_routine(
field, tmp_str,
(curr_inx == field_count));
break;
case PRINT_FEATURES:
{
List tmp_list = NULL;
if (tmp_cluster)
tmp_list = tmp_cluster->
fed.feature_list;
field->print_routine(
field, tmp_list,
(curr_inx == field_count));
break;
}
case PRINT_FEDSTATE:
if (!tmp_cluster)
tmp_str = NULL;
else {
tmp_str =
slurmdb_cluster_fed_states_str(
tmp_cluster->fed.state);
}
field->print_routine(
field, tmp_str,
(curr_inx == field_count));
break;
case PRINT_FEDSTATERAW:
if (!tmp_cluster)
tmp_uint32 = NO_VAL;
else
tmp_uint32 =
tmp_cluster->fed.state;
field->print_routine(
field, tmp_uint32,
(curr_inx == field_count));
break;
case PRINT_ID:
if (!tmp_cluster)
tmp_uint32 = NO_VAL;
else
tmp_uint32 =
tmp_cluster->fed.id;
field->print_routine(
field, tmp_uint32,
(curr_inx == field_count));
break;
default:
field->print_routine(
field, NULL,
(curr_inx == field_count));
break;
}
curr_inx++;
}
list_iterator_reset(itr2);
printf("\n");
} while(print_clusters && (tmp_cluster = list_next(itr3)));
list_iterator_destroy(itr3);
}
list_iterator_destroy(itr2);
list_iterator_destroy(itr);
FREE_NULL_LIST(federation_list);
FREE_NULL_LIST(print_fields_list);
return rc;
}
extern int fed_mgr_init(void *db_conn)
{
int rc = SLURM_SUCCESS;
slurmdb_federation_cond_t fed_cond;
List fed_list;
slurmdb_federation_rec_t *fed = NULL;
slurm_mutex_lock(&init_mutex);
if (inited) {
slurm_mutex_unlock(&init_mutex);
return SLURM_SUCCESS;
}
if (!association_based_accounting)
goto end_it;
slurm_persist_conn_recv_server_init();
if (running_cache) {
debug("Database appears down, reading federations from state file.");
fed = fed_mgr_state_load(
slurmctld_conf.state_save_location);
if (!fed) {
debug2("No federation state");
rc = SLURM_SUCCESS;
goto end_it;
}
} else {
slurmdb_init_federation_cond(&fed_cond, 0);
fed_cond.cluster_list = list_create(NULL);
list_append(fed_cond.cluster_list, slurmctld_cluster_name);
fed_list = acct_storage_g_get_federations(db_conn, getuid(),
&fed_cond);
FREE_NULL_LIST(fed_cond.cluster_list);
if (!fed_list) {
error("failed to get a federation list");
rc = SLURM_ERROR;
goto end_it;
}
if (list_count(fed_list) == 1)
fed = list_pop(fed_list);
else if (list_count(fed_list) > 1) {
error("got more federations than expected");
rc = SLURM_ERROR;
}
FREE_NULL_LIST(fed_list);
}
if (fed) {
slurmdb_cluster_rec_t *cluster = NULL;
if ((cluster = list_find_first(fed->cluster_list,
slurmdb_find_cluster_in_list,
slurmctld_cluster_name))) {
_join_federation(fed, cluster, false);
} else {
error("failed to get cluster from federation that we requested");
rc = SLURM_ERROR;
}
}
end_it:
inited = true;
slurm_mutex_unlock(&init_mutex);
return rc;
}
