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

#include <stdio.h>
#include <stdlib.h>

#include <llapi.h>
#include <unistd.h>
#include <fcntl.h>
#include <time.h>
#include <string.h>
#include <errno.h>

#include <sys/types.h>
#include <sys/stat.h>

#define CHAR_BUFFER 256
#define FILE_LENGTH 1024

void getStatus(char* jobid)
{
char * name=NULL;
        enum StepState step_state;
        int rc;
        int  obj_count,err_code;
        LL_element * job=NULL,*data=NULL,*step=NULL;
        char **host_list;
        
        
        job = ll_query(JOBS);
        if (!job) {
                printf("Query JOBS: ll_query() returns NULL.\n"); exit(1);
        }
        
        host_list = (char **)malloc(2*sizeof(char *));
        host_list[0] = jobid;
        host_list[1] = NULL;

        rc = ll_set_request(job,QUERY_JOBID,host_list,ALL_DATA);
        if (rc) {
                printf("Query JOBS: ll_set_request() return code is non-zero.\n"); exit(1);
        }
        

        data = ll_get_objs(job, LL_SCHEDD, NULL, &obj_count, &err_code);
        if (data == NULL) {
                printf("Query JOBS: ll_get_objs() returns NULL. Error code = %d\n", err_code);
        }
        //printf("Number of jobs objects returned = %d\n", obj_count);

        name=(char*)malloc(256*sizeof(char *));

      ll_get_data(data, LL_JobGetFirstStep, &step);
    

        while(data) {

                rc = ll_get_data(data, LL_JobName,&name);

                if (!rc) {
                        printf("Job name: %s\n",name);
                        free(name);
                }
                //free(step_state);
                rc = ll_get_data(step, LL_StepState,&step_state);
                if (rc) {
                        printf("Query MACHINES: ll_get_data() return code is non-zero.\n"); 
                        exit(1);
                }
                
                if(!rc) {
                        printf("State: %d\n",step_state);
                        
                }               

                data = ll_next_obj(job);
        }

        ll_free_objs(job);
        ll_deallocate(job);

}

