diff --git a/src/resmom/mom_comm.c b/src/resmom/mom_comm.c index 18a1800431..cbd1189675 100644 --- a/src/resmom/mom_comm.c +++ b/src/resmom/mom_comm.c @@ -261,20 +261,36 @@ int task_save( int fds; int i; int TaskID = 0; - char namebuf[MAXPATHLEN]; - char portname[MAXPATHLEN]; + char namebuf[MAXPATHLEN + 1]; + char portname[MAXPATHLEN + 1]; int openflags; - strcpy(namebuf, path_jobs); /* job directory path */ - strcat(namebuf, pjob->ji_qs.ji_fileprefix); + if (ptask == NULL) + { + log_err(PBSE_BAD_PARAMETER, __func__, "NULL input pointer"); + return(PBSE_BAD_PARAMETER); + } + + pjob = ptask->ti_job; + + if (pjob == NULL) + { + log_err(PBSE_BAD_PARAMETER, __func__, "NULL pointer to owning job"); + return(PBSE_BAD_PARAMETER); + } + + strncpy(namebuf, path_jobs, sizeof(namebuf) - 1); /* job directory path */ + strncat(namebuf, pjob->ji_qs.ji_fileprefix, sizeof(namebuf) - 1); /*TODO: think about stncats third arguments*/ if (multi_mom) { sprintf(portname, "%d", pbs_rm_port); - strcat(namebuf, portname); + /*TODO: do we have actually snprintf*/ + /*snprintf(portname, sizeof(portname), "%d", pbs_rm_port);*/ + strncat(namebuf, portname, sizeof(namebuf) - 1); } - strcat(namebuf, JOB_TASKDIR_SUFFIX); + strncat(namebuf, JOB_TASKDIR_SUFFIX, sizeof(namebuf) - 1); openflags = O_WRONLY | O_CREAT | O_Sync; @@ -1457,6 +1473,11 @@ int check_ms( } np = pjob->ji_hosts; + if (pjob->ji_hosts == NULL) + { + log_err(PBSE_BAD_PARAMETER, __func__, "NULL ptr to job host management stuff"); + return(PBSE_BAD_PARAMETER); + } ipaddr_ms = ntohl(((struct sockaddr_in *)(&np->sock_addr))->sin_addr.s_addr); /* make sure the ip addresses match */ @@ -2131,7 +2152,9 @@ int im_join_job_as_sister( return(IM_FAILURE); } else + { return(IM_DONE); + } } pjob->ji_numnodes = nodenum; /* XXX */ @@ -4896,7 +4919,9 @@ void im_request( case IM_KILL_JOB: { if (check_ms(chan, pjob) == FALSE) + { im_kill_job_as_sister(pjob,event,momport,FALSE); + } close_conn(chan->sock, FALSE); svr_conn[chan->sock].cn_stay_open = FALSE; chan->sock = -1; @@ -7090,8 +7115,6 @@ int tm_request( extern struct connection svr_conn[]; - int start_process(task *ptask, char **argv, char **envp); - if (svr_conn[chan->sock].cn_addr != localaddr) { sprintf(log_buffer, "non-local connect"); diff --git a/src/resmom/mom_comm.h b/src/resmom/mom_comm.h index 2ea5ae2999..965532a55e 100644 --- a/src/resmom/mom_comm.h +++ b/src/resmom/mom_comm.h @@ -1,120 +1,126 @@ #ifndef _MOM_COMM_H #define _MOM_COMM_H #include "license_pbs.h" /* See here for the software license */ - -#include "pbs_job.h" /* task, hnodent, tm_task_id, job, eventent, fwdevent */ #include "tm_.h" /* tm_event_t */ -#include "sys/socket.h" /* sockaddr_in */ -#include "resource.h" /* resource */ -#include "tcp.h" /* tcp_chan */ -int task_save(task *ptask); +/* Forward declarations */ +struct job; +struct task; +struct eventent; +struct hnodent; +struct fwdevent; +struct infoent; +struct sockaddr_in; +struct resource; +struct tcp_chan; + +int task_save(struct task *ptask); -eventent *event_alloc(int command, hnodent *pnode, tm_event_t event, tm_task_id taskid); +struct eventent *event_alloc(int command, struct hnodent *pnode, tm_event_t event, tm_task_id taskid); -task *pbs_task_create(job *pjob, tm_task_id taskid); +struct task *pbs_task_create(struct job *pjob, tm_task_id taskid); -task *task_find(job *pjob, tm_task_id taskid); +struct task *task_find(struct job *pjob, tm_task_id taskid); -task *task_check(job *pjob, tm_task_id taskid); +struct task *task_check(struct job *pjob, tm_task_id taskid); -int task_recov(job *pjob); +int task_recov(struct job *pjob); int tm_reply(struct tcp_chan *chan, int com, tm_event_t event); int im_compose(struct tcp_chan *chan, char *jobid, char *cookie, int command, tm_event_t event, tm_task_id taskid); -int send_sisters(job *pjob, int com, int using_radix); +int send_sisters(struct job *pjob, int com, int using_radix); -hnodent *find_node(job *pjob, int stream, tm_node_id nodeid); +struct hnodent *find_node(struct job *pjob, int stream, tm_node_id nodeid); -void job_start_error(job *pjob, int code, char *nodename); +void job_start_error(struct job *pjob, int code, char *nodename); void arrayfree(char **array); -void node_bailout(job *pjob, hnodent *np); +void node_bailout(struct job *pjob, struct hnodent *np); -void term_job(job *pjob); +void term_job(struct job *pjob); void im_eof(int stream, int ret); -int check_ms(struct tcp_chan *chan, job *pjob); +int check_ms(struct tcp_chan *chan, struct job *pjob); -u_long resc_used(job *pjob, const char *name, u_long(*func)(resource *)); +u_long resc_used(struct job *pjob, const char *name, u_long(*func)(struct resource *)); -infoent *task_findinfo(task *ptask, char *name); +struct infoent *task_findinfo(struct task *ptask, char *name); -void task_saveinfo(task *ptask, char *name, void *info, size_t len); +void task_saveinfo(struct task *ptask, char *name, void *info, size_t len); -char *resc_string(job *pjob); +char *resc_string(struct job *pjob); -int contact_sisters(job *pjob, tm_event_t parent_event, int sister_count, char *radix_hosts, char *radix_ports); +int contact_sisters(struct job *pjob, tm_event_t parent_event, int sister_count, char *radix_hosts, char *radix_ports); -void send_im_error(int err, int reply, job *pjob, char *cookie, tm_event_t event, tm_task_id fromtask); +void send_im_error(int err, int reply, struct job *pjob, char *cookie, tm_event_t event, tm_task_id fromtask); int im_join_job_as_sister(struct tcp_chan *chan, char *jobid, struct sockaddr_in *addr, char *cookie, tm_event_t event, int fromtask, int command, int job_radix); -void im_kill_job_as_sister(job *pjob, tm_event_t event, unsigned int momport, int radix); +void im_kill_job_as_sister(struct job *pjob, tm_event_t event, unsigned int momport, int radix); -int im_spawn_task(struct tcp_chan *chan, char *cookie, tm_event_t event, struct sockaddr_in *addr, tm_task_id fromtask, job *pjob); +int im_spawn_task(struct tcp_chan *chan, char *cookie, tm_event_t event, struct sockaddr_in *addr, tm_task_id fromtask, struct job *pjob); -int im_signal_task(struct tcp_chan *chan, job *pjob, char *cookie, tm_event_t event, tm_task_id fromtask); +int im_signal_task(struct tcp_chan *chan, struct job *pjob, char *cookie, tm_event_t event, tm_task_id fromtask); -int im_obit_task(struct tcp_chan *chan, job *pjob, char *cookie, tm_event_t event, tm_task_id fromtask); +int im_obit_task(struct tcp_chan *chan, struct job *pjob, char *cookie, tm_event_t event, tm_task_id fromtask); -int im_get_info(struct tcp_chan *chan, job *pjob, char *cookie, tm_event_t event, tm_task_id fromtask); +int im_get_info(struct tcp_chan *chan, struct job *pjob, char *cookie, tm_event_t event, tm_task_id fromtask); -int im_get_resc_as_sister(struct tcp_chan *chan, job *pjob, char *cookie, tm_event_t event, tm_task_id fromtask); +int im_get_resc_as_sister(struct tcp_chan *chan, struct job *pjob, char *cookie, tm_event_t event, tm_task_id fromtask); -int get_reply_stream(job *pjob); +int get_reply_stream(struct job *pjob); -int get_radix_reply_stream(job *pjob); +int get_radix_reply_stream(struct job *pjob); -int im_poll_job_as_sister(job *pjob, char *cookie, tm_event_t event, tm_task_id fromtask); +int im_poll_job_as_sister(struct job *pjob, char *cookie, tm_event_t event, tm_task_id fromtask); -int im_abort_job(job *pjob, struct sockaddr_in *addr, char *cookie, tm_event_t event, tm_task_id fromtask); +int im_abort_job(struct job *pjob, struct sockaddr_in *addr, char *cookie, tm_event_t event, tm_task_id fromtask); -int im_get_tid(job *pjob, char *cookie, tm_event_t event, tm_task_id fromtask); +int im_get_tid(struct job *pjob, char *cookie, tm_event_t event, tm_task_id fromtask); -int handle_im_join_job_response(struct tcp_chan *chan, job *pjob, struct sockaddr_in *addr); +int handle_im_join_job_response(struct tcp_chan *chan, struct job *pjob, struct sockaddr_in *addr); -int handle_im_kill_job_response(struct tcp_chan *chan, job *pjob, hnodent *np, int event_com, int nodeidx); +int handle_im_kill_job_response(struct tcp_chan *chan, struct job *pjob, struct hnodent *np, int event_com, int nodeidx); -int handle_im_spawn_task_response(struct tcp_chan *chan, job *pjob, tm_task_id event_task, tm_event_t event); +int handle_im_spawn_task_response(struct tcp_chan *chan, struct job *pjob, tm_task_id event_task, tm_event_t event); -int handle_im_signal_task_response(job *pjob, tm_task_id event_task, tm_event_t event); +int handle_im_signal_task_response(struct job *pjob, tm_task_id event_task, tm_event_t event); -int handle_im_get_tasks_response(struct tcp_chan *chan, job *pjob, tm_task_id event_task, tm_event_t event); +int handle_im_get_tasks_response(struct tcp_chan *chan, struct job *pjob, tm_task_id event_task, tm_event_t event); -int handle_im_obit_task_response(struct tcp_chan *chan, job *pjob, tm_task_id event_task, tm_event_t event); +int handle_im_obit_task_response(struct tcp_chan *chan, struct job *pjob, tm_task_id event_task, tm_event_t event); -int handle_im_get_info_response(struct tcp_chan *chan, job *pjob, tm_task_id event_task, tm_event_t event); +int handle_im_get_info_response(struct tcp_chan *chan, struct job *pjob, tm_task_id event_task, tm_event_t event); -int handle_im_get_resc_response(struct tcp_chan *chan, job *pjob, tm_task_id event_task, tm_event_t event); +int handle_im_get_resc_response(struct tcp_chan *chan, struct job *pjob, tm_task_id event_task, tm_event_t event); -int handle_im_poll_job_response(struct tcp_chan *chan, job *pjob, int nodeidx, hnodent *np); +int handle_im_poll_job_response(struct tcp_chan *chan, struct job *pjob, int nodeidx, struct hnodent *np); -int handle_im_get_tid_response(struct tcp_chan *chan, job *pjob, char *cookie, char **argv, char **envp, fwdevent *efwd); +int handle_im_get_tid_response(struct tcp_chan *chan, struct job *pjob, char *cookie, char **argv, char **envp, struct fwdevent *efwd); void im_request(struct tcp_chan *chan, int version); void tm_eof(int fd); -void tm_request_init(job *pjob, task *ptask, int *ret, int event, int prev_error); +void tm_request_init(struct job *pjob, struct task *ptask, int *ret, int event, int prev_error); -int tm_postinfo(char *name, char *info, char *jobid, int fromtask, int prev_error, int event, int *ret, task *ptask, size_t *len); +int tm_postinfo(char *name, char *info, char *jobid, int fromtask, int prev_error, int event, int *ret, struct task *ptask, size_t *len); -int tm_spawn_request(struct tcp_chan *chan, job *pjob, int prev_error, int event, char *cookie, int *reply_ptr, int *ret, tm_task_id fromtask, hnodent *phost, int nodeid); +int tm_spawn_request(struct tcp_chan *chan, struct job *pjob, int prev_error, int event, char *cookie, int *reply_ptr, int *ret, tm_task_id fromtask, struct hnodent *phost, int nodeid); -int tm_tasks_request(struct tcp_chan *chan, job *pjob, int prev_error, int event, char *cookie, int *reply_ptr, int *ret, tm_task_id fromtask, hnodent *phost, int nodeid); +int tm_tasks_request(struct tcp_chan *chan, struct job *pjob, int prev_error, int event, char *cookie, int *reply_ptr, int *ret, tm_task_id fromtask, struct hnodent *phost, int nodeid); -int tm_signal_request(struct tcp_chan *chan, job *pjob, int prev_error, int event, char *cookie, tm_task_id fromtask, int *ret, int *reply_ptr, hnodent *phost, int nodeid); +int tm_signal_request(struct tcp_chan *chan, struct job *pjob, int prev_error, int event, char *cookie, tm_task_id fromtask, int *ret, int *reply_ptr, struct hnodent *phost, int nodeid); -int tm_obit_request(struct tcp_chan *chan, job *pjob, int prev_error, int event, char *cookie, int *reply_ptr, int *ret, tm_task_id fromtask, hnodent *phost, int nodeid); +int tm_obit_request(struct tcp_chan *chan, struct job *pjob, int prev_error, int event, char *cookie, int *reply_ptr, int *ret, tm_task_id fromtask, struct hnodent *phost, int nodeid); -int tm_getinfo_request(struct tcp_chan *chan, job *pjob, int prev_error, int event, char *cookie, int *reply_ptr, int *ret, tm_task_id fromtask, hnodent *phost, int nodeid); +int tm_getinfo_request(struct tcp_chan *chan, struct job *pjob, int prev_error, int event, char *cookie, int *reply_ptr, int *ret, tm_task_id fromtask, struct hnodent *phost, int nodeid); -int tm_resources_request(struct tcp_chan *chan, job *pjob, int prev_error, int event, char *cookie, int *reply_ptr, int *ret, tm_task_id fromtask, hnodent *phost, int nodeid); +int tm_resources_request(struct tcp_chan *chan, struct job *pjob, int prev_error, int event, char *cookie, int *reply_ptr, int *ret, tm_task_id fromtask, struct hnodent *phost, int nodeid); int tm_request(struct tcp_chan *chan, int version); @@ -122,15 +128,15 @@ int tm_request(struct tcp_chan *chan, int version); char *cat_dirs(char *root, char *base); -char *get_local_script_path(job *pjob, char *base); +char *get_local_script_path(struct job *pjob, char *base); -int get_job_struct(job **pjob, char *jobid, int command, struct tcp_chan *chan, struct sockaddr_in *addr, tm_node_id nodeid); +int get_job_struct(struct job **pjob, char *jobid, int command, struct tcp_chan *chan, struct sockaddr_in *addr, tm_node_id nodeid); int readit(int sock, int fd); void demux_wait(int sig); -void fork_demux(job *pjob); +void fork_demux(struct job *pjob); void send_update_soon(); diff --git a/src/resmom/test/mom_comm/scaffolding.c b/src/resmom/test/mom_comm/scaffolding.c index 910185ee6e..9dac70fcc1 100644 --- a/src/resmom/test/mom_comm/scaffolding.c +++ b/src/resmom/test/mom_comm/scaffolding.c @@ -17,7 +17,7 @@ #include "mom_func.h" /* radix_buf */ #include "dis.h" -char *path_jobs; /* mom_main.c */ +char *path_jobs = "mom_priv/jobs/"; /* mom_main.c */ int multi_mom = 1; /* mom_main.c */ int svr_resc_size = 0; /* resc_def_all.c */ u_long localaddr = 0; /* mom_main.c */ @@ -54,26 +54,22 @@ int insert_thing(resizable_array *ra, void *thing) #undef disrus unsigned short disrus(int stream, int *retval) { - fprintf(stderr, "The call to disrus needs to be mocked!!\n"); - exit(1); + *retval = DIS_SUCCESS; + return(0); } int job_save(job *pjob, int updatetype, int mom_port) { - fprintf(stderr, "The call to job_save needs to be mocked!!\n"); - exit(1); + fprintf(stderr, "This mock job_save always returns 0!!\n"); + return(0); } -void mom_job_purge(job *pjob) - { - fprintf(stderr, "The call to job_purge needs to be mocked!!\n"); - exit(1); - } +void mom_job_purge(job *pjob) {} int decode_DIS_svrattrl(struct tcp_chan *chan, tlist_head *phead) { - fprintf(stderr, "The call to decode_DIS_svrattrl needs to be mocked!!\n"); - exit(1); + fprintf(stderr, "This mock decode_DIS_svrattrl always returns 0!!\n"); + return(0); } ssize_t read_nonblocking_socket(int fd, void *buf, ssize_t count) @@ -82,12 +78,6 @@ ssize_t read_nonblocking_socket(int fd, void *buf, ssize_t count) exit(1); } -char * netaddr(struct sockaddr_in *ap) - { - fprintf(stderr, "The call to netaddr needs to be mocked!!\n"); - exit(1); - } - int TMakeTmpDir(job *pjob, char *tmpdir) { fprintf(stderr, "The call to TMakeTmpDir needs to be mocked!!\n"); @@ -100,11 +90,7 @@ unsigned long gettime(resource *pres) exit(1); } -void exec_bail(job *pjob, int code) - { - fprintf(stderr, "The call to exec_bail needs to be mocked!!\n"); - exit(1); - } +void exec_bail(job *pjob, int code) {} int AVL_list(AvlTree tree, char **Buf, long *current_len, long *max_len) { @@ -118,16 +104,19 @@ int exec_job_on_ms(job *pjob) exit(1); } +struct passwd *check_pwd_return; struct passwd *check_pwd(job *pjob) { - fprintf(stderr, "The call to check_pwd needs to be mocked!!\n"); - exit(1); + if(check_pwd_return == NULL) + { + check_pwd_return = calloc(1,sizeof(*check_pwd_return)); + } + return(check_pwd_return); } int mom_do_poll(job *pjob) { - fprintf(stderr, "The call to mom_do_poll needs to be mocked!!\n"); - exit(1); + return(0); } void delete_link(struct list_link *old) @@ -299,8 +288,7 @@ int mom_get_sample() int run_pelog(int which, char *specpelog, job *pjog, int pe_io_type) { - fprintf(stderr, "The call to run_pelog needs to be mocked!!\n"); - exit(1); + return(0); } #undef disrul @@ -324,8 +312,8 @@ size_t write_nonblocking_socket(int fd, const void *buf, ssize_t count) struct tcp_chan *DIS_tcp_setup(int fd) { - fprintf(stderr, "The call to DIS_tcp_setup needs to be mocked!!\n"); - exit(1); + fprintf(stderr, "This mock DIS_tcp_setup always returns NULL!!\n"); + return(NULL); } int find_attr(struct attribute_def *attr_def, const char *name, int limit) @@ -337,14 +325,8 @@ int find_attr(struct attribute_def *attr_def, const char *name, int limit) #undef disrui unsigned disrui(struct tcp_chan *chan, int *retval) { - fprintf(stderr, "The call to disrui needs to be mocked!!\n"); - exit(1); - } - -int AVL_is_in_tree_no_port_compare(u_long key, uint16_t port, AvlTree tree) - { - fprintf(stderr, "The call to AVL_is_in_tree_no_port_compare needs to be mocked!!\n"); - exit(1); + *retval = DIS_SUCCESS; + return(0); } int kill_task(struct task *task, int sig, int pg) @@ -378,8 +360,8 @@ unsigned long getsize(resource *pres) void *get_next(list_link pl, char *file, int line) { - fprintf(stderr, "The call to get_next needs to be mocked!!\n"); - exit(1); + fprintf(stderr, "This mock get_next always returns NULL!!\n"); + return(NULL); } int add_host_to_sister_list(char *hostname, unsigned short port, struct radix_buf *rb) @@ -415,8 +397,8 @@ void free_sisterlist(struct radix_buf **list, int radix) int write_tcp_reply(struct tcp_chan *chan, int protocol, int version, int command, int exit_code) { - fprintf(stderr, "The call to write_tcp_reply needs to be mocked!!\n"); - exit(1); + fprintf(stderr, "This mock write_tcp_reply always returns 0!!\n"); + return(0); } int mom_set_use(job *pjob) @@ -425,11 +407,7 @@ int mom_set_use(job *pjob) exit(1); } -void free_attrlist(tlist_head *pattrlisthead) - { - fprintf(stderr, "The call to free_attrlist needs to be mocked!!\n"); - exit(1); - } +void free_attrlist(tlist_head *pattrlisthead) {} void attrl_fixlink(tlist_head *phead) { @@ -437,10 +415,19 @@ void attrl_fixlink(tlist_head *phead) exit(1); } +struct resource_def *find_resc_def_return = NULL; resource_def *find_resc_def(resource_def *rscdf, const char *name, int limit) { - fprintf(stderr, "The call to find_resc_def needs to be mocked!!\n"); - exit(1); + if (find_resc_def_return == NULL) + { + find_resc_def_return = calloc(1, sizeof(*find_resc_def_return)); + } + if (find_resc_def_return->rs_name != NULL) + { + free((void*)find_resc_def_return->rs_name); + } + find_resc_def_return->rs_name = strdup(name); + return(find_resc_def_return); } struct radix_buf **allocate_sister_list(int radix) @@ -449,29 +436,13 @@ struct radix_buf **allocate_sister_list(int radix) exit(1); } -int disrst_count = 0; -char *disrst(struct tcp_chan * chan, int *retval) - { - if (--disrst_count > 0) - { - retval = DIS_SUCCESS; - return strdup("hi"); - } - *retval = DIS_EOF; - return NULL; - } - int tcp_connect_sockaddr(struct sockaddr *sa, size_t sa_size) { - fprintf(stderr, "The call to tcp_connect_sockaddr needs to be mocked!!\n"); - exit(1); + fprintf(stderr, "This mock tcp_connect_sockaddr always returns 0!!\n"); + return(0); } -void append_link(tlist_head *head, list_link *new_link, void *pobj) - { - fprintf(stderr, "The call to append_link needs to be mocked!!\n"); - exit(1); - } +void append_link(tlist_head *head, list_link *new_link, void *pobj) {} void sister_job_nodes(job *pjob, char *radix_hosts, char *radix_ports ) { @@ -481,21 +452,12 @@ void sister_job_nodes(job *pjob, char *radix_hosts, char *radix_ports ) int TTmpDirName(job *pjob, char *tmpdir, int tmdir_size) { - fprintf(stderr, "The call to TTmpDirName needs to be mocked!!\n"); - exit(1); + return(0); } -void job_nodes(job *pjob) - { - fprintf(stderr, "The call to job_nodes needs to be mocked!!\n"); - exit(1); - } +void job_nodes(job *pjob) {} -void close_conn(int sd, int has_mutex) - { - fprintf(stderr, "The call to close_conn needs to be mocked!!\n"); - exit(1); - } +void close_conn(int sd, int has_mutex) {} int copy_to_end_of_dynamic_string(dynamic_string *ds, const char *to_copy) { @@ -517,34 +479,41 @@ int rpp_eom(int index) resource *find_resc_entry(pbs_attribute *pattr, resource_def *rscdf) { - fprintf(stderr, "The call to find_resc_entry needs to be mocked!!\n"); - exit(1); + fprintf(stderr, "This mock find_resc_entry always returns NULL!!\n"); + return(NULL); } +job *mock_mom_find_job_return = NULL; job *mom_find_job(char *jobid) { - fprintf(stderr, "The call to find_job needs to be mocked!!\n"); - exit(1); + if (strcmp("jobid", jobid) != 0) + { + return(NULL); + } + if (mock_mom_find_job_return == NULL) + { + mock_mom_find_job_return = calloc(1, sizeof(*mock_mom_find_job_return)); + mock_mom_find_job_return->ji_wattr[JOB_ATR_Cookie].at_flags |= ATR_VFLAG_SET; + mock_mom_find_job_return->ji_wattr[JOB_ATR_Cookie].at_val.at_str = strdup("cookie"); + } + return(mock_mom_find_job_return); } #undef diswsi int diswsi(int stream, int value) { - fprintf(stderr, "The call to diswsi needs to be mocked!!\n"); - exit(1); + fprintf(stderr, "This mock diswsi always returns 0!!\n"); + return(0); } +job *mock_job_alloc_return = NULL; job *job_alloc(void ) { - fprintf(stderr, "The call to job_alloc needs to be mocked!!\n"); - exit(1); - } - -#undef disrsi -int disrsi(struct tcp_chan * chan, int *retval) - { - *retval = 1; - return 0; + if (mock_job_alloc_return == NULL) + { + mock_job_alloc_return = calloc(1, sizeof(*mock_job_alloc_return)); + } + return(mock_job_alloc_return); } int timeval_subtract(struct timeval *result, struct timeval *x, struct timeval *y) @@ -561,8 +530,8 @@ int allocate_demux_sockets(job *pjob, int flag) int kill_job(job *pjob, int sig, const char *killer_id_name, const char *why_killed_reason) { - fprintf(stderr, "The call to kill_job needs to be mocked!!\n"); - exit(1); + fprintf(stderr, "This mock kill_job always returns 0!!\n"); + return(0); } int add_to_resend_things(resend_momcomm *mc) @@ -603,3 +572,76 @@ ssize_t read_ac_socket(int fd, void *buf, ssize_t count) { return(0); } + +int getpeername(int __fd, __SOCKADDR_ARG __addr, socklen_t *__restrict __len) + { + memset(__addr, 0, sizeof(*__addr)); + return(0); + } + +char * netaddr_long(long ap, char *out) + { + u_long ipadd; + + ipadd = ap; + + sprintf(out, "%ld.%ld.%ld.%ld", + (ipadd & 0xff000000) >> 24, + (ipadd & 0x00ff0000) >> 16, + (ipadd & 0x0000ff00) >> 8, + (ipadd & 0x000000ff)); + + return out; + } + +char * netaddr(struct sockaddr_in *ap) + { + static char out[80]; + char tmp[80]; + + if (ap == NULL) + return (char *)"unknown"; + + netaddr_long( ntohl(ap->sin_addr.s_addr), tmp); + + sprintf(out, "%s:%d", tmp, ntohs(ap->sin_port)); + + return out; + } + +int AVL_is_in_tree_no_port_compare(u_long key, uint16_t port, AvlTree tree) + { + return(1); + } + +int disrst_return_index = 0; +#define disrst_array_size 10 +char *disrst_array[disrst_array_size]; +char *disrst(struct tcp_chan *chan, int *retval) + { + if (disrst_return_index >= disrst_array_size) + { + *retval = -1; + return(NULL); + } + *retval = DIS_SUCCESS; + return(disrst_array[disrst_return_index++]); + } + +int disrsi_return_index = 0; +const int disrsi_array_size = 10; +#define disrsi_array_size 10 +int disrsi_array[disrsi_array_size]; +#undef disrsi +int disrsi(struct tcp_chan *chan, int *retval) + { + if (disrsi_return_index >= disrsi_array_size) + { + *retval = -1; + return(-1); + } + *retval = DIS_SUCCESS; + return disrsi_array[disrsi_return_index++]; + } + + diff --git a/src/resmom/test/mom_comm/test_mom_comm.c b/src/resmom/test/mom_comm/test_mom_comm.c index 3af30b060f..f94e9f0a49 100644 --- a/src/resmom/test/mom_comm/test_mom_comm.c +++ b/src/resmom/test/mom_comm/test_mom_comm.c @@ -7,6 +7,12 @@ #include "dis.h" #include "pbs_error.h" #include "pbs_nodes.h" +#include "pbs_job.h" + +extern int disrsi_return_index; +extern int disrst_return_index; +extern int disrsi_array[]; +extern char *disrst_array[]; received_node *get_received_node_entry(char *str); @@ -16,12 +22,16 @@ START_TEST(test_read_status_strings_null_chan_doesnt_crash) } END_TEST -extern int disrst_count; START_TEST(test_read_status_strings_loop) { struct tcp_chan chan; - disrst_count = 5; + disrst_return_index = 0; + disrsi_return_index = 0; + disrsi_array[0] = DIS_SUCCESS; + disrsi_array[1] = DIS_SUCCESS; + disrst_array[0] = strdup("jobid"); + disrst_array[1] = strdup("cookie"); read_status_strings(&chan, 1); } END_TEST @@ -32,17 +42,273 @@ START_TEST(test_get_received_node_entry) } END_TEST +START_TEST(task_save_test) + { + int result = 0; + struct task test_task; + struct job test_job; + char *file_prefix = "prefix"; + + memset(&test_task, 0, sizeof(test_task)); + memset(&test_job, 0, sizeof(test_job)); + + result = task_save(NULL); + fail_unless(result == PBSE_BAD_PARAMETER, "NULL input fail"); + + result = task_save(&test_task); + fail_unless(result == PBSE_BAD_PARAMETER, "NULL pointer to owning job fail"); + + test_task.ti_job = &test_job; + strncpy(test_job.ji_qs.ji_fileprefix, + file_prefix, + sizeof(test_job.ji_qs.ji_fileprefix) - 1); + result = task_save(&test_task); + fail_unless(result == -1, "task_save fail"); + } +END_TEST + +START_TEST(im_request_test) + { + struct tcp_chan test_chan; + memset(&test_chan, 0, sizeof(test_chan)); + + im_request(&test_chan, 0); + + memset(&test_chan, 0, sizeof(test_chan)); + disrsi_return_index = 0; + disrst_return_index = 0; + disrst_array[0] = strdup("other"); + disrst_array[1] = strdup("other"); + disrsi_array[0] = IM_KILL_JOB; + disrsi_array[0] = 0; + disrsi_array[1] = 0; + im_request(&test_chan, IM_PROTOCOL_VER); + + memset(&test_chan, 0, sizeof(test_chan)); + disrsi_return_index = 0; + disrst_return_index = 0; + disrst_array[0] = strdup("jobid"); + disrst_array[1] = strdup("cookie"); + disrsi_array[0] = IM_ALL_OKAY; + disrsi_array[0] = 0; + disrsi_array[1] = 0; + im_request(&test_chan, IM_PROTOCOL_VER); + + memset(&test_chan, 0, sizeof(test_chan)); + disrsi_return_index = 0; + disrst_return_index = 0; + disrst_array[0] = strdup("jobid"); + disrst_array[1] = strdup("cookie"); + disrsi_array[0] = IM_JOIN_JOB; + im_request(&test_chan, IM_PROTOCOL_VER); + + memset(&test_chan, 0, sizeof(test_chan)); + disrsi_return_index = 0; + disrst_return_index = 0; + disrst_array[0] = strdup("jobid"); + disrst_array[1] = strdup("cookie"); + disrsi_array[0] = IM_KILL_JOB; + im_request(&test_chan, IM_PROTOCOL_VER); + + memset(&test_chan, 0, sizeof(test_chan)); + disrsi_return_index = 0; + disrst_return_index = 0; + disrst_array[0] = strdup("jobid"); + disrst_array[1] = strdup("cookie"); + disrsi_array[0] = IM_SPAWN_TASK; + im_request(&test_chan, IM_PROTOCOL_VER); + + memset(&test_chan, 0, sizeof(test_chan)); + disrsi_return_index = 0; + disrst_return_index = 0; + disrst_array[0] = strdup("jobid"); + disrst_array[1] = strdup("cookie"); + disrsi_array[0] = IM_GET_TASKS; + im_request(&test_chan, IM_PROTOCOL_VER); + + memset(&test_chan, 0, sizeof(test_chan)); + disrsi_return_index = 0; + disrst_return_index = 0; + disrst_array[0] = strdup("jobid"); + disrst_array[1] = strdup("cookie"); + disrsi_array[0] = IM_SIGNAL_TASK; + im_request(&test_chan, IM_PROTOCOL_VER); + + memset(&test_chan, 0, sizeof(test_chan)); + disrsi_return_index = 0; + disrst_return_index = 0; + disrst_array[0] = strdup("jobid"); + disrst_array[1] = strdup("cookie"); + disrsi_array[0] = IM_OBIT_TASK; + im_request(&test_chan, IM_PROTOCOL_VER); + + memset(&test_chan, 0, sizeof(test_chan)); + disrsi_return_index = 0; + disrst_return_index = 0; + disrst_array[0] = strdup("jobid"); + disrst_array[1] = strdup("cookie"); + disrsi_array[0] = IM_POLL_JOB; + im_request(&test_chan, IM_PROTOCOL_VER); + + memset(&test_chan, 0, sizeof(test_chan)); + disrsi_return_index = 0; + disrst_return_index = 0; + disrst_array[0] = strdup("jobid"); + disrst_array[1] = strdup("cookie"); + disrsi_array[0] = IM_GET_INFO; + im_request(&test_chan, IM_PROTOCOL_VER); + + memset(&test_chan, 0, sizeof(test_chan)); + disrsi_return_index = 0; + disrst_return_index = 0; + disrst_array[0] = strdup("jobid"); + disrst_array[1] = strdup("cookie"); + disrsi_array[0] = IM_GET_RESC; + im_request(&test_chan, IM_PROTOCOL_VER); + + memset(&test_chan, 0, sizeof(test_chan)); + disrsi_return_index = 0; + disrst_return_index = 0; + disrst_array[0] = strdup("jobid"); + disrst_array[1] = strdup("cookie"); + disrsi_array[0] = IM_ABORT_JOB; + im_request(&test_chan, IM_PROTOCOL_VER); + + memset(&test_chan, 0, sizeof(test_chan)); + disrsi_return_index = 0; + disrst_return_index = 0; + disrst_array[0] = strdup("jobid"); + disrst_array[1] = strdup("cookie"); + disrsi_array[0] = IM_GET_TID; + im_request(&test_chan, IM_PROTOCOL_VER); + + memset(&test_chan, 0, sizeof(test_chan)); + disrsi_return_index = 0; + disrst_return_index = 0; + disrst_array[0] = strdup("jobid"); + disrst_array[1] = strdup("cookie"); + disrsi_array[0] = IM_RADIX_ALL_OK; + im_request(&test_chan, IM_PROTOCOL_VER); + + memset(&test_chan, 0, sizeof(test_chan)); + disrsi_return_index = 0; + disrst_return_index = 0; + disrst_array[0] = strdup("jobid"); + disrst_array[1] = strdup("cookie"); + disrsi_array[0] = IM_JOIN_JOB_RADIX; + im_request(&test_chan, IM_PROTOCOL_VER); + + memset(&test_chan, 0, sizeof(test_chan)); + disrsi_return_index = 0; + disrst_return_index = 0; + disrst_array[0] = strdup("jobid"); + disrst_array[1] = strdup("cookie"); + disrsi_array[0] = IM_KILL_JOB_RADIX; + im_request(&test_chan, IM_PROTOCOL_VER); + + memset(&test_chan, 0, sizeof(test_chan)); + disrsi_return_index = 0; + disrst_return_index = 0; + disrst_array[0] = strdup("jobid"); + disrst_array[1] = strdup("cookie"); + disrsi_array[0] = IM_MAX; + im_request(&test_chan, IM_PROTOCOL_VER); + + memset(&test_chan, 0, sizeof(test_chan)); + disrsi_return_index = 0; + disrst_return_index = 0; + disrst_array[0] = strdup("jobid"); + disrst_array[1] = strdup("cookie"); + disrsi_array[0] = IM_ERROR; + im_request(&test_chan, IM_PROTOCOL_VER); + } +END_TEST + +START_TEST(im_join_job_as_sister_test) + { + int result = -1; + char *test_job_id = "not_jobid"; + char *test_cookie = "cookie"; + struct tcp_chan test_chan; + struct sockaddr_in test_sock_addr; + + memset(&test_chan, 0, sizeof(test_chan)); + memset(&test_sock_addr, 0, sizeof(test_sock_addr)); + + result = im_join_job_as_sister(&test_chan, + test_job_id, + &test_sock_addr, + test_cookie, + 0, + 0, + 0, + 0); + } +END_TEST + +START_TEST(tm_spawn_request_test) + { + struct tcp_chan test_chan; + struct job test_job; + struct hnodent test_hnodent; + char *test_cookie = "cookie"; + int reply = 0; + int ret = 0; + int result = 0; + + memset(&test_chan, 0, sizeof(test_chan)); + memset(&test_job, 0, sizeof(test_job)); + memset(&test_hnodent, 0, sizeof(test_hnodent)); + + result = tm_spawn_request(&test_chan, + &test_job, + 0, + 0, + test_cookie, + &reply, + &ret, + 0, + &test_hnodent, + 0); + + fail_unless(result == TM_DONE, "tm_spawn_request fail: %d", result); + } +END_TEST + Suite *mom_comm_suite(void) { Suite *s = suite_create("mom_comm_suite methods"); - TCase * tc = tcase_create("mom_comm"); + TCase *tc_core = tcase_create("mom_comm"); + + tc_core = tcase_create("test_read_status_strings_null_chan_doesnt_crash"); + tcase_add_test(tc_core, test_read_status_strings_null_chan_doesnt_crash); + suite_add_tcase(s, tc_core); + + tc_core = tcase_create("test_read_status_strings_loop"); + tcase_add_test(tc_core, test_read_status_strings_loop); + suite_add_tcase(s, tc_core); + + tc_core = tcase_create("test_get_received_node_entry"); + tcase_add_test(tc_core, test_get_received_node_entry); + suite_add_tcase(s, tc_core); + + tc_core = tcase_create("task_save_test"); + tcase_add_test(tc_core, task_save_test); + suite_add_tcase(s, tc_core); + + tc_core = tcase_create("im_request_test"); + tcase_add_test(tc_core, im_request_test); + suite_add_tcase(s, tc_core); + + tc_core = tcase_create("im_join_job_as_sister_test"); + tcase_add_test(tc_core, im_join_job_as_sister_test); + suite_add_tcase(s, tc_core); - tcase_add_test(tc, test_read_status_strings_null_chan_doesnt_crash); - tcase_add_test(tc, test_read_status_strings_loop); - tcase_add_test(tc, test_get_received_node_entry); + tc_core = tcase_create("tm_spawn_request_test"); + tcase_add_test(tc_core, tm_spawn_request_test); + suite_add_tcase(s, tc_core); - suite_add_tcase(s, tc); - return s; + return(s); } void rundebug()