/* Dump the configuration in name,value pairs for output to
* "statsmgr show config", caller must call list_destroy() */
extern List dump_config(void)
{
config_key_pair_t *key_pair;
char time_str[32];
List my_list = list_create(destroy_config_key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("ArchiveDir");
key_pair->value = xstrdup(slurmdbd_conf->archive_dir);
list_append(my_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("ArchiveEvents");
key_pair->value = xstrdup(
SLURMDB_PURGE_ARCHIVE_SET(
slurmdbd_conf->purge_event) ? "Yes" : "No");
list_append(my_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("ArchiveJobs");
key_pair->value = xstrdup(
SLURMDB_PURGE_ARCHIVE_SET(
slurmdbd_conf->purge_job) ? "Yes" : "No");
list_append(my_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("ArchiveResvs");
key_pair->value = xstrdup(
SLURMDB_PURGE_ARCHIVE_SET(
slurmdbd_conf->purge_resv) ? "Yes" : "No");
list_append(my_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("ArchiveScript");
key_pair->value = xstrdup(slurmdbd_conf->archive_script);
list_append(my_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("ArchiveSteps");
key_pair->value = xstrdup(
SLURMDB_PURGE_ARCHIVE_SET(
slurmdbd_conf->purge_step) ? "Yes" : "No");
list_append(my_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("ArchiveSuspend");
key_pair->value = xstrdup(
SLURMDB_PURGE_ARCHIVE_SET(
slurmdbd_conf->purge_suspend) ? "Yes" : "No");
list_append(my_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("ArchiveTXN");
key_pair->value = xstrdup(
SLURMDB_PURGE_ARCHIVE_SET(
slurmdbd_conf->purge_txn) ? "Yes" : "No");
list_append(my_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("ArchiveUsage");
key_pair->value = xstrdup(
SLURMDB_PURGE_ARCHIVE_SET(
slurmdbd_conf->purge_usage) ? "Yes" : "No");
list_append(my_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("AuthInfo");
key_pair->value = xstrdup(slurmdbd_conf->auth_info);
list_append(my_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("AuthType");
key_pair->value = xstrdup(slurmdbd_conf->auth_type);
list_append(my_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("BOOT_TIME");
key_pair->value = xmalloc(128);
slurm_make_time_str ((time_t *)&boot_time, key_pair->value, 128);
list_append(my_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("CommitDelay");
key_pair->value = xstrdup(slurmdbd_conf->commit_delay ? "Yes" : "No");
list_append(my_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("DbdAddr");
key_pair->value = xstrdup(slurmdbd_conf->dbd_addr);
list_append(my_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("DbdBackupHost");
key_pair->value = xstrdup(slurmdbd_conf->dbd_backup);
list_append(my_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("DbdHost");
key_pair->value = xstrdup(slurmdbd_conf->dbd_host);
list_append(my_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("DbdPort");
key_pair->value = xstrdup_printf("%u", slurmdbd_conf->dbd_port);
list_append(my_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("DebugFlags");
key_pair->value = debug_flags2str(slurmdbd_conf->debug_flags);
list_append(my_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("DebugLevel");
key_pair->value = xstrdup(log_num2string(slurmdbd_conf->debug_level));
list_append(my_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("DebugLevelSyslog");
key_pair->value = xstrdup(log_num2string(slurmdbd_conf->syslog_debug));
list_append(my_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("DefaultQOS");
key_pair->value = xstrdup(slurmdbd_conf->default_qos);
list_append(my_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("LogFile");
key_pair->value = xstrdup(slurmdbd_conf->log_file);
list_append(my_list, key_pair);
secs2time_str(slurmdbd_conf->max_time_range, time_str,
sizeof(time_str));
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("MaxQueryTimeRange");
key_pair->value = xstrdup_printf("%s", time_str);
list_append(my_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("MessageTimeout");
key_pair->value = xstrdup_printf("%u secs", slurmdbd_conf->msg_timeout);
list_append(my_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("PidFile");
key_pair->value = xstrdup(slurmdbd_conf->pid_file);
list_append(my_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("PluginDir");
key_pair->value = xstrdup(slurmdbd_conf->plugindir);
list_append(my_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("PrivateData");
key_pair->value = xmalloc(128);
private_data_string(slurmdbd_conf->private_data,
key_pair->value, 128);
list_append(my_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("PurgeEventAfter");
if (slurmdbd_conf->purge_event != NO_VAL) {
key_pair->value = xmalloc(32);
slurmdb_purge_string(slurmdbd_conf->purge_event,
key_pair->value, 32, 1);
} else
key_pair->value = xstrdup("NONE");
list_append(my_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("PurgeJobAfter");
if (slurmdbd_conf->purge_job != NO_VAL) {
key_pair->value = xmalloc(32);
slurmdb_purge_string(slurmdbd_conf->purge_job,
key_pair->value, 32, 1);
} else
key_pair->value = xstrdup("NONE");
list_append(my_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("PurgeResvAfter");
if (slurmdbd_conf->purge_resv != NO_VAL) {
key_pair->value = xmalloc(32);
slurmdb_purge_string(slurmdbd_conf->purge_resv,
key_pair->value, 32, 1);
} else
key_pair->value = xstrdup("NONE");
list_append(my_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("PurgeStepAfter");
if (slurmdbd_conf->purge_step != NO_VAL) {
key_pair->value = xmalloc(32);
slurmdb_purge_string(slurmdbd_conf->purge_step,
key_pair->value, 32, 1);
} else
key_pair->value = xstrdup("NONE");
list_append(my_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("PurgeSuspendAfter");
if (slurmdbd_conf->purge_suspend != NO_VAL) {
key_pair->value = xmalloc(32);
slurmdb_purge_string(slurmdbd_conf->purge_suspend,
key_pair->value, 32, 1);
} else
key_pair->value = xstrdup("NONE");
list_append(my_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("PurgeTXNAfter");
if (slurmdbd_conf->purge_txn != NO_VAL) {
key_pair->value = xmalloc(32);
slurmdb_purge_string(slurmdbd_conf->purge_txn,
key_pair->value, 32, 1);
} else
key_pair->value = xstrdup("NONE");
list_append(my_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("PurgeUsageAfter");
if (slurmdbd_conf->purge_usage != NO_VAL) {
key_pair->value = xmalloc(32);
slurmdb_purge_string(slurmdbd_conf->purge_usage,
key_pair->value, 32, 1);
} else
key_pair->value = xstrdup("NONE");
list_append(my_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("SLURMDBD_CONF");
key_pair->value = get_extra_conf_path("slurmdbd.conf");
list_append(my_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("SLURMDBD_VERSION");
key_pair->value = xstrdup(SLURM_VERSION_STRING);
list_append(my_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("SlurmUser");
key_pair->value = xstrdup_printf("%s(%u)",
slurmdbd_conf->slurm_user_name,
slurmdbd_conf->slurm_user_id);
list_append(my_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("StorageBackupHost");
key_pair->value = xstrdup(slurmdbd_conf->storage_backup_host);
list_append(my_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("StorageHost");
key_pair->value = xstrdup(slurmdbd_conf->storage_host);
list_append(my_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("StorageLoc");
key_pair->value = xstrdup(slurmdbd_conf->storage_loc);
list_append(my_list, key_pair);
/* StoragePass should NOT be passed due to security reasons */
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("StoragePort");
key_pair->value = xstrdup_printf("%u", slurmdbd_conf->storage_port);
list_append(my_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("StorageType");
key_pair->value = xstrdup(slurmdbd_conf->storage_type);
list_append(my_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("StorageUser");
key_pair->value = xstrdup(slurmdbd_conf->storage_user);
list_append(my_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("TCPTimeout");
key_pair->value = xstrdup_printf("%u secs", slurmdbd_conf->tcp_timeout);
list_append(my_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("TrackWCKey");
key_pair->value = xstrdup(slurmdbd_conf->track_wckey ? "Yes" : "No");
list_append(my_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("TrackSlurmctldDown");
key_pair->value = xstrdup(slurmdbd_conf->track_ctld ? "Yes" : "No");
list_append(my_list, key_pair);
return my_list;
}
extern void *slurm_ctl_conf_2_key_pairs (slurm_ctl_conf_t* slurm_ctl_conf_ptr)
{
List ret_list = NULL;
config_key_pair_t *key_pair;
char tmp_str[128];
uint32_t cluster_flags = slurmdb_setup_cluster_flags();
if ( slurm_ctl_conf_ptr == NULL )
return NULL;
ret_list = list_create(destroy_config_key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("AccountingStorageBackupHost");
key_pair->value =
xstrdup(slurm_ctl_conf_ptr->accounting_storage_backup_host);
list_append(ret_list, key_pair);
accounting_enforce_string(slurm_ctl_conf_ptr->
accounting_storage_enforce,
tmp_str, sizeof(tmp_str));
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("AccountingStorageEnforce");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("AccountingStorageHost");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->accounting_storage_host);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("AccountingStorageLoc");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->accounting_storage_loc);
list_append(ret_list, key_pair);
snprintf(tmp_str, sizeof(tmp_str), "%u",
slurm_ctl_conf_ptr->accounting_storage_port);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("AccountingStoragePort");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("AccountingStorageType");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->accounting_storage_type);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("AccountingStorageUser");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->accounting_storage_user);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("AccountingStoreJobComment");
if (slurm_ctl_conf_ptr->acctng_store_job_comment)
key_pair->value = xstrdup("YES");
else
key_pair->value = xstrdup("NO");
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("AcctGatherEnergyType");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->acct_gather_energy_type);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("AcctGatherFilesystemType");
key_pair->value =
xstrdup(slurm_ctl_conf_ptr->acct_gather_filesystem_type);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("AcctGatherInfinibandType");
key_pair->value =
xstrdup(slurm_ctl_conf_ptr->acct_gather_infiniband_type);
list_append(ret_list, key_pair);
snprintf(tmp_str, sizeof(tmp_str), "%u sec",
slurm_ctl_conf_ptr->acct_gather_node_freq);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("AcctGatherNodeFreq");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("AcctGatherProfileType");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->acct_gather_profile_type);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("AuthInfo");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->authinfo);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("AuthType");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->authtype);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("BackupAddr");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->backup_addr);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("BackupController");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->backup_controller);
list_append(ret_list, key_pair);
snprintf(tmp_str, sizeof(tmp_str), "%u sec",
slurm_ctl_conf_ptr->batch_start_timeout);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("BatchStartTimeout");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
slurm_make_time_str((time_t *)&slurm_ctl_conf_ptr->boot_time,
tmp_str, sizeof(tmp_str));
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("BOOT_TIME");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("CacheGroups");
if (slurm_ctl_conf_ptr->group_info & GROUP_CACHE)
key_pair->value = xstrdup("1");
else
key_pair->value = xstrdup("0");
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("CheckpointType");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->checkpoint_type);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("ClusterName");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->cluster_name);
list_append(ret_list, key_pair);
snprintf(tmp_str, sizeof(tmp_str), "%u sec",
slurm_ctl_conf_ptr->complete_wait);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("CompleteWait");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("ControlAddr");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->control_addr);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("ControlMachine");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->control_machine);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("CryptoType");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->crypto_type);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("DebugFlags");
key_pair->value = debug_flags2str(slurm_ctl_conf_ptr->debug_flags);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
list_append(ret_list, key_pair);
if (slurm_ctl_conf_ptr->def_mem_per_cpu & MEM_PER_CPU) {
key_pair->name = xstrdup("DefMemPerCPU");
snprintf(tmp_str, sizeof(tmp_str), "%u",
slurm_ctl_conf_ptr->def_mem_per_cpu &
(~MEM_PER_CPU));
key_pair->value = xstrdup(tmp_str);
} else if (slurm_ctl_conf_ptr->def_mem_per_cpu) {
key_pair->name = xstrdup("DefMemPerNode");
snprintf(tmp_str, sizeof(tmp_str), "%u",
slurm_ctl_conf_ptr->def_mem_per_cpu);
key_pair->value = xstrdup(tmp_str);
} else {
key_pair->name = xstrdup("DefMemPerNode");
key_pair->value = xstrdup("UNLIMITED");
}
key_pair = xmalloc(sizeof(config_key_pair_t));
list_append(ret_list, key_pair);
key_pair->name = xstrdup("DisableRootJobs");
if (slurm_ctl_conf_ptr->disable_root_jobs)
key_pair->value = xstrdup("YES");
else
key_pair->value = xstrdup("NO");
snprintf(tmp_str, sizeof(tmp_str), "%u",
slurm_ctl_conf_ptr->dynalloc_port);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("DynAllocPort");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
list_append(ret_list, key_pair);
key_pair->name = xstrdup("EnforcePartLimits");
if (slurm_ctl_conf_ptr->enforce_part_limits)
key_pair->value = xstrdup("YES");
else
key_pair->value = xstrdup("NO");
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("Epilog");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->epilog);
list_append(ret_list, key_pair);
snprintf(tmp_str, sizeof(tmp_str), "%u usec",
slurm_ctl_conf_ptr->epilog_msg_time);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("EpilogMsgTime");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("EpilogSlurmctld");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->epilog_slurmctld);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("ExtSensorsType");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->ext_sensors_type);
list_append(ret_list, key_pair);
snprintf(tmp_str, sizeof(tmp_str), "%u sec",
slurm_ctl_conf_ptr->ext_sensors_freq);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("ExtSensorsFreq");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
if (strcmp(slurm_ctl_conf_ptr->priority_type, "priority/basic")) {
snprintf(tmp_str, sizeof(tmp_str), "%u",
slurm_ctl_conf_ptr->fs_dampening_factor);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("FairShareDampeningFactor");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
}
snprintf(tmp_str, sizeof(tmp_str), "%u",
slurm_ctl_conf_ptr->fast_schedule);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("FastSchedule");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
snprintf(tmp_str, sizeof(tmp_str), "%u",
slurm_ctl_conf_ptr->first_job_id);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("FirstJobId");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
snprintf(tmp_str, sizeof(tmp_str), "%u sec",
slurm_ctl_conf_ptr->get_env_timeout);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("GetEnvTimeout");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("GresTypes");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->gres_plugins);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("GroupUpdateForce");
if (slurm_ctl_conf_ptr->group_info & GROUP_FORCE)
key_pair->value = xstrdup("1");
else
key_pair->value = xstrdup("0");
list_append(ret_list, key_pair);
snprintf(tmp_str, sizeof(tmp_str), "%u sec",
slurm_ctl_conf_ptr->group_info & GROUP_TIME_MASK);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("GroupUpdateTime");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
if (slurm_ctl_conf_ptr->hash_val != NO_VAL) {
if (slurm_ctl_conf_ptr->hash_val == slurm_get_hash_val())
snprintf(tmp_str, sizeof(tmp_str), "Match");
else {
snprintf(tmp_str, sizeof(tmp_str),
"Different Ours=0x%x Slurmctld=0x%x",
slurm_get_hash_val(),
slurm_ctl_conf_ptr->hash_val);
}
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("HASH_VAL");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
}
snprintf(tmp_str, sizeof(tmp_str), "%u sec",
slurm_ctl_conf_ptr->health_check_interval);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("HealthCheckInterval");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("HealthCheckNodeState");
key_pair->value = health_check_node_state_str(slurm_ctl_conf_ptr->
health_check_node_state);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("HealthCheckProgram");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->health_check_program);
list_append(ret_list, key_pair);
if (cluster_flags & CLUSTER_FLAG_XCPU) {
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("HAVE_XCPU");
key_pair->value = xstrdup("1");
list_append(ret_list, key_pair);
}
snprintf(tmp_str, sizeof(tmp_str), "%u sec",
slurm_ctl_conf_ptr->inactive_limit);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("InactiveLimit");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("JobAcctGatherFrequency");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->job_acct_gather_freq);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("JobAcctGatherType");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->job_acct_gather_type);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("JobAcctGatherParams");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->job_acct_gather_params);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("JobCheckpointDir");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->job_ckpt_dir);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("JobCompHost");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->job_comp_host);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("JobCompLoc");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->job_comp_loc);
list_append(ret_list, key_pair);
snprintf(tmp_str, sizeof(tmp_str), "%u",
slurm_ctl_conf_ptr->job_comp_port);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("JobCompPort");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("JobCompType");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->job_comp_type);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("JobCompUser");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->job_comp_user);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("JobContainerPlugin");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->job_container_plugin);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("JobCredentialPrivateKey");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->
job_credential_private_key);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("JobCredentialPublicCertificate");
key_pair->value = xstrdup(
slurm_ctl_conf_ptr->job_credential_public_certificate);
list_append(ret_list, key_pair);
snprintf(tmp_str, sizeof(tmp_str), "%u",
slurm_ctl_conf_ptr->job_file_append);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("JobFileAppend");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
snprintf(tmp_str, sizeof(tmp_str), "%u",
slurm_ctl_conf_ptr->job_requeue);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("JobRequeue");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("JobSubmitPlugins");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->job_submit_plugins);
list_append(ret_list, key_pair);
if (slurm_ctl_conf_ptr->keep_alive_time == (uint16_t) NO_VAL)
snprintf(tmp_str, sizeof(tmp_str), "SYSTEM_DEFAULT");
else {
snprintf(tmp_str, sizeof(tmp_str), "%u sec",
slurm_ctl_conf_ptr->keep_alive_time);
}
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("KeepAliveTime");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
snprintf(tmp_str, sizeof(tmp_str), "%u",
slurm_ctl_conf_ptr->kill_on_bad_exit);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("KillOnBadExit");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
snprintf(tmp_str, sizeof(tmp_str), "%u sec",
slurm_ctl_conf_ptr->kill_wait);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("KillWait");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("LaunchType");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->launch_type);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("Licenses");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->licenses);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("LicensesUsed");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->licenses_used);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("MailProg");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->mail_prog);
list_append(ret_list, key_pair);
snprintf(tmp_str, sizeof(tmp_str), "%u",
slurm_ctl_conf_ptr->max_array_sz);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("MaxArraySize");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
snprintf(tmp_str, sizeof(tmp_str), "%u",
slurm_ctl_conf_ptr->max_job_cnt);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("MaxJobCount");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
snprintf(tmp_str, sizeof(tmp_str), "%u",
slurm_ctl_conf_ptr->max_job_id);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("MaxJobId");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
list_append(ret_list, key_pair);
if (slurm_ctl_conf_ptr->max_mem_per_cpu & MEM_PER_CPU) {
key_pair->name = xstrdup("MaxMemPerCPU");
snprintf(tmp_str, sizeof(tmp_str), "%u",
slurm_ctl_conf_ptr->max_mem_per_cpu & (~MEM_PER_CPU));
key_pair->value = xstrdup(tmp_str);
} else if (slurm_ctl_conf_ptr->max_mem_per_cpu) {
key_pair->name = xstrdup("MaxMemPerNode");
snprintf(tmp_str, sizeof(tmp_str), "%u",
slurm_ctl_conf_ptr->max_mem_per_cpu);
key_pair->value = xstrdup(tmp_str);
} else {
key_pair->name = xstrdup("MaxMemPerNode");
key_pair->value = xstrdup("UNLIMITED");
}
snprintf(tmp_str, sizeof(tmp_str), "%u",
slurm_ctl_conf_ptr->max_step_cnt);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("MaxStepCount");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
snprintf(tmp_str, sizeof(tmp_str), "%u",
slurm_ctl_conf_ptr->max_tasks_per_node);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("MaxTasksPerNode");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
snprintf(tmp_str, sizeof(tmp_str), "%u sec",
slurm_ctl_conf_ptr->msg_timeout);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("MessageTimeout");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
snprintf(tmp_str, sizeof(tmp_str), "%u sec",
slurm_ctl_conf_ptr->min_job_age);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("MinJobAge");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("MpiDefault");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->mpi_default);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("MpiParams");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->mpi_params);
list_append(ret_list, key_pair);
if (cluster_flags & CLUSTER_FLAG_MULTSD) {
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("MULTIPLE_SLURMD");
key_pair->value = xstrdup("1");
list_append(ret_list, key_pair);
}
snprintf(tmp_str, sizeof(tmp_str), "%u",
slurm_ctl_conf_ptr->next_job_id);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("NEXT_JOB_ID");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
if (slurm_ctl_conf_ptr->over_time_limit == (uint16_t) INFINITE)
snprintf(tmp_str, sizeof(tmp_str), "UNLIMITED");
else
snprintf(tmp_str, sizeof(tmp_str), "%u min",
slurm_ctl_conf_ptr->over_time_limit);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("OverTimeLimit");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("PluginDir");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->plugindir);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("PlugStackConfig");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->plugstack);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("PreemptMode");
key_pair->value = xstrdup(preempt_mode_string(slurm_ctl_conf_ptr->
preempt_mode));
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("PreemptType");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->preempt_type);
list_append(ret_list, key_pair);
if (strcmp(slurm_ctl_conf_ptr->priority_type, "priority/basic") == 0) {
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("PriorityType");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->priority_type);
list_append(ret_list, key_pair);
} else {
secs2time_str((time_t) slurm_ctl_conf_ptr->priority_decay_hl,
tmp_str, sizeof(tmp_str));
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("PriorityDecayHalfLife");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
secs2time_str((time_t)slurm_ctl_conf_ptr->priority_calc_period,
tmp_str, sizeof(tmp_str));
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("PriorityCalcPeriod");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
snprintf(tmp_str, sizeof(tmp_str), "%u",
slurm_ctl_conf_ptr->priority_favor_small);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("PriorityFavorSmall");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
snprintf(tmp_str, sizeof(tmp_str), "%u",
slurm_ctl_conf_ptr->priority_flags);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("PriorityFlags");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
secs2time_str((time_t) slurm_ctl_conf_ptr->priority_max_age,
tmp_str, sizeof(tmp_str));
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("PriorityMaxAge");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("PriorityUsageResetPeriod");
key_pair->value = xstrdup(_reset_period_str(
slurm_ctl_conf_ptr->
priority_reset_period));
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("PriorityType");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->priority_type);
list_append(ret_list, key_pair);
snprintf(tmp_str, sizeof(tmp_str), "%u",
slurm_ctl_conf_ptr->priority_weight_age);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("PriorityWeightAge");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
snprintf(tmp_str, sizeof(tmp_str), "%u",
slurm_ctl_conf_ptr->priority_weight_fs);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("PriorityWeightFairShare");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
snprintf(tmp_str, sizeof(tmp_str), "%u",
slurm_ctl_conf_ptr->priority_weight_js);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("PriorityWeightJobSize");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
snprintf(tmp_str, sizeof(tmp_str), "%u",
slurm_ctl_conf_ptr->priority_weight_part);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("PriorityWeightPartition");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
snprintf(tmp_str, sizeof(tmp_str), "%u",
slurm_ctl_conf_ptr->priority_weight_qos);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("PriorityWeightQOS");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
}
private_data_string(slurm_ctl_conf_ptr->private_data,
tmp_str, sizeof(tmp_str));
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("PrivateData");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("ProctrackType");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->proctrack_type);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("Prolog");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->prolog);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("PrologSlurmctld");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->prolog_slurmctld);
list_append(ret_list, key_pair);
snprintf(tmp_str, sizeof(tmp_str), "%u",
slurm_ctl_conf_ptr->propagate_prio_process);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("PropagatePrioProcess");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("PropagateResourceLimits");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->propagate_rlimits);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("PropagateResourceLimitsExcept");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->
propagate_rlimits_except);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("RebootProgram");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->reboot_program);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("ReconfigFlags");
key_pair->value =
reconfig_flags2str(slurm_ctl_conf_ptr->reconfig_flags);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("ResumeProgram");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->resume_program);
list_append(ret_list, key_pair);
snprintf(tmp_str, sizeof(tmp_str), "%u nodes/min",
slurm_ctl_conf_ptr->resume_rate);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("ResumeRate");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
snprintf(tmp_str, sizeof(tmp_str), "%u sec",
slurm_ctl_conf_ptr->resume_timeout);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("ResumeTimeout");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("ResvEpilog");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->resv_epilog);
list_append(ret_list, key_pair);
if (slurm_ctl_conf_ptr->resv_over_run == (uint16_t) INFINITE)
snprintf(tmp_str, sizeof(tmp_str), "UNLIMITED");
else
snprintf(tmp_str, sizeof(tmp_str), "%u min",
slurm_ctl_conf_ptr->resv_over_run);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("ResvOverRun");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("ResvProlog");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->resv_prolog);
list_append(ret_list, key_pair);
snprintf(tmp_str, sizeof(tmp_str), "%u",
slurm_ctl_conf_ptr->ret2service);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("ReturnToService");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("SallocDefaultCommand");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->salloc_default_command);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("SchedulerParameters");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->sched_params);
list_append(ret_list, key_pair);
snprintf(tmp_str, sizeof(tmp_str), "%u",
slurm_ctl_conf_ptr->schedport);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("SchedulerPort");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
snprintf(tmp_str, sizeof(tmp_str), "%u",
slurm_ctl_conf_ptr->schedrootfltr);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("SchedulerRootFilter");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
snprintf(tmp_str, sizeof(tmp_str), "%u sec",
slurm_ctl_conf_ptr->sched_time_slice);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("SchedulerTimeSlice");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("SchedulerType");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->schedtype);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("SelectType");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->select_type);
list_append(ret_list, key_pair);
if (slurm_ctl_conf_ptr->select_type_param) {
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("SelectTypeParameters");
key_pair->value = xstrdup(
select_type_param_string(slurm_ctl_conf_ptr->
select_type_param));
list_append(ret_list, key_pair);
}
snprintf(tmp_str, sizeof(tmp_str), "%s(%u)",
slurm_ctl_conf_ptr->slurm_user_name,
slurm_ctl_conf_ptr->slurm_user_id);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("SlurmUser");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
snprintf(tmp_str, sizeof(tmp_str), "%s",
log_num2string(slurm_ctl_conf_ptr->slurmctld_debug));
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("SlurmctldDebug");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("SlurmctldLogFile");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->slurmctld_logfile);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("SlurmSchedLogFile");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->sched_logfile);
list_append(ret_list, key_pair);
if (slurm_ctl_conf_ptr->slurmctld_port_count > 1) {
uint32_t high_port = slurm_ctl_conf_ptr->slurmctld_port;
high_port += (slurm_ctl_conf_ptr->slurmctld_port_count - 1);
snprintf(tmp_str, sizeof(tmp_str), "%u-%u",
slurm_ctl_conf_ptr->slurmctld_port, high_port);
} else {
snprintf(tmp_str, sizeof(tmp_str), "%u",
slurm_ctl_conf_ptr->slurmctld_port);
}
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("SlurmctldPort");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
snprintf(tmp_str, sizeof(tmp_str), "%u sec",
slurm_ctl_conf_ptr->slurmctld_timeout);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("SlurmctldTimeout");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
snprintf(tmp_str, sizeof(tmp_str), "%s",
log_num2string(slurm_ctl_conf_ptr->slurmd_debug));
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("SlurmdDebug");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("SlurmdLogFile");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->slurmd_logfile);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("SlurmdPidFile");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->slurmd_pidfile);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("SlurmdPlugstack");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->slurmd_plugstack);
list_append(ret_list, key_pair);
#ifndef MULTIPLE_SLURMD
snprintf(tmp_str, sizeof(tmp_str), "%u",
slurm_ctl_conf_ptr->slurmd_port);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("SlurmdPort");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
#endif
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("SlurmdSpoolDir");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->slurmd_spooldir);
list_append(ret_list, key_pair);
snprintf(tmp_str, sizeof(tmp_str), "%u sec",
slurm_ctl_conf_ptr->slurmd_timeout);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("SlurmdTimeout");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
snprintf(tmp_str, sizeof(tmp_str), "%s(%u)",
slurm_ctl_conf_ptr->slurmd_user_name,
slurm_ctl_conf_ptr->slurmd_user_id);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("SlurmdUser");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
snprintf(tmp_str, sizeof(tmp_str), "%u",
slurm_ctl_conf_ptr->sched_log_level);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("SlurmSchedLogLevel");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("SlurmctldPidFile");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->slurmctld_pidfile);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("SlurmctldPlugstack");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->slurmctld_plugstack);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("SLURM_CONF");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->slurm_conf);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("SLURM_VERSION");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->version);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("SrunEpilog");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->srun_epilog);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("SrunProlog");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->srun_prolog);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("StateSaveLocation");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->state_save_location);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("SuspendExcNodes");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->suspend_exc_nodes);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("SuspendExcParts");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->suspend_exc_parts);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("SuspendProgram");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->suspend_program);
list_append(ret_list, key_pair);
snprintf(tmp_str, sizeof(tmp_str), "%u nodes/min",
slurm_ctl_conf_ptr->suspend_rate);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("SuspendRate");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
if (!slurm_ctl_conf_ptr->suspend_time)
snprintf(tmp_str, sizeof(tmp_str), "NONE");
else
snprintf(tmp_str, sizeof(tmp_str), "%d sec",
((int)slurm_ctl_conf_ptr->suspend_time - 1));
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("SuspendTime");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
snprintf(tmp_str, sizeof(tmp_str), "%u sec",
slurm_ctl_conf_ptr->suspend_timeout);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("SuspendTimeout");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("SwitchType");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->switch_type);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("TaskEpilog");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->task_epilog);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("TaskPlugin");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->task_plugin);
list_append(ret_list, key_pair);
slurm_sprint_cpu_bind_type(tmp_str,
slurm_ctl_conf_ptr->task_plugin_param);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("TaskPluginParam");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("TaskProlog");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->task_prolog);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("TmpFS");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->tmp_fs);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("TopologyPlugin");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->topology_plugin);
list_append(ret_list, key_pair);
snprintf(tmp_str, sizeof(tmp_str), "%u",
slurm_ctl_conf_ptr->track_wckey);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("TrackWCKey");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
snprintf(tmp_str, sizeof(tmp_str), "%u",
slurm_ctl_conf_ptr->tree_width);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("TreeWidth");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
snprintf(tmp_str, sizeof(tmp_str), "%u",
slurm_ctl_conf_ptr->use_pam);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("UsePam");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("UnkillableStepProgram");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->unkillable_program);
list_append(ret_list, key_pair);
snprintf(tmp_str, sizeof(tmp_str), "%u sec",
slurm_ctl_conf_ptr->unkillable_timeout);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("UnkillableStepTimeout");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
snprintf(tmp_str, sizeof(tmp_str), "%u percent",
slurm_ctl_conf_ptr->vsize_factor);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("VSizeFactor");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
snprintf(tmp_str, sizeof(tmp_str), "%u sec",
slurm_ctl_conf_ptr->wait_time);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("WaitTime");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
return (void *)ret_list;
}
/* Log the current configuration using verbose() */
extern void log_config(void)
{
char tmp_str[128];
char *tmp_ptr = NULL;
debug2("ArchiveDir = %s", slurmdbd_conf->archive_dir);
debug2("ArchiveScript = %s", slurmdbd_conf->archive_script);
debug2("AuthInfo = %s", slurmdbd_conf->auth_info);
debug2("AuthType = %s", slurmdbd_conf->auth_type);
debug2("CommitDelay = %u", slurmdbd_conf->commit_delay);
debug2("DbdAddr = %s", slurmdbd_conf->dbd_addr);
debug2("DbdBackupHost = %s", slurmdbd_conf->dbd_backup);
debug2("DbdHost = %s", slurmdbd_conf->dbd_host);
debug2("DbdPort = %u", slurmdbd_conf->dbd_port);
tmp_ptr = debug_flags2str(slurmdbd_conf->debug_flags);
debug2("DebugFlags = %s", tmp_ptr);
xfree(tmp_ptr);
debug2("DebugLevel = %u", slurmdbd_conf->debug_level);
debug2("DebugLevelSyslog = %u", slurmdbd_conf->syslog_debug);
debug2("DefaultQOS = %s", slurmdbd_conf->default_qos);
debug2("LogFile = %s", slurmdbd_conf->log_file);
debug2("MessageTimeout = %u", slurmdbd_conf->msg_timeout);
debug2("PidFile = %s", slurmdbd_conf->pid_file);
debug2("PluginDir = %s", slurmdbd_conf->plugindir);
private_data_string(slurmdbd_conf->private_data,
tmp_str, sizeof(tmp_str));
debug2("PrivateData = %s", tmp_str);
slurmdb_purge_string(slurmdbd_conf->purge_event,
tmp_str, sizeof(tmp_str), 1);
debug2("PurgeEventAfter = %s", tmp_str);
slurmdb_purge_string(slurmdbd_conf->purge_job,
tmp_str, sizeof(tmp_str), 1);
debug2("PurgeJobAfter = %s", tmp_str);
slurmdb_purge_string(slurmdbd_conf->purge_resv,
tmp_str, sizeof(tmp_str), 1);
debug2("PurgeResvAfter = %s", tmp_str);
slurmdb_purge_string(slurmdbd_conf->purge_step,
tmp_str, sizeof(tmp_str), 1);
debug2("PurgeStepAfter = %s", tmp_str);
slurmdb_purge_string(slurmdbd_conf->purge_suspend,
tmp_str, sizeof(tmp_str), 1);
debug2("PurgeSuspendAfter = %s", tmp_str);
slurmdb_purge_string(slurmdbd_conf->purge_txn,
tmp_str, sizeof(tmp_str), 1);
debug2("PurgeTXNAfter = %s", tmp_str);
slurmdb_purge_string(slurmdbd_conf->purge_usage,
tmp_str, sizeof(tmp_str), 1);
debug2("PurgeUsageAfter = %s", tmp_str);
debug2("SlurmUser = %s(%u)",
slurmdbd_conf->slurm_user_name, slurmdbd_conf->slurm_user_id);
debug2("StorageBackupHost = %s", slurmdbd_conf->storage_backup_host);
debug2("StorageHost = %s", slurmdbd_conf->storage_host);
debug2("StorageLoc = %s", slurmdbd_conf->storage_loc);
/* debug2("StoragePass = %s", slurmdbd_conf->storage_pass); */
debug2("StoragePort = %u", slurmdbd_conf->storage_port);
debug2("StorageType = %s", slurmdbd_conf->storage_type);
debug2("StorageUser = %s", slurmdbd_conf->storage_user);
debug2("TCPTimeout = %u", slurmdbd_conf->tcp_timeout);
debug2("TrackWCKey = %u", slurmdbd_conf->track_wckey);
debug2("TrackSlurmctldDown= %u", slurmdbd_conf->track_ctld);
}
/* Returns a menubar widget made from the above menu */
static GtkWidget *_get_menubar_menu(GtkWidget *window, GtkWidget *notebook)
{
GtkAccelGroup *accel_group = NULL;
GError *error = NULL;
char *ui_description;
GtkActionEntry entries[] = {
{"actions", NULL, "_Actions", "<alt>a"},
{"options", NULL, "_Options", "<alt>o"},
{"displays", NULL, "_Query", "<alt>q"},
{"batch_job", NULL, "Batch Job", "", "Submit batch job",
G_CALLBACK(create_create_popup)},
{"partition", NULL, "Partition", "", "Create partition",
G_CALLBACK(create_create_popup)},
{"reservation", NULL, "Reservation", "", "Create reservation",
G_CALLBACK(create_create_popup)},
{"search", GTK_STOCK_FIND, "Search", ""},
{"jobid", NULL, "Job ID",
"", "Search for jobid",
G_CALLBACK(create_search_popup)},
{"user_jobs", NULL, "Specific User's Job(s)",
"", "Search for a specific users job(s)",
G_CALLBACK(create_search_popup)},
{"state_jobs", NULL, "Job(s) in a Specific State",
"", "Search for job(s) in a specific state",
G_CALLBACK(create_search_popup)},
{"partition_name", NULL, "Slurm Partition Name",
"", "Search for a specific SLURM partition",
G_CALLBACK(create_search_popup)},
{"partition_state", NULL, "Slurm Partition State",
"", "Search for SLURM partitions in a given state",
G_CALLBACK(create_search_popup)},
{"reservation_name", NULL, "Reservation Name",
"", "Search for reservation",
G_CALLBACK(create_search_popup)},
{"tab_pos", NULL, "_Tab Position"},
{"create", GTK_STOCK_ADD, "Create"},
{"interval", GTK_STOCK_REFRESH, "Set Refresh _Interval",
"<control>i", "Change Refresh Interval",
G_CALLBACK(change_refresh_popup)},
{"refresh", GTK_STOCK_REFRESH, "Refresh",
"F5", "Refreshes page", G_CALLBACK(refresh_main)},
{"config", GTK_STOCK_INFO, "_Config Info",
"<control>c", "Displays info from slurm.conf file",
G_CALLBACK(create_config_popup)},
{"dbconfig", GTK_STOCK_INFO, "_Database Config Info",
"<control>d",
"Displays info relevant to the "
"configuration of the Slurm Database.",
G_CALLBACK(create_dbconfig_popup)},
{"exit", GTK_STOCK_QUIT, "E_xit",
"<control>x", "Exits Program", G_CALLBACK(_delete)},
{"help", NULL, "_Help", "<alt>h"},
{"about", GTK_STOCK_ABOUT, "Ab_out", "<control>o",
"About", G_CALLBACK(about_popup)},
{"usage", GTK_STOCK_HELP, "Usage", "",
"Usage", G_CALLBACK(usage_popup)},
//{"manual", GTK_STOCK_HELP, "_Manual", "<control>m"},
{"grid_specs", GTK_STOCK_EDIT, "Set Grid _Properties",
"<control>p", "Change Grid Properties",
G_CALLBACK(change_grid_popup)},
{"defaults", GTK_STOCK_EDIT, "_Set Default Settings",
"<control>s", "Change Default Settings",
G_CALLBACK(configure_defaults)},
};
GtkActionEntry bg_entries[] = {
{"bg_block_name", NULL, "BG Block Name",
"", "Search for a specific BG Block",
G_CALLBACK(create_search_popup)},
{"bg_block_size", NULL, "BG Block Size",
"",
"Search for BG Blocks having given size in cnodes",
G_CALLBACK(create_search_popup)},
{"bg_block_state", NULL, "BG Block State",
"",
"Search for BG Blocks having given state",
G_CALLBACK(create_search_popup)},
{"node_name_bg", NULL,
"Midplane(s) Name",
"", "Search for a specific Midplane(s)",
G_CALLBACK(create_search_popup)},
{"node_state_bg", NULL,
"Midplane State",
"", "Search for a Midplane in a given state",
G_CALLBACK(create_search_popup)},
};
GtkActionEntry nonbg_entries[] = {
{"node_name", NULL,
"Node(s) Name",
"", "Search for a specific Node(s)",
G_CALLBACK(create_search_popup)},
{"node_state", NULL,
"Node State",
"", "Search for a Node in a given state",
G_CALLBACK(create_search_popup)},
};
GtkActionEntry admin_entries[] = {
{"reconfig", GTK_STOCK_REDO, "SLUR_M Reconfigure",
"<control>m", "Reconfigures System",
G_CALLBACK(_reconfigure)},
{"debugflags", GTK_STOCK_DIALOG_WARNING,
"Slurmctld DebugFlags",
"", "Set slurmctld DebugFlags",
G_CALLBACK(_get_current_debug_flags)},
{"debuglevel", GTK_STOCK_DIALOG_WARNING,
"Slurmctld Debug Level",
"", "Set slurmctld debug level",
G_CALLBACK(_get_current_debug)},
};
GtkRadioActionEntry radio_entries[] = {
{"tab_top", GTK_STOCK_GOTO_TOP, "_Top",
"<control>T", "Move tabs to top", GTK_POS_TOP},
{"tab_bottom", GTK_STOCK_GOTO_BOTTOM, "_Bottom",
"<control>B", "Move tabs to the bottom", GTK_POS_BOTTOM},
{"tab_left", GTK_STOCK_GOTO_FIRST, "_Left",
"<control>L", "Move tabs to the Left", GTK_POS_LEFT},
{"tab_right", GTK_STOCK_GOTO_LAST, "_Right",
"<control>R", "Move tabs to the Right", GTK_POS_RIGHT}
};
GtkToggleActionEntry toggle_entries[] = {
{"grid", GTK_STOCK_SELECT_COLOR, "Show _Grid",
"<control>g", "Visual display of cluster",
G_CALLBACK(_set_grid), working_sview_config.show_grid},
{"hidden", GTK_STOCK_SELECT_COLOR, "Show _Hidden",
"<control>h", "Display Hidden Partitions/Jobs",
G_CALLBACK(_set_hidden), working_sview_config.show_hidden},
{"page_opts", GTK_STOCK_SELECT_COLOR, "Save Page Options",
"<control>w", "Save Page Options",
G_CALLBACK(_set_page_opts),
working_sview_config.save_page_opts},
#ifdef WANT_TOPO_ON_MAIN_OPTIONS
{"topoorder", GTK_STOCK_SELECT_COLOR, "Set Topology Grid",
"<control>t", "Set Topology Grid",
G_CALLBACK(_set_topogrid),
working_sview_config.grid_topological},
#endif
{"ruled", GTK_STOCK_SELECT_COLOR, "R_uled Tables",
"<control>u", "Have ruled tables or not",
G_CALLBACK(_set_ruled), working_sview_config.ruled_treeview},
{"admin", GTK_STOCK_PREFERENCES,
"_Admin Mode", "<control>a",
"Allows user to change or update information",
G_CALLBACK(_set_admin_mode),
working_sview_config.admin_mode}
};
GtkRadioActionEntry debug_entries[] = {
{"debug_quiet", NULL, "quiet(0)", "", "Quiet level", 0},
{"debug_fatal", NULL, "fatal(1)", "", "Fatal level", 1},
{"debug_error", NULL, "error(2)", "", "Error level", 2},
{"debug_info", NULL, "info(3)", "", "Info level", 3},
{"debug_verbose", NULL, "verbose(4)", "", "Verbose level", 4},
{"debug_debug", NULL, "debug(5)", "", "Debug debug level", 5},
{"debug_debug2", NULL, "debug2(6)", "", "Debug2 level", 6},
{"debug_debug3", NULL, "debug3(7)", "", "Debug3 level", 7},
{"debug_debug4", NULL, "debug4(8)", "", "Debug4 level", 8},
{"debug_debug5", NULL, "debug5(9)", "", "Debug5 level", 9},
};
char *all_debug_flags = debug_flags2str(0xFFFFFFFFFFFFFFFF);
char *last = NULL;
char *tok = strtok_r(all_debug_flags, ",", &last);
/* set up the global debug_actions */
debug_actions = xmalloc(sizeof(GtkToggleActionEntry));
while (tok) {
xrealloc(debug_actions,
(debug_action_entries + 1)
* sizeof(GtkToggleActionEntry));
debug_actions[debug_action_entries].name =
debug_actions[debug_action_entries].label =
debug_actions[debug_action_entries].tooltip =
xstrdup(tok);
debug_actions[debug_action_entries].callback =
G_CALLBACK(_set_flags);
debug_action_entries++;
tok = strtok_r(NULL, ",", &last);
}
xfree(all_debug_flags);
/* Make an accelerator group (shortcut keys) */
menu_action_group = gtk_action_group_new ("MenuActions");
gtk_action_group_add_actions(menu_action_group, entries,
G_N_ELEMENTS(entries), window);
gtk_action_group_add_actions(menu_action_group, bg_entries,
G_N_ELEMENTS(bg_entries), window);
gtk_action_group_add_actions(menu_action_group, nonbg_entries,
G_N_ELEMENTS(nonbg_entries),
window);
gtk_action_group_add_radio_actions(menu_action_group, radio_entries,
G_N_ELEMENTS(radio_entries),
working_sview_config.tab_pos,
G_CALLBACK(_tab_pos), notebook);
gtk_action_group_add_toggle_actions(menu_action_group, debug_actions,
debug_action_entries, NULL);
gtk_action_group_add_radio_actions(menu_action_group, debug_entries,
G_N_ELEMENTS(debug_entries),
-1, G_CALLBACK(_set_debug),
notebook);
gtk_action_group_add_toggle_actions(menu_action_group, toggle_entries,
G_N_ELEMENTS(toggle_entries),
NULL);
admin_action_group = gtk_action_group_new ("MenuAdminActions");
gtk_action_group_add_actions(admin_action_group, admin_entries,
G_N_ELEMENTS(admin_entries),
window);
gtk_action_group_set_sensitive(admin_action_group,
working_sview_config.admin_mode);
g_ui_manager = gtk_ui_manager_new();
gtk_ui_manager_insert_action_group(g_ui_manager, menu_action_group, 0);
gtk_ui_manager_insert_action_group(g_ui_manager, admin_action_group, 1);
accel_group = gtk_ui_manager_get_accel_group(g_ui_manager);
gtk_window_add_accel_group(GTK_WINDOW(window), accel_group);
ui_description = _get_ui_description();
if (!(g_menu_id = gtk_ui_manager_add_ui_from_string(
g_ui_manager, ui_description, -1, &error))) {
xfree(ui_description);
g_error("building menus failed: %s", error->message);
g_error_free (error);
exit (0);
}
xfree(ui_description);
/* GList *action_list = */
/* gtk_action_group_list_actions(menu_action_group); */
/* GtkAction *action = NULL; */
/* int i=0; */
/* while ((action = g_list_nth_data(action_list, i++))) { */
/* g_print("got %s and %x\n", gtk_action_get_name(action), */
/* action); */
/* } */
/* Get the pointers to the correct action so if we ever need
to change it we can effect the action directly so
everything stays in sync.
*/
default_sview_config.action_admin =
(GtkToggleAction *)gtk_action_group_get_action(
menu_action_group, "admin");
default_sview_config.action_grid =
(GtkToggleAction *)gtk_action_group_get_action(
menu_action_group, "grid");
default_sview_config.action_hidden =
(GtkToggleAction *)gtk_action_group_get_action(
menu_action_group, "hidden");
default_sview_config.action_page_opts =
(GtkToggleAction *)gtk_action_group_get_action(
menu_action_group, "page_opts");
// default_sview_config.action_gridtopo =
// (GtkToggleAction *)gtk_action_group_get_action(
// menu_action_group, "topoorder");
default_sview_config.action_ruled =
(GtkToggleAction *)gtk_action_group_get_action(
menu_action_group, "ruled");
/* Pick the first one of the Radio, it is how GTK references
the group in the future.
*/
default_sview_config.action_tab =
(GtkRadioAction *)gtk_action_group_get_action(
menu_action_group, "tab_top");
/* g_print("action grid is %x\n", default_sview_config.action_grid); */
/* Finally, return the actual menu bar created by the item factory. */
return gtk_ui_manager_get_widget (g_ui_manager, "/main");
}
