diff --git a/src/api/config_info.c b/src/api/config_info.c
index 8c47fe5d76f9c7b58d71fe341c6d962f2ede8b89..96ab894f9c43dfc970f6e6a3f1684456ee473214 100644
--- a/src/api/config_info.c
+++ b/src/api/config_info.c
@@ -37,22 +37,20 @@ void slurm_print_ctl_conf ( FILE* out, slurm_ctl_conf_info_msg_t * slurm_ctl_con
if ( slurm_ctl_conf_ptr == NULL )
return ;
fprintf(out, "Build updated at %lx\n", (time_t)slurm_ctl_conf_ptr->last_update);
- fprintf(out, "BACKUP_INTERVAL = %u\n", slurm_ctl_conf_ptr->backup_interval);
- fprintf(out, "BACKUP_LOCATION = %s\n", slurm_ctl_conf_ptr->backup_location);
- fprintf(out, "BACKUP_MACHINE = %s\n", slurm_ctl_conf_ptr->backup_machine);
- fprintf(out, "CONTROL_DAEMON = %s\n", slurm_ctl_conf_ptr->control_daemon);
- fprintf(out, "CONTROL_MACHINE = %s\n", slurm_ctl_conf_ptr->control_machine);
- fprintf(out, "EPILOG = %s\n", slurm_ctl_conf_ptr->epilog);
- fprintf(out, "FAST_SCHEDULE = %u\n", slurm_ctl_conf_ptr->fast_schedule);
- fprintf(out, "HASH_BASE = %u\n", slurm_ctl_conf_ptr->hash_base);
- fprintf(out, "HEARTBEAT_INTERVAL = %u\n", slurm_ctl_conf_ptr->heartbeat_interval);
- fprintf(out, "KILL_WAIT = %u\n", slurm_ctl_conf_ptr->kill_wait);
- fprintf(out, "PRIORITIZE = %s\n", slurm_ctl_conf_ptr->prioritize);
- fprintf(out, "PROLOG = %s\n", slurm_ctl_conf_ptr->prolog);
- fprintf(out, "SERVER_DAEMON = %s\n", slurm_ctl_conf_ptr->server_daemon);
- fprintf(out, "SERVER_TIMEOUT = %u\n", slurm_ctl_conf_ptr->server_timeout);
- fprintf(out, "SLURM_CONF = %s\n", slurm_ctl_conf_ptr->slurm_conf);
- fprintf(out, "TMP_FS = %s\n", slurm_ctl_conf_ptr->tmp_fs);
+ fprintf(out, "BackupController = %s\n", slurm_ctl_conf_ptr->backup_controller);
+ fprintf(out, "ControlMachine = %s\n", slurm_ctl_conf_ptr->control_machine);
+ fprintf(out, "Epilog = %s\n", slurm_ctl_conf_ptr->epilog);
+ fprintf(out, "FastSchedule = %u\n", slurm_ctl_conf_ptr->fast_schedule);
+ fprintf(out, "NodeHashBase = %u\n", slurm_ctl_conf_ptr->hash_base);
+ fprintf(out, "HeartbeatInterval = %u\n", slurm_ctl_conf_ptr->heartbeat_interval);
+ fprintf(out, "KillWait = %u\n", slurm_ctl_conf_ptr->kill_wait);
+ fprintf(out, "Prioritize = %s\n", slurm_ctl_conf_ptr->prioritize);
+ fprintf(out, "Prolog = %s\n", slurm_ctl_conf_ptr->prolog);
+ fprintf(out, "SlurmctldTimeout = %u\n", slurm_ctl_conf_ptr->slurmctld_timeout);
+ fprintf(out, "SlurmdTimeout = %u\n", slurm_ctl_conf_ptr->slurmd_timeout);
+ fprintf(out, "SLURM_CONFIG_FILE = %s\n", slurm_ctl_conf_ptr->slurm_conf);
+ fprintf(out, "StateSaveLocation = %s\n", slurm_ctl_conf_ptr->state_save_location);
+ fprintf(out, "TmpFS = %s\n", slurm_ctl_conf_ptr->tmp_fs);
}
int
diff --git a/src/common/Makefile.am b/src/common/Makefile.am
index 0df2e7f2b70233225193677af8aa65a2d5966b84..f9385383a7c4708b01496c116605b0a6b1f324a2 100644
--- a/src/common/Makefile.am
+++ b/src/common/Makefile.am
@@ -28,6 +28,7 @@ libcommon_la_SOURCES = xmalloc.c \
pack.c \
xerrno.c \
hostlist.c \
+ parse_spec.c \
slurm_protocol_api.c \
slurm_protocol_pack.c \
slurm_protocol_util.c \
@@ -49,6 +50,7 @@ noinst_HEADERS = xmalloc.h \
pack.h \
xerrno.h \
hostlist.h \
+ parse_spec.h \
slurm_protocol_api.h \
slurm_protocol_pack.h \
slurm_protocol_util.h \
diff --git a/src/common/slurm_protocol_api.c b/src/common/slurm_protocol_api.c
index 945afdd58fe506ac6e9786c040060b61b463de93..5629f7e15d447025eadd779aa3fdf9a1b0e1d056 100644
--- a/src/common/slurm_protocol_api.c
+++ b/src/common/slurm_protocol_api.c
@@ -5,8 +5,8 @@
#include <stdio.h>
/* PROJECT INCLUDES */
+#include <src/common/parse_spec.h>
#include <src/common/slurm_protocol_interface.h>
-#include <src/common/slurm_protocol_defs.h>
#include <src/common/slurm_protocol_api.h>
#include <src/common/slurm_protocol_common.h>
#include <src/common/slurm_protocol_pack.h>
@@ -17,11 +17,12 @@
/* EXTERNAL VARIABLES */
/* #DEFINES */
+#define BUF_SIZE 1024
/* STATIC VARIABLES */
static slurm_protocol_config_t proto_conf_default ;
static slurm_protocol_config_t * proto_conf = & proto_conf_default ;
-
+static slurm_ctl_conf_t slurmctld_conf;
/************************/
/***** API init functions */
@@ -39,13 +40,92 @@ slurm_protocol_config_t * slurm_get_api_config ( )
int slurm_api_set_default_config ( )
{
- slurm_set_addr ( & proto_conf_default . primary_controller , SLURM_PROTOCOL_DEFAULT_PORT , SLURM_PROTOCOL_DEFAULT_PRIMARY_CONTROLLER ) ;
- slurm_set_addr ( & proto_conf_default . secondary_controller , SLURM_PROTOCOL_DEFAULT_PORT , SLURM_PROTOCOL_DEFAULT_SECONDARY_CONTROLLER ) ;
+ if ( (slurmctld_conf . control_machine == NULL) ||
+ (slurmctld_conf . backup_controller == NULL) ||
+ (slurmctld_conf . slurmctld_port == 0) )
+ read_slurm_port_config ( );
+
+ slurm_set_addr ( & proto_conf_default . primary_controller ,
+ slurmctld_conf . slurmctld_port ,
+ slurmctld_conf . control_machine ) ;
+ slurm_set_addr ( & proto_conf_default . secondary_controller ,
+ slurmctld_conf . slurmctld_port ,
+ slurmctld_conf . backup_controller ) ;
proto_conf = & proto_conf_default ;
return SLURM_SUCCESS ;
}
+int read_slurm_port_config ( )
+{
+ FILE *slurm_spec_file; /* pointer to input data file */
+ char in_line[BUF_SIZE]; /* input line */
+ char * control_machine = NULL;
+ char * backup_controller = NULL;
+ int error_code, i, j, line_num = 0;
+ int slurmctld_port = 0, slurmd_port = 0;
+
+ slurm_spec_file = fopen (SLURM_CONFIG_FILE, "r");
+ if (slurm_spec_file == NULL) {
+ fprintf (stderr, "read_slurm_conf error %d opening file %s",
+ errno, SLURM_CONFIG_FILE);
+ exit (1);
+ }
+
+ while (fgets (in_line, BUF_SIZE, slurm_spec_file) != NULL) {
+ line_num++;
+ if (strlen (in_line) >= (BUF_SIZE - 1)) {
+ error ("read_slurm_conf line %d, of input file %s too long\n",
+ line_num, SLURM_CONFIG_FILE);
+ fclose (slurm_spec_file);
+ return E2BIG;
+ break;
+ }
+
+
+ /* everything after a non-escaped "#" is a comment */
+ /* replace comment flag "#" with an end of string (NULL) */
+ for (i = 0; i < BUF_SIZE; i++) {
+ if (in_line[i] == (char) NULL)
+ break;
+ if (in_line[i] != '#')
+ continue;
+ if ((i > 0) && (in_line[i - 1] == '\\')) { /* escaped "#" */
+ for (j = i; j < BUF_SIZE; j++) {
+ in_line[j - 1] = in_line[j];
+ }
+ continue;
+ }
+ in_line[i] = (char) NULL;
+ break;
+ }
+
+ /* parse what is left */
+ /* overall slurm configuration parameters */
+ error_code = slurm_parser(in_line,
+ "ControlMachine=", 's', &control_machine,
+ "BackupController=", 's', &backup_controller,
+ "SlurmctldPort=", 'd', &slurmctld_port,
+ "SlurmdPort=", 'd', &slurmd_port,
+ "END");
+ if (error_code) {
+ fclose (slurm_spec_file);
+ return error_code;
+ }
+
+ if ( slurmctld_conf.control_machine == NULL )
+ slurmctld_conf.control_machine = control_machine;
+ if ( slurmctld_conf.backup_controller == NULL )
+ slurmctld_conf.backup_controller = backup_controller;
+ if (slurmctld_port)
+ slurmctld_conf.slurmctld_port = slurmctld_port;
+ if (slurmd_port)
+ slurmctld_conf.slurmd_port = slurmd_port;
+ }
+ fclose (slurm_spec_file);
+ return SLURM_SUCCESS;
+}
+
int slurm_set_default_controllers ( char * primary_controller_hostname , char * secondary_controller_hostname, uint16_t pri_port , uint16_t sec_port )
{
slurm_set_addr ( & proto_conf_default . primary_controller , pri_port , primary_controller_hostname ) ;
diff --git a/src/common/slurm_protocol_api.h b/src/common/slurm_protocol_api.h
index a71f03b75509847e00ee671abec8d31406538bb5..b17668fcb6e46f64b99ee33ec0851b8d73f1fb60 100644
--- a/src/common/slurm_protocol_api.h
+++ b/src/common/slurm_protocol_api.h
@@ -21,12 +21,8 @@
#include <src/common/slurm_protocol_defs.h>
#include <src/common/slurm_protocol_errno.h>
-
-#define SLURM_PORT 7002
-#define SLURM_PROTOCOL_DEFAULT_PORT 7002
-#define SLURM_PROTOCOL_DEFAULT_PRIMARY_CONTROLLER "localhost"
-#define SLURM_PROTOCOL_DEFAULT_SECONDARY_CONTROLLER "localhost"
-
+/* slurmctld_conf must be loaded with port numbers and controller names */
+extern slurm_ctl_conf_t slurmctld_conf;
/* high level routines */
/* API init routines */
@@ -150,6 +146,9 @@ void inline slurm_get_addr ( slurm_addr * slurm_address , uint16_t * port , char
void inline slurm_pack_slurm_addr ( slurm_addr * slurm_address , void ** buffer , int * length ) ;
void inline slurm_unpack_slurm_addr_no_alloc ( slurm_addr * slurm_address , void ** buffer , int * length ) ;
+/* function to read hostname and port numbers from configuration file */
+int read_slurm_port_config ( );
+
/* Slurm message functions */
void slurm_free_msg ( slurm_msg_t * msg ) ;
diff --git a/src/common/slurm_protocol_defs.c b/src/common/slurm_protocol_defs.c
index 0e3c6cfb8e79bcab691f26c9ddc2c34a9b40e653..f84ccf79375496eafec785d7274e85ea5989fa42 100644
--- a/src/common/slurm_protocol_defs.c
+++ b/src/common/slurm_protocol_defs.c
@@ -53,12 +53,8 @@ void slurm_free_ctl_conf ( slurm_ctl_conf_info_msg_t * build_ptr )
{
if ( build_ptr )
{
- if ( build_ptr->backup_location )
- xfree ( build_ptr->backup_location ) ;
- if ( build_ptr->backup_machine )
- xfree ( build_ptr->backup_machine ) ;
- if ( build_ptr->control_daemon )
- xfree ( build_ptr->control_daemon ) ;
+ if ( build_ptr->backup_controller )
+ xfree ( build_ptr->backup_controller ) ;
if ( build_ptr->control_machine )
xfree ( build_ptr->control_machine ) ;
if ( build_ptr->epilog )
@@ -67,14 +63,12 @@ void slurm_free_ctl_conf ( slurm_ctl_conf_info_msg_t * build_ptr )
xfree ( build_ptr->prioritize ) ;
if ( build_ptr->prolog )
xfree ( build_ptr->prolog ) ;
- if ( build_ptr->server_daemon )
- xfree ( build_ptr->server_daemon ) ;
if ( build_ptr->slurm_conf )
xfree ( build_ptr->slurm_conf ) ;
+ if ( build_ptr->state_save_location )
+ xfree ( build_ptr->state_save_location ) ;
if ( build_ptr->tmp_fs )
xfree ( build_ptr->tmp_fs ) ;
- if ( build_ptr->server_daemon )
- xfree ( build_ptr->server_daemon ) ;
xfree ( build_ptr ) ;
}
}
diff --git a/src/common/slurm_protocol_defs.h b/src/common/slurm_protocol_defs.h
index 9f35cfc53533ee72bfa1ab37caab779856359446..ebf3bef9ab6d4d23e6e8067d14eeb8a6bc4ce1a5 100644
--- a/src/common/slurm_protocol_defs.h
+++ b/src/common/slurm_protocol_defs.h
@@ -322,13 +322,10 @@ typedef struct job_desc_msg { /* Job descriptor for submit, allocate, and upda
struct slurm_ctl_conf {
uint32_t last_update; /* last update time of the build parameters*/
- uint16_t backup_interval;/* slurmctld save state interval, seconds */
- char *backup_location; /* pathname of state save directory */
- char *backup_machine; /* name of slurmctld secondary server */
- char *control_daemon; /* pathname of slurmctld */
+ char *backup_controller;/* name of slurmctld secondary server */
char *control_machine; /* name of slurmctld primary server */
- uint16_t controller_timeout; /* seconds for secondary slurmctld to take over */
char *epilog; /* pathname of job epilog */
+ uint32_t first_job_id; /* first slurm generated job_id to assign */
uint16_t fast_schedule; /* 1 to *not* check configurations by node
* (only check configuration file, faster) */
uint16_t hash_base; /* base used for hashing node table */
@@ -336,9 +333,12 @@ struct slurm_ctl_conf {
uint16_t kill_wait; /* seconds from SIGXCPU to SIGKILL on job termination */
char *prioritize; /* pathname of program to set initial job priority */
char *prolog; /* pathname of job prolog */
- char *server_daemon; /* pathame of slurmd */
- uint16_t server_timeout;/* how long slurmctld waits for setting node DOWN */
+ uint32_t slurmctld_port;/* default communications port to slurmctld */
+ uint16_t slurmctld_timeout; /* how long backup waits for primarly slurmctld */
+ uint32_t slurmd_port; /* default communications port to slurmd */
+ uint16_t slurmd_timeout;/* how long slurmctld waits for slurmd before setting down */
char *slurm_conf; /* pathname of slurm config file */
+ char *state_save_location; /* pathname of state save directory */
char *tmp_fs; /* pathname of temporary file system */
} ;
typedef struct slurm_ctl_conf slurm_ctl_conf_t ;
diff --git a/src/common/slurm_protocol_pack.c b/src/common/slurm_protocol_pack.c
index d0663484203e5f1e5bff56de8c3f0f1c78e0ebc9..1ca3f92ff2ccaf12206a147086360eb32a58485a 100644
--- a/src/common/slurm_protocol_pack.c
+++ b/src/common/slurm_protocol_pack.c
@@ -834,12 +834,8 @@ int unpack_job_table ( job_table_t * job , void ** buf_ptr , int * buffer_size )
void pack_slurm_ctl_conf ( slurm_ctl_conf_info_msg_t * build_ptr, void ** buf_ptr , int * buffer_size )
{
pack32 (build_ptr->last_update, buf_ptr, buffer_size);
- pack16 (build_ptr->backup_interval, buf_ptr, buffer_size);
- packstr (build_ptr->backup_location, buf_ptr, buffer_size);
- packstr (build_ptr->backup_machine, buf_ptr, buffer_size);
- packstr (build_ptr->control_daemon, buf_ptr, buffer_size);
+ packstr (build_ptr->backup_controller, buf_ptr, buffer_size);
packstr (build_ptr->control_machine, buf_ptr, buffer_size);
- pack16 (build_ptr->controller_timeout, buf_ptr, buffer_size);
packstr (build_ptr->epilog, buf_ptr, buffer_size);
pack16 (build_ptr->fast_schedule, buf_ptr, buffer_size);
pack16 (build_ptr->hash_base, buf_ptr, buffer_size);
@@ -847,9 +843,10 @@ void pack_slurm_ctl_conf ( slurm_ctl_conf_info_msg_t * build_ptr, void ** buf_pt
pack16 (build_ptr->kill_wait, buf_ptr, buffer_size);
packstr (build_ptr->prioritize, buf_ptr, buffer_size);
packstr (build_ptr->prolog, buf_ptr, buffer_size);
- packstr (build_ptr->server_daemon, buf_ptr, buffer_size);
- pack16 (build_ptr->server_timeout, buf_ptr, buffer_size);
+ pack16 (build_ptr->slurmctld_timeout, buf_ptr, buffer_size);
+ pack16 (build_ptr->slurmd_timeout, buf_ptr, buffer_size);
packstr (build_ptr->slurm_conf, buf_ptr, buffer_size);
+ packstr (build_ptr->state_save_location, buf_ptr, buffer_size);
packstr (build_ptr->tmp_fs, buf_ptr, buffer_size);
}
@@ -867,12 +864,8 @@ int unpack_slurm_ctl_conf ( slurm_ctl_conf_info_msg_t **build_buffer_ptr, void *
/* load the data values */
/* unpack timestamp of snapshot */
unpack32 (&build_ptr->last_update, buffer, buffer_size);
- unpack16 (&build_ptr->backup_interval, buffer, buffer_size);
- unpackstr_xmalloc (&build_ptr->backup_location, &uint16_tmp, buffer, buffer_size);
- unpackstr_xmalloc (&build_ptr->backup_machine, &uint16_tmp, buffer, buffer_size);
- unpackstr_xmalloc (&build_ptr->control_daemon, &uint16_tmp, buffer, buffer_size);
+ unpackstr_xmalloc (&build_ptr->backup_controller, &uint16_tmp, buffer, buffer_size);
unpackstr_xmalloc (&build_ptr->control_machine, &uint16_tmp, buffer, buffer_size);
- unpack16 (&build_ptr->controller_timeout, buffer, buffer_size);
unpackstr_xmalloc (&build_ptr->epilog, &uint16_tmp, buffer, buffer_size);
unpack16 (&build_ptr->fast_schedule, buffer, buffer_size);
unpack16 (&build_ptr->hash_base, buffer, buffer_size);
@@ -880,9 +873,10 @@ int unpack_slurm_ctl_conf ( slurm_ctl_conf_info_msg_t **build_buffer_ptr, void *
unpack16 (&build_ptr->kill_wait, buffer, buffer_size);
unpackstr_xmalloc (&build_ptr->prioritize, &uint16_tmp, buffer, buffer_size);
unpackstr_xmalloc (&build_ptr->prolog, &uint16_tmp, buffer, buffer_size);
- unpackstr_xmalloc (&build_ptr->server_daemon, &uint16_tmp, buffer, buffer_size);
- unpack16 (&build_ptr->server_timeout, buffer, buffer_size);
+ unpack16 (&build_ptr->slurmctld_timeout, buffer, buffer_size);
+ unpack16 (&build_ptr->slurmd_timeout, buffer, buffer_size);
unpackstr_xmalloc (&build_ptr->slurm_conf, &uint16_tmp, buffer, buffer_size);
+ unpackstr_xmalloc (&build_ptr->state_save_location, &uint16_tmp, buffer, buffer_size);
unpackstr_xmalloc (&build_ptr->tmp_fs, &uint16_tmp, buffer, buffer_size);
*build_buffer_ptr = build_ptr ;
return 0 ;
diff --git a/src/scontrol/scontrol.c b/src/scontrol/scontrol.c
index 2b1740e7548ff8c8762394eb05827a507c1eacb7..cb6c2d6550590f54cfaa3f7a1173bbce5722c29f 100644
--- a/src/scontrol/scontrol.c
+++ b/src/scontrol/scontrol.c
@@ -252,68 +252,7 @@ print_config (char *config_param)
}
old_slurm_ctl_conf_ptr = slurm_ctl_conf_ptr;
- if (config_param == NULL ||
- strcmp_i (config_param, "BACKUP_INTERVAL") == 0)
- printf ("BACKUP_INTERVAL = %u\n",
- slurm_ctl_conf_ptr->backup_interval);
- if (config_param == NULL ||
- strcmp_i (config_param, "BACKUP_LOCATION") == 0)
- printf ("BACKUP_LOCATION = %s\n",
- slurm_ctl_conf_ptr->backup_location);
- if (config_param == NULL ||
- strcmp_i (config_param, "BACKUP_MACHINE") == 0)
- printf ("BACKUP_MACHINE = %s\n",
- slurm_ctl_conf_ptr->backup_machine);
- if (config_param == NULL ||
- strcmp_i (config_param, "CONTROL_DAEMON") == 0)
- printf ("CONTROL_DAEMON = %s\n",
- slurm_ctl_conf_ptr->control_daemon);
- if (config_param == NULL ||
- strcmp_i (config_param, "CONTROL_MACHINE") == 0)
- printf ("CONTROL_MACHINE = %s\n",
- slurm_ctl_conf_ptr->control_machine);
- if (config_param == NULL ||
- strcmp_i (config_param, "CONTROLLER_TIMEOUT") == 0)
- printf ("CONTROLLER_TIMEOUT = %u\n",
- slurm_ctl_conf_ptr->controller_timeout);
- if (config_param == NULL ||
- strcmp_i (config_param, "EPILOG") == 0)
- printf ("EPILOG = %s\n", slurm_ctl_conf_ptr->epilog);
- if (config_param == NULL ||
- strcmp_i (config_param, "FAST_SCHEDULE") == 0)
- printf ("FAST_SCHEDULE = %u\n",
- slurm_ctl_conf_ptr->fast_schedule);
- if (config_param == NULL ||
- strcmp_i (config_param, "HASH_BASE") == 0)
- printf ("HASH_BASE = %u\n",
- slurm_ctl_conf_ptr->hash_base);
- if (config_param == NULL ||
- strcmp_i (config_param, "HEARTBEAT_INTERVAL") == 0)
- printf ("HEARTBEAT_INTERVAL = %u\n",
- slurm_ctl_conf_ptr->heartbeat_interval);
- if (config_param == NULL ||
- strcmp_i (config_param, "KILL_WAIT") == 0)
- printf ("KILL_WAIT = %u\n", slurm_ctl_conf_ptr->kill_wait);
- if (config_param == NULL ||
- strcmp_i (config_param, "PRIORITIZE") == 0)
- printf ("PRIORITIZE = %s\n", slurm_ctl_conf_ptr->prioritize);
- if (config_param == NULL ||
- strcmp_i (config_param, "PROLOG") == 0)
- printf ("PROLOG = %s\n", slurm_ctl_conf_ptr->prolog);
- if (config_param == NULL ||
- strcmp_i (config_param, "SERVER_DAEMON") == 0)
- printf ("SERVER_DAEMON = %s\n",
- slurm_ctl_conf_ptr->server_daemon);
- if (config_param == NULL ||
- strcmp_i (config_param, "SERVER_TIMEOUT") == 0)
- printf ("SERVER_TIMEOUT = %u\n",
- slurm_ctl_conf_ptr->server_timeout);
- if (config_param == NULL ||
- strcmp_i (config_param, "SLURM_CONF") == 0)
- printf ("SLURM_CONF = %s\n", slurm_ctl_conf_ptr->slurm_conf);
- if (config_param == NULL ||
- strcmp_i (config_param, "TMP_FS") == 0)
- printf ("TMP_FS = %s\n", slurm_ctl_conf_ptr->tmp_fs);
+ slurm_print_ctl_conf (stdout, slurm_ctl_conf_ptr) ;
}