source: experiments/5_4_job_control/a.c @ 16

Revision 16, 5.7 KB checked in by mmatloka, 14 years ago (diff)

add experiments
RevLine 
[16]1#include <stdio.h>
2#include <stdlib.h>
3
4#include <llapi.h>
5#include <unistd.h>
6#include <fcntl.h>
7#include <time.h>
8#include <string.h>
9#include <errno.h>
10
11#include <sys/types.h>
12#include <sys/stat.h>
13
14#define CHAR_BUFFER 256
15#define FILE_LENGTH 1024
16
17void getStatus(char* jobid)
18{
19char * name=NULL;
20        enum StepState step_state;
21        int rc;
22        int  obj_count,err_code;
23        LL_element * job=NULL,*data=NULL,*step=NULL;
24        char **host_list;
25       
26       
27        job = ll_query(JOBS);
28        if (!job) {
29                printf("Query JOBS: ll_query() returns NULL.\n"); exit(1);
30        }
31       
32        host_list = (char **)malloc(2*sizeof(char *));
33        host_list[0] = jobid;
34        host_list[1] = NULL;
35
36        rc = ll_set_request(job,QUERY_JOBID,host_list,ALL_DATA);
37        if (rc) {
38                printf("Query JOBS: ll_set_request() return code is non-zero.\n"); exit(1);
39        }
40       
41
42        data = ll_get_objs(job, LL_SCHEDD, NULL, &obj_count, &err_code);
43        if (data == NULL) {
44                printf("Query JOBS: ll_get_objs() returns NULL. Error code = %d\n", err_code);
45        }
46        //printf("Number of jobs objects returned = %d\n", obj_count);
47
48        name=(char*)malloc(256*sizeof(char *));
49
50      ll_get_data(data, LL_JobGetFirstStep, &step);
51   
52
53        while(data) {
54
55                rc = ll_get_data(data, LL_JobName,&name);
56
57                if (!rc) {
58                        printf("Job name: %s\n",name);
59                        free(name);
60                }
61                //free(step_state);
62                rc = ll_get_data(step, LL_StepState,&step_state);
63                if (rc) {
64                        printf("Query MACHINES: ll_get_data() return code is non-zero.\n");
65                        exit(1);
66                }
67               
68                if(!rc) {
69                        printf("State: %d\n",step_state);
70                       
71                }               
72
73                data = ll_next_obj(job);
74        }
75
76        ll_free_objs(job);
77        ll_deallocate(job);
78
79}
80
81void changeStatus(char *jobid,char *state)
82{
83        int st = atoi(state);
84       
85        int rt;
86        char **job_list;
87                        job_list = (char **)malloc(2*sizeof(char*));
88                        job_list[0] = jobid;
89                        job_list[1] = NULL;
90                       
91        LL_element *errObj;
92        LL_preempt_param  *param_struct;               
93       
94        LL_terminate_job_info *cancel_info;
95        char *rest;
96    char *token;
97    char *ptr = jobid; 
98        int n,i;
99        switch(st)
100        {
101                case 0:                 
102                        param_struct->type=PREEMPT_STEP;
103                        param_struct->method=LL_PREEMPT_SUSPEND; //?
104                        param_struct->user_list=NULL;
105                        param_struct->host_list=NULL;
106                        param_struct->job_list=job_list;
107                        printf("DRMAA_CONTROL_SUSPEND\n");
108                        rt = ll_preempt_jobs(LL_API_VERSION,errObj,&param_struct);
109                        printf("ll_preempt_jobs - PREEMPT_STEP returned: %d\n",rt);
110                        break;
111
112                case 1:
113                        param_struct->type=RESUME_STEP;
114                        param_struct->method=LL_PREEMPT_SUSPEND; //?
115                        param_struct->user_list=NULL;
116                        param_struct->host_list=NULL;
117                        param_struct->job_list=job_list;
118                        printf("DRMAA_CONTROL_RESUME\n");
119                        rt = ll_preempt_jobs(LL_API_VERSION,errObj,&param_struct);
120                        printf("ll_preempt_jobs - RESUME_STEP returned: %d\n",rt);
121                        break;
122
123                case 2:
124                        printf("DRMAA_CONTROL_HOLD\n");
125                        rt = ll_control(LL_CONTROL_VERSION, LL_CONTROL_HOLD_USER, NULL,NULL,job_list,NULL,0);
126                        printf("LL_control - LL_CONTROL_HOLD_USER returned: %d, jobid %s\n",rt,jobid);
127                        break;
128
129                case 3:
130                        printf("DRMAA_CONTROL_RELEASE\n");
131                        rt = ll_control(LL_CONTROL_VERSION, LL_CONTROL_HOLD_RELEASE, NULL,NULL,job_list,NULL,0);
132                        printf("LL_control - LL_CONTROL_HOLD_RELEASE returned: %d, jobid %s\n",rt,jobid);
133                        break;
134
135                case 4:
136                        cancel_info = (LL_terminate_job_info *)malloc(sizeof(LL_terminate_job_info));
137                        if (!cancel_info) {
138                                fprintf(stderr, "Out of memory.\n");
139                                exit(1);
140                        }
141                       
142                        cancel_info->version_num=LL_PROC_VERSION;
143                       
144                        /*cancel_info->StepId.from_host="l4f1n03";
145                        cancel_info->StepId.cluster=16651;
146                        cancel_info->StepId.proc = 0;*/
147                        token = strtok_r(ptr, ".", &rest);
148                        cancel_info->StepId.from_host =  strdup(token);
149                        ptr = rest;
150                        token = strtok_r(ptr, ".", &rest);
151                        ptr = rest;
152                       
153                                cancel_info->StepId.cluster = atoi(token);
154                        token = strtok_r(ptr, ".", &rest);
155        /*                        ptr = rest;           */
156                        if(token!=NULL)
157                        {
158                                cancel_info->StepId.proc = atoi(token);
159                        }
160                        else
161                        {
162                                enum StepState step_state;
163                                int rc;
164                                int  obj_count,err_code;
165                                LL_element * job=NULL,*data=NULL,*step=NULL;
166                                char **host_list;
167                                char * temp = (char *)malloc(30*sizeof(char *));
168                                printf("tu3\n");
169                                job = ll_query(JOBS);
170                                if (!job) {
171                                printf("Query JOBS: ll_query() returns NULL.\n"); exit(1);
172                                }       
173                               
174                                sprintf(temp,"%s.%d",cancel_info->StepId.from_host,cancel_info->StepId.cluster);
175                                printf("tu2\n");       
176                                host_list = (char **)malloc(2*sizeof(char *));
177                                host_list[0] = temp;
178                                host_list[1] = NULL;
179                               
180                               
181                                rc = ll_set_request(job,QUERY_JOBID,host_list,ALL_DATA);
182                                if (rc) {
183                                printf("Query JOBS: ll_set_request() return code is non-zero.\n"); exit(1);
184                                }
185                               
186                                data = ll_get_objs(job, LL_SCHEDD, NULL, &obj_count, &err_code);
187                                if (data == NULL) {
188                                        printf("Query JOBS: ll_get_objs() returns NULL. Error code = %d\n", err_code);
189                                }
190                                printf("obj_c %d\n",obj_count);
191                                  ll_get_data(data, LL_JobGetFirstStep, &step); 
192                       
193                                rc = ll_get_data(data, LL_JobStepCount, &n);
194                                printf("Job count: %d\n",n);
195                       
196                       
197                               
198                       
199                                }
200                        /**/
201                                       
202                        printf("Cancel Job Step %s.%d.%d \n\n",
203                cancel_info->StepId.from_host,
204                cancel_info->StepId.cluster,
205                cancel_info->StepId.proc);
206                       
207                        cancel_info->msg=NULL;
208                        printf("DRMAA_CONTROL_TERMINATE\n");
209                        for(i = 0; i<n;i++)
210                        {
211                                cancel_info->StepId.proc = i;
212                                rt = ll_terminate_job(cancel_info);
213                        }
214                        printf("LL_terminate_job returned: %d\n",rt);
215                       
216                        free(cancel_info->StepId.from_host);
217                        free(cancel_info);
218                       
219                        break;
220
221                default:
222                        printf("Wrong state value\n");
223                        break;
224
225        }
226        sleep(1);
227}
228
229int main(int argc, char *argv[])
230{
231        if(argc<3)
232        {
233                printf("./a <job_id> <change_to_state>\n");
234                exit(1);
235        }
236
237        getStatus(argv[1]);
238        printf("\n");
239        changeStatus(argv[1],argv[2]);
240        printf("\n");
241        getStatus(argv[1]);
242        return 0;
243}
Note: See TracBrowser for help on using the repository browser.