From 5de236db69b8bef5eda2c2a39684fdcb4e12c18d Mon Sep 17 00:00:00 2001
From: tewk <tewk@unknown>
Date: Thu, 30 May 2002 17:27:24 +0000
Subject: [PATCH] Added pack routines for job_desc and continued clean up
---
src/common/slurm_protocol_defs.h | 37 +++++-
src/common/slurm_protocol_pack.c | 196 +++++++++++++++++++++++++++++++
2 files changed, 231 insertions(+), 2 deletions(-)
diff --git a/src/common/slurm_protocol_defs.h b/src/common/slurm_protocol_defs.h
index 816adb4146c..a6fcf600e30 100644
--- a/src/common/slurm_protocol_defs.h
+++ b/src/common/slurm_protocol_defs.h
@@ -18,6 +18,7 @@
#define true -1
#define false 0
+#include <src/common/slurm_protocol_common.h>
/* for sendto and recvfrom commands */
#define NO_SEND_RECV_FLAGS 0
@@ -96,7 +97,8 @@ typedef enum {
REQUEST_RUN_JOB_STEP = 48,
RESPONSE_RUN_JOB_STEP = 49
*/
-} slurm_msg_type_t ;
+} SLURM_MSG_TYPE_T ;
+typedef uint16_t slurm_msg_type_t ;
#define REQUEST_NODE_REGISRATION_STATUS 1
#define MESSAGE_NODE_REGISRATION_STATUS 2
@@ -161,9 +163,40 @@ typedef struct slurm_node_registration_status_msg
uint32_t temporary_disk_space ;
} node_registration_status_msg_t ;
+typedef struct job_desc { /* Job descriptor for submit, allocate, and update requests */
+ uint16_t contiguous; /* 1 if job requires contiguous nodes, 0 otherwise,
+ * default=0 */
+ char *features; /* comma separated list of required features, default NONE */
+ char *groups; /* comma separated list of groups the user can access,
+ * default set output of "/usr/bin/groups" by API,
+ * can only be set if user is root */
+ uint32_t job_id; /* job ID, default set by SLURM */
+ char *name; /* name of the job, default "" */
+ void *partition_key; /* root key to submit job, format TBD, default NONE */
+ uint32_t min_procs; /* minimum processors required per node, default=0 */
+ uint32_t min_memory; /* minimum real memory required per node, default=0 */
+ uint32_t min_tmp_disk; /* minimum temporary disk required per node, default=0 */
+ char *partition; /* name of requested partition, default in SLURM config */
+ uint32_t priority; /* relative priority of the job, default set by SLURM,
+ * can only be explicitly set if user is root, maximum
+ * * value is #fffffffe */
+ char *req_nodes; /* comma separated list of required nodes, default NONE */
+ char *job_script; /* pathname of required script, default NONE */
+ uint16_t shared; /* 1 if job can share nodes with other jobs, 0 otherwise,
+ * default in SLURM configuration */
+ uint32_t time_limit; /* maximum run time in minutes, default is partition
+ * limit as defined in SLURM configuration, maximum
+ * * value is #fffffffe */
+ uint32_t num_procs; /* number of processors required by job, default=0 */
+ uint32_t num_nodes; /* number of nodes required by job, default=0 */
+ uint32_t user_id; /* set only if different from current UID, default set
+ * to UID by API, can only be set if user is root */
+} job_desc_t ;
+
typedef struct slurm_msg
{
- uint16_t msg_type ;
+ slurm_msg_type_t msg_type ;
+ slurm_addr address ;
void * msg ;
} slurm_msg_t ;
#endif
diff --git a/src/common/slurm_protocol_pack.c b/src/common/slurm_protocol_pack.c
index b984e8bc139..b15fd47c46b 100644
--- a/src/common/slurm_protocol_pack.c
+++ b/src/common/slurm_protocol_pack.c
@@ -1,6 +1,11 @@
#include <stdlib.h>
+#include <errno.h>
+#include <string.h>
+
#include <src/common/slurm_protocol_pack.h>
#include <src/common/pack.h>
+#include <src/common/log.h>
+#include <src/slurmctld/slurmctld.h>
void pack_header ( char ** buffer , uint32_t * length , header_t * header )
{
@@ -90,6 +95,67 @@ void unpack_msg ( char ** buffer , uint32_t * buf_len , slurm_msg_t * msg )
{
switch ( msg -> msg_type )
{
+ case REQUEST_NODE_REGISRATION_STATUS :
+ break ;
+ case MESSAGE_NODE_REGISRATION_STATUS :
+ break ;
+ case REQUEST_RESOURCE_ALLOCATION :
+ case REQUEST_SUBMIT_BATCH_JOB :
+ break ;
+ case RESPONSE_RESOURCE_ALLOCATION :
+ break ;
+ case RESPONSE_SUBMIT_BATCH_JOB :
+ break ;
+ case REQUEST_CANCEL_JOB :
+ break ;
+ case REQUEST_CANCEL_JOB_STEP :
+ break ;
+ case REQUEST_SIGNAL_JOB :
+ break ;
+ case REQUEST_SIGNAL_JOB_STEP :
+ break ;
+ case REQUEST_RECONFIGURE :
+ break ;
+ case RESPONSE_CANCEL_JOB :
+ case RESPONSE_RECONFIGURE :
+ case RESPONSE_CANCEL_JOB_STEP :
+ case RESPONSE_SIGNAL_JOB :
+ case RESPONSE_SIGNAL_JOB_STEP :
+ break ;
+ case REQUEST_JOB_INFO :
+ break ;
+ case REQUEST_JOB_ATTACH :
+ break ;
+ case RESPONSE_JOB_ATTACH :
+ break ;
+ case REQUEST_LAUNCH_TASKS :
+ break ;
+ case REQUEST_GET_JOB_STEP_INFO :
+ break ;
+ case RESPONSE_GET_JOB_STEP_INFO :
+ break ;
+ case REQUEST_JOB_RESOURCE :
+ break ;
+ case RESPONSE_JOB_RESOURCE :
+ break ;
+ case REQUEST_RUN_JOB_STEP :
+ break ;
+ case RESPONSE_RUN_JOB_STEP:
+ break ;
+ case REQUEST_GET_KEY :
+ break ;
+ case RESPONSE_GET_KEY :
+ break ;
+ case MESSAGE_TASK_EXIT :
+ break ;
+ case REQUEST_BATCH_JOB_LAUNCH :
+ break ;
+ case MESSAGE_UPLOAD_ACCOUNTING_INFO :
+ break ;
+ default :
+ debug ( "No pack method for msg type %i", msg -> msg_type ) ;
+ break;
+
}
}
@@ -107,6 +173,136 @@ void unpack_node_registration_status_msg ( char ** buffer , uint32_t * length ,
unpack32 ( & msg -> temporary_disk_space , ( void ** ) buffer , length ) ;
}
+
+int unpack_build_info ( struct build_buffer **build_buffer_ptr, void * buffer , int buffer_size )
+{
+ uint16_t uint16_tmp;
+ uint32_t uint32_time;
+ struct build_table * build_ptr ;
+ void * buf_ptr;
+
+ /* alloc memory for structure */
+ build_ptr = malloc ( sizeof ( struct build_table ) ) ;
+ if (build_ptr == NULL)
+ {
+ return ENOMEM;
+ }
+
+ /* load the data values */
+ /* unpack timestamp of snapshot */
+ buf_ptr = buffer ;
+ unpack32 (&uint32_time, &buf_ptr, &buffer_size);
+
+ unpack16 (&build_ptr->backup_interval, &buf_ptr, &buffer_size);
+ unpackstr_ptr (&build_ptr->backup_location, &uint16_tmp, &buf_ptr, &buffer_size);
+ unpackstr_ptr (&build_ptr->backup_machine, &uint16_tmp, &buf_ptr, &buffer_size);
+ unpackstr_ptr (&build_ptr->control_daemon, &uint16_tmp, &buf_ptr, &buffer_size);
+ unpackstr_ptr (&build_ptr->control_machine, &uint16_tmp, &buf_ptr, &buffer_size);
+ unpack16 (&build_ptr->controller_timeout, &buf_ptr, &buffer_size);
+ unpackstr_ptr (&build_ptr->epilog, &uint16_tmp, &buf_ptr, &buffer_size);
+ unpack16 (&build_ptr->fast_schedule, &buf_ptr, &buffer_size);
+ unpack16 (&build_ptr->hash_base, &buf_ptr, &buffer_size);
+ unpack16 (&build_ptr->heartbeat_interval, &buf_ptr, &buffer_size);
+ unpackstr_ptr (&build_ptr->init_program, &uint16_tmp, &buf_ptr, &buffer_size);
+ unpack16 (&build_ptr->kill_wait, &buf_ptr, &buffer_size);
+ unpackstr_ptr (&build_ptr->prioritize, &uint16_tmp, &buf_ptr, &buffer_size);
+ unpackstr_ptr (&build_ptr->prolog, &uint16_tmp, &buf_ptr, &buffer_size);
+ unpackstr_ptr (&build_ptr->server_daemon, &uint16_tmp, &buf_ptr, &buffer_size);
+ unpack16 (&build_ptr->server_timeout, &buf_ptr, &buffer_size);
+ unpackstr_ptr (&build_ptr->slurm_conf, &uint16_tmp, &buf_ptr, &buffer_size);
+ unpackstr_ptr (&build_ptr->tmp_fs, &uint16_tmp, &buf_ptr, &buffer_size);
+
+ *build_buffer_ptr = malloc (sizeof (struct build_buffer));
+ if (*build_buffer_ptr == NULL) {
+ free (build_ptr);
+ return ENOMEM;
+ }
+ (*build_buffer_ptr)->last_update = (time_t) uint32_time;
+ (*build_buffer_ptr)->raw_buffer_ptr = buffer;
+ (*build_buffer_ptr)->build_table_ptr = build_ptr;
+ return 0;
+}
+
+int pack_job_desc ( job_desc_t *job_desc_ptr, void * buffer , int buf_len )
+{
+ void * buf_ptr;
+ int buffer_size = buf_len ;
+
+ /* load the data values */
+ /* unpack timestamp of snapshot */
+ buf_ptr = buffer ;
+
+ pack16 (job_desc_ptr->contiguous, &buf_ptr, &buffer_size);
+ packstr (job_desc_ptr->features, &buf_ptr, &buffer_size);
+ packstr (job_desc_ptr->groups, &buf_ptr, &buffer_size);
+ pack32 (job_desc_ptr->job_id, &buf_ptr, &buffer_size);
+ packstr (job_desc_ptr->name, &buf_ptr, &buffer_size);
+ packmem (job_desc_ptr->partition_key, 32, &buf_ptr, &buffer_size);
+
+ pack32 (job_desc_ptr->min_procs, &buf_ptr, &buffer_size);
+ pack32 (job_desc_ptr->min_memory, &buf_ptr, &buffer_size);
+ pack32 (job_desc_ptr->min_tmp_disk, &buf_ptr, &buffer_size);
+
+ packstr (job_desc_ptr->partition, &buf_ptr, &buffer_size);
+ pack32 (job_desc_ptr->priority, &buf_ptr, &buffer_size);
+
+ packstr (job_desc_ptr->partition, &buf_ptr, &buffer_size);
+ packstr (job_desc_ptr->partition, &buf_ptr, &buffer_size);
+ pack16 (job_desc_ptr->shared, &buf_ptr, &buffer_size);
+
+ pack32 (job_desc_ptr->time_limit, &buf_ptr, &buffer_size);
+
+ pack32 (job_desc_ptr->num_procs, &buf_ptr, &buffer_size);
+ pack32 (job_desc_ptr->num_nodes, &buf_ptr, &buffer_size);
+ pack32 (job_desc_ptr->user_id, &buf_ptr, &buffer_size);
+
+ return buf_len - buffer_size ;
+}
+
+int unpack_job_desc ( job_desc_t **job_desc_buffer_ptr, void * buffer , int buffer_size )
+{
+ uint16_t uint16_tmp;
+ void * buf_ptr;
+ job_desc_t * job_desc_ptr ;
+
+ /* alloc memory for structure */
+ job_desc_ptr = malloc ( sizeof ( job_desc_t ) ) ;
+ if (job_desc_ptr== NULL)
+ {
+ return ENOMEM;
+ }
+
+ /* load the data values */
+ /* unpack timestamp of snapshot */
+ buf_ptr = buffer ;
+
+ unpack16 (&job_desc_ptr->contiguous, &buf_ptr, &buffer_size);
+ unpackstr_ptr (&job_desc_ptr->features, &uint16_tmp, &buf_ptr, &buffer_size);
+ unpackstr_ptr (&job_desc_ptr->groups, &uint16_tmp, &buf_ptr, &buffer_size);
+ unpack32 (&job_desc_ptr->job_id, &buf_ptr, &buffer_size);
+ unpackstr_ptr (&job_desc_ptr->name, &uint16_tmp, &buf_ptr, &buffer_size);
+ unpackmem_ptr ( ( char ** ) &job_desc_ptr->partition_key, &uint16_tmp, &buf_ptr, &buffer_size);
+
+ unpack32 (&job_desc_ptr->min_procs, &buf_ptr, &buffer_size);
+ unpack32 (&job_desc_ptr->min_memory, &buf_ptr, &buffer_size);
+ unpack32 (&job_desc_ptr->min_tmp_disk, &buf_ptr, &buffer_size);
+
+ unpackstr_ptr (&job_desc_ptr->partition, &uint16_tmp, &buf_ptr, &buffer_size);
+ unpack32 (&job_desc_ptr->priority, &buf_ptr, &buffer_size);
+
+ unpackstr_ptr (&job_desc_ptr->partition, &uint16_tmp, &buf_ptr, &buffer_size);
+ unpackstr_ptr (&job_desc_ptr->partition, &uint16_tmp, &buf_ptr, &buffer_size);
+ unpack16 (&job_desc_ptr->shared, &buf_ptr, &buffer_size);
+
+ unpack32 (&job_desc_ptr->time_limit, &buf_ptr, &buffer_size);
+
+ unpack32 (&job_desc_ptr->num_procs, &buf_ptr, &buffer_size);
+ unpack32 (&job_desc_ptr->num_nodes, &buf_ptr, &buffer_size);
+ unpack32 (&job_desc_ptr->user_id, &buf_ptr, &buffer_size);
+
+ return 0;
+}
+
/* template
void pack_ ( char ** buffer , uint32_t * length , * msg )
{
--
GitLab