void changeStatus(char *jobid,char *state)
{
        int st = atoi(state);
        
        int rt;
        char **job_list;
                        job_list = (char **)malloc(2*sizeof(char*));
                        job_list[0] = jobid;
                        job_list[1] = NULL;
                        
        LL_element *errObj;
        LL_preempt_param  *param_struct;                
        
        LL_terminate_job_info *cancel_info;
        char *rest; 
    char *token; 
    char *ptr = jobid;  
        int n,i;
        switch(st)
        {
                case 0:                 
                        param_struct->type=PREEMPT_STEP;
                        param_struct->method=LL_PREEMPT_SUSPEND; //?
                        param_struct->user_list=NULL;
                        param_struct->host_list=NULL;
                        param_struct->job_list=job_list;
                        printf("DRMAA_CONTROL_SUSPEND\n");
                        rt = ll_preempt_jobs(LL_API_VERSION,errObj,&param_struct);
                        printf("ll_preempt_jobs - PREEMPT_STEP returned: %d\n",rt);
                        break;

                case 1:
                        param_struct->type=RESUME_STEP;
                        param_struct->method=LL_PREEMPT_SUSPEND; //?
                        param_struct->user_list=NULL;
                        param_struct->host_list=NULL;
                        param_struct->job_list=job_list;
                        printf("DRMAA_CONTROL_RESUME\n");
                        rt = ll_preempt_jobs(LL_API_VERSION,errObj,&param_struct);
                        printf("ll_preempt_jobs - RESUME_STEP returned: %d\n",rt);
                        break;

                case 2:
                        printf("DRMAA_CONTROL_HOLD\n");
                        rt = ll_control(LL_CONTROL_VERSION, LL_CONTROL_HOLD_USER, NULL,NULL,job_list,NULL,0);
                        printf("LL_control - LL_CONTROL_HOLD_USER returned: %d, jobid %s\n",rt,jobid);
                        break;

                case 3:
                        printf("DRMAA_CONTROL_RELEASE\n");
                        rt = ll_control(LL_CONTROL_VERSION, LL_CONTROL_HOLD_RELEASE, NULL,NULL,job_list,NULL,0);
                        printf("LL_control - LL_CONTROL_HOLD_RELEASE returned: %d, jobid %s\n",rt,jobid);
                        break;

                case 4:
                        cancel_info = (LL_terminate_job_info *)malloc(sizeof(LL_terminate_job_info));
                        if (!cancel_info) {
                                fprintf(stderr, "Out of memory.\n");
                                exit(1);
                        }
                        
                        cancel_info->version_num=LL_PROC_VERSION;
                        
                        /*cancel_info->StepId.from_host="l4f1n03";
                        cancel_info->StepId.cluster=16651;
                        cancel_info->StepId.proc = 0;*/
                        token = strtok_r(ptr, ".", &rest);
                        cancel_info->StepId.from_host =  strdup(token);
                        ptr = rest; 
                        token = strtok_r(ptr, ".", &rest);
                        ptr = rest; 
                        
                                cancel_info->StepId.cluster = atoi(token);
                        token = strtok_r(ptr, ".", &rest);
        /*                        ptr = rest;           */
                        if(token!=NULL)
                        {
                                cancel_info->StepId.proc = atoi(token);
                        }
                        else
                        {
                                enum StepState step_state;
                                int rc;
                                int  obj_count,err_code;
                                LL_element * job=NULL,*data=NULL,*step=NULL;
                                char **host_list;
                                char * temp = (char *)malloc(30*sizeof(char *));
                                printf("tu3\n");
                                job = ll_query(JOBS);
                                if (!job) {
                                printf("Query JOBS: ll_query() returns NULL.\n"); exit(1);
                                }       
                                
                                sprintf(temp,"%s.%d",cancel_info->StepId.from_host,cancel_info->StepId.cluster);
                                printf("tu2\n");        
                                host_list = (char **)malloc(2*sizeof(char *));
                                host_list[0] = temp;
                                host_list[1] = NULL;
                                
                                
                                rc = ll_set_request(job,QUERY_JOBID,host_list,ALL_DATA);
                                if (rc) {
                                printf("Query JOBS: ll_set_request() return code is non-zero.\n"); exit(1);
                                }
                                
                                data = ll_get_objs(job, LL_SCHEDD, NULL, &obj_count, &err_code);
                                if (data == NULL) {
                                        printf("Query JOBS: ll_get_objs() returns NULL. Error code = %d\n", err_code);
                                }
                                printf("obj_c %d\n",obj_count);
                                  ll_get_data(data, LL_JobGetFirstStep, &step);  
                        
                                rc = ll_get_data(data, LL_JobStepCount, &n);
                                printf("Job count: %d\n",n);
                        
                        
                                
                        
                                }
                        /**/
                                        
                        printf("Cancel Job Step %s.%d.%d \n\n",
                cancel_info->StepId.from_host,
                cancel_info->StepId.cluster,
                cancel_info->StepId.proc);
                        
                        cancel_info->msg=NULL;
                        printf("DRMAA_CONTROL_TERMINATE\n");
                        for(i = 0; i<n;i++)
                        {
                                cancel_info->StepId.proc = i;
                                rt = ll_terminate_job(cancel_info);
                        }
                        printf("LL_terminate_job returned: %d\n",rt);
                        
                        free(cancel_info->StepId.from_host);
                        free(cancel_info);
                        
                        break;

                default:
                        printf("Wrong state value\n");
                        break;

        }
        sleep(1);
}

int main(int argc, char *argv[])
{
        if(argc<3)
        {
                printf("./a <job_id> <change_to_state>\n");
                exit(1);
        }

        getStatus(argv[1]);
        printf("\n");
        changeStatus(argv[1],argv[2]);
        printf("\n");
        getStatus(argv[1]);
        return 0;
}