Did some small test stuff for slurmctld. I think that I duplacted some of the...

Did some small test stuff for slurmctld.  I think that I duplacted some of the work all ready in api/manual, but I'll resolve that later.

testsuite/slurm_unit/slurmctld/Makefile.am

 AUTOMAKE_OPTIONS = foreign
 
-noinst_PROGRAMS = job_mgr-test job_step-test
+noinst_PROGRAMS = job_mgr-test job_step-test job_add job_cancel step_create
 
 INCLUDES = -I$(top_srcdir)/src/common
-job_step_test_LDADD = $(top_srcdir)/src/common/libcommon.la
+
+job_step_test_LDADD = $(top_srcdir)/src/common/libcommon.la \
+		$(top_srcdir)/src/api/libslurm.la
+
+step_create_LDADD = $(top_srcdir)/src/common/libcommon.la \
+		$(top_srcdir)/src/api/libslurm.la
+
+job_add_LDADD = $(top_srcdir)/src/common/libcommon.la \
+		$(top_srcdir)/src/api/libslurm.la
+
+job_cancel_LDADD = $(top_srcdir)/src/common/libcommon.la \
+		$(top_srcdir)/src/api/libslurm.la
+
 LDADD   = $(top_srcdir)/src/common/libcommon.la \
 		$(top_srcdir)/src/slurmctld/job_scheduler.o \
 		$(top_srcdir)/src/slurmctld/node_scheduler.o \

testsuite/slurm_unit/slurmctld/get_resp.h

+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <syslog.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <unistd.h>
+
+#define TBUF_SIZE 2048
+char tbuf[TBUF_SIZE];
+
+char* get_string_resp( char* message, char* current )
+{
+	tbuf[0] = '\0';
+	printf("%s (%s) = ", message, current );
+	fgets( tbuf, TBUF_SIZE, stdin );
+	if ( tbuf[0] != '\n' )
+	{
+		printf( "%s\n", tbuf);
+		return strdup( tbuf ); 
+	}
+	printf( "%s\n", current);
+	return current;
+}
+
+int get_int_resp( char* message, int current )
+{
+	int ret_val = 0;
+	tbuf[0] = '\0';
+	printf("%s (%d) = ", message, current );
+	fgets( tbuf, TBUF_SIZE, stdin );
+	ret_val = atoi( tbuf );
+	if ( ret_val )
+	{
+		printf( "%d\n", ret_val );
+		return ret_val;
+	}
+	printf( "%d\n", current );
+	return current;
+}
+
+uint8_t get_tf_resp( char* message, uint8_t current )
+{
+	tbuf[0] = '\0';
+	printf("%s (%c) = ", message, current ? 't': 'f' );
+	fgets( tbuf, TBUF_SIZE, stdin );
+	if ( tbuf[0] == 'f' || tbuf[0] == 'F' )
+	{
+		printf("false\n" );
+		return 0;
+	}
+	if ( tbuf[0] == 't' || tbuf[0] == 'T' )
+	{
+		printf("true\n" );
+		return 1;
+	}
+	printf("%s\n", current ?"true" :"false"  );
+	return current;	
+}
+
+

testsuite/slurm_unit/slurmctld/job_add.c

+
+
+#ifdef HAVE_CONFIG_H
+#  include <config.h>
+#endif
+
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <syslog.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <unistd.h>
+
+#include <src/api/slurm.h>
+#include <src/common/slurm_protocol_api.h>
+
+#include "get_resp.h"
+#define DEBUG_MODULE
+/* report results of successful job allocation */
+void report_results(resource_allocation_response_msg_t* resp_msg);
+int
+main( int argc, char* argv[])
+{
+	int error_code;	
+	job_desc_msg_t job_mesg;
+	resource_allocation_response_msg_t* resp_msg ;
+
+	/* Create a job/resource allocation */
+	slurm_init_job_desc_msg( &job_mesg );
+	printf("Creating Job Message\n");
+	
+	job_mesg. contiguous = get_tf_resp( "contiguous", 0 );
+	job_mesg. groups = get_string_resp( "groups", "students,employee\0");
+	job_mesg. name = get_string_resp( "job_name", "job01\0");
+	job_mesg. partition_key = get_string_resp( "partition_key", "1234" );
+	job_mesg. min_procs = get_int_resp( "min_procs", 4 );
+	job_mesg. min_memory = get_int_resp( "min_memory", 1024);
+	job_mesg. min_tmp_disk = get_int_resp( "min_tmp_disk", 2034 );
+	job_mesg. partition = get_string_resp("string_resp", "batch\0" );
+	job_mesg. priority = get_int_resp( "priority", 100 );
+	job_mesg. req_nodes = get_string_resp( "req_nodes", "lx[3000-3003]\0" );
+	job_mesg. job_script = get_string_resp( "job_script", "/bin/hostname\0");
+	job_mesg. shared = get_int_resp( "shared", 0 );
+	job_mesg. time_limit = get_int_resp( "time_limit", 200 );
+	job_mesg. num_procs = get_int_resp( "num_procs", 1000) ;
+	job_mesg. num_nodes = get_int_resp( "num_nodes", 400);
+	job_mesg. user_id = get_int_resp( "user_id", 1500 );
+
+
+	error_code = slurm_allocate_resources ( &job_mesg , &resp_msg , false ); 
+	if (error_code)
+		printf ("allocate error %s\n", slurm_strerror( error_code ));
+	else
+		report_results(resp_msg);
+
+	return SLURM_SUCCESS ;
+}
+
+
+void
+report_results(resource_allocation_response_msg_t* resp_msg)
+{
+	int i;
+
+	printf ("NODES ALLOCATED\n\t JOB_ID = %u\n\tnodes = %s\n",  resp_msg->job_id, resp_msg->node_list);
+	if (resp_msg->num_cpu_groups > 0) {
+		printf ("\tprocessor counts: ");
+		for (i=0; i<resp_msg->num_cpu_groups; i++) {
+			if (i > 0)
+				printf(", ");
+			printf ("%u(x%u)", resp_msg->cpus_per_node[i], resp_msg->cpu_count_reps[i]);
+		}
+		printf ("\n");
+	}
+}

testsuite/slurm_unit/slurmctld/job_cancel.c

+
+
+#ifdef HAVE_CONFIG_H
+#  include <config.h>
+#endif
+
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <syslog.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <unistd.h>
+
+#include <src/api/slurm.h>
+#include <src/common/slurm_protocol_api.h>
+
+#include "get_resp.h"
+
+#define DEBUG_MODULE
+/* report results of successful job allocation */
+void report_results(resource_allocation_response_msg_t* resp_msg);
+
+int
+main( int argc, char* argv[])
+{
+	int error_code;	
+	int job_id = atoi( argv[1] );
+	error_code = slurm_cancel_job ( job_id ); 
+
+	if (error_code)
+		slurm_perror( "slurm_cancel_job faile: ");
+	else
+		printf("Job %d canceled\n", job_id );	
+
+	return SLURM_SUCCESS ;
+}
+
+

testsuite/slurm_unit/slurmctld/job_mgr-test.c

@@ -16,8 +16,6 @@ main (int argc, char *argv[])
 	uint16_t tmp_id;
 	//char update_spec[] = "TimeLimit=1234 Priority=123";
 
-	note("This is BullShit");
-
 	log_init(argv[0], opts, SYSLOG_FACILITY_DAEMON, NULL);
 	error_code = init_job_conf ();
 	if (error_code) 

testsuite/slurm_unit/slurmctld/job_step-test.c

@@ -13,20 +13,57 @@
 #include <netinet/in.h>
 #include <unistd.h>
 
+#include <src/api/slurm.h>
 #include <src/common/slurm_protocol_api.h>
 
 #define DEBUG_MODULE
+/* report results of successful job allocation */
+void report_results(resource_allocation_response_msg_t* resp_msg);
+
 int
 main( int argc, char* argv[])
 {
+	int error_code;	
+	job_step_create_request_msg_t request = {   5, 5, 4,4 , 0, "" }; 
+	job_desc_msg_t job_mesg;
+	resource_allocation_response_msg_t* resp_msg ;
 
-	job_step_create_request_msg_t request = {   5, 5, 1, "lx[1-10]" }; 
 	slurm_msg_t request_msg ;
 	slurm_msg_t response_msg;
 
 	request_msg.msg_type = REQUEST_JOB_STEP_CREATE;
 	request_msg.data = &request;
 
+	/* Create a job/resource allocation */
+	slurm_init_job_desc_msg( &job_mesg );
+	job_mesg. contiguous = 1;
+	job_mesg. groups = ("students,employee\0");
+	job_mesg. name = ("job01\0");
+	job_mesg. partition_key = "1234";
+	job_mesg. min_procs = 4;
+	job_mesg. min_memory = 1024;
+	job_mesg. min_tmp_disk = 2034;
+	job_mesg. partition = "batch\0";
+	job_mesg. priority = 100;
+	job_mesg. req_nodes = "lx[3000-3003]\0";
+	job_mesg. job_script = "/bin/hostname\0";
+	job_mesg. shared = 0;
+	job_mesg. time_limit = 200;
+	job_mesg. num_procs = 1000;
+	job_mesg. num_nodes = 400;
+	job_mesg. user_id = 1500;
+
+
+	error_code = slurm_allocate_resources ( &job_mesg , &resp_msg , false ); 
+	if (error_code)
+		printf ("allocate error %d\n", errno);
+	else
+		report_results(resp_msg);
+
+	request. job_id = resp_msg->job_id;
+	request. user_id = 1500;
+	
+	/*create job step */
 	slurm_send_recv_controller_msg ( &request_msg , &response_msg);	
 
 
@@ -51,5 +88,25 @@ main( int argc, char* argv[])
 
 
 	}
+
+	slurm_free_resource_allocation_response_msg ( resp_msg );
 	return SLURM_SUCCESS ;
 }
+
+
+void
+report_results(resource_allocation_response_msg_t* resp_msg)
+{
+	int i;
+
+	printf ("allocate nodes %s to job %u\n", resp_msg->node_list, resp_msg->job_id);
+	if (resp_msg->num_cpu_groups > 0) {
+		printf ("processor counts: ");
+		for (i=0; i<resp_msg->num_cpu_groups; i++) {
+			if (i > 0)
+				printf(", ");
+			printf ("%u(x%u)", resp_msg->cpus_per_node[i], resp_msg->cpu_count_reps[i]);
+		}
+		printf ("\n");
+	}
+}

testsuite/slurm_unit/slurmctld/step_create.c

+
+
+#ifdef HAVE_CONFIG_H
+#  include <config.h>
+#endif
+
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <syslog.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <unistd.h>
+
+#include <src/api/slurm.h>
+#include <src/common/slurm_protocol_api.h>
+
+#include "get_resp.h"
+#define DEBUG_MODULE
+/* report results of successful job allocation */
+void report_results(resource_allocation_response_msg_t* resp_msg);
+
+int
+main( int argc, char* argv[])
+{
+	job_desc_msg_t job_mesg;
+
+	job_step_create_request_msg_t request = {   5, 5, 4,4 , 0, "" }; 
+	resource_allocation_response_msg_t* resp_msg ;
+
+	slurm_msg_t request_msg ;
+	slurm_msg_t response_msg;
+
+	request_msg.msg_type = REQUEST_JOB_STEP_CREATE;
+	request_msg.data = &request;
+
+	request.job_id = get_int_resp( "job_id", 1 );
+	request.user_id = get_int_resp( "user_id", 1500 ); 
+	request.node_count = get_int_resp( "node_count", 10 ); 
+	request.cpu_count = get_int_resp( "cpu_count", 10 ); 
+	request.relative = get_int_resp( "relative", 0 ); 
+	request.node_list = get_string_resp( "node_list", NULL );
+	 
+	
+	/*create job step */
+	slurm_send_recv_controller_msg ( &request_msg , &response_msg);	
+
+
+	if ( response_msg.msg_type != RESPONSE_JOB_STEP_CREATE )
+	{
+		printf("job_step_create failed\n");
+	}
+	else 
+	{
+		job_step_create_response_msg_t* msg = (job_step_create_response_msg_t *) response_msg.data ;
+		printf("job_step_id = %u\n ", msg->	job_step_id );
+		printf("node_list = %s\n", msg->node_list );
+		printf("credentials:\n\tjob_id = %u\n\tuser_id = %u\n\tnode_list = %s\n\texperation_time = %lu\n\tsignature = %u\n\n", 
+					msg->credentials->job_id, 
+					msg->credentials->user_id, 
+					msg->credentials->node_list, 
+					msg->credentials->experation_time, 
+					msg->credentials->signature);
+#ifdef HAVE_LIBELAN3
+    /* print the elan stuff */
+#endif
+
+
+	}
+
+	slurm_free_resource_allocation_response_msg ( resp_msg );
+	return SLURM_SUCCESS ;
+}
+
+
+void
+report_results(resource_allocation_response_msg_t* resp_msg)
+{
+	int i;
+
+	printf ("allocate nodes %s to job %u\n", resp_msg->node_list, resp_msg->job_id);
+	if (resp_msg->num_cpu_groups > 0) {
+		printf ("processor counts: ");
+		for (i=0; i<resp_msg->num_cpu_groups; i++) {
+			if (i > 0)
+				printf(", ");
+			printf ("%u(x%u)", resp_msg->cpus_per_node[i], resp_msg->cpu_count_reps[i]);
+		}
+		printf ("\n");
+	}
+}