int edg_wll_InitContext(edg_wll_Context *ctx) { int i, ret; edg_wll_Context out = (edg_wll_Context) malloc(sizeof(*out)); union { int i; char *s; struct timeval *tv; } null; if (!out) return ENOMEM; memset(out,0,sizeof(*out)); assert(out->errDesc == NULL); out->allowAnonymous = 1; out->notifSock = -1; out->p_tmp_timeout.tv_sec = out->p_log_timeout.tv_sec; out->p_tmp_timeout.tv_usec = out->p_log_timeout.tv_usec; out->connNotif = (edg_wll_Connections *) calloc(1, sizeof(edg_wll_Connections)); out->connProxy = (edg_wll_ConnProxy *) calloc(1, sizeof(edg_wll_ConnProxy)); if (!out->connNotif || !out->connProxy) goto enomem; out->connections = edg_wll_initConnections(); edg_wll_initConnNotif(out->connNotif); out->connProxy->conn.sock = -1; // out->connToUse = -1; out->id_mapping.num = 0; memset(&null, 0, sizeof null); for (i=0; i<EDG_WLL_PARAM__LAST; i++) { if ((ret = edg_wll_SetParam(out,i,null)) != 0) { edg_wll_FreeContext(out); return ret; } } *ctx = out; #ifdef CTXTRACE { int trc = open(CTXTRACE,O_WRONLY|O_CREAT,0644); char buf[200]; sprintf(buf,"%p init\n",out); lseek(trc,0,SEEK_END); write(trc,buf,strlen(buf)); close(trc); } #endif return 0; enomem: edg_wll_FreeParams(out); free(out->connNotif); free(out->connProxy); free(out); return ENOMEM; }
int main(int argc, char *argv[]) { char *server, *jobid_s, *user; int opt, err = 0; edg_wlc_JobId jobid = NULL; long i; int port = 0; server = jobid_s = NULL; while ( (opt = getopt_long(argc, argv, "hs:p:j:u:c:n:v:", opts, NULL)) != EOF) switch (opt) { case 'h': usage(argv[0]); return 0; case 's': server = strdup(optarg); break; case 'p': port = atoi(optarg); break; case 'j': jobid_s = strdup(optarg); break; case 'u': user = strdup(optarg); break; case '?': usage(argv[0]); return 1; } if ( !jobid_s ) { fprintf(stderr, "JobId not given\n"); return 1; } /*variables*/ edg_wll_Context ctx; edg_wll_Event *eventsOut; edg_wll_QueryRec jc[2]; edg_wll_QueryRec ec[2]; /*end variables*/ if ( (errno = edg_wlc_JobIdParse(jobid_s, &jobid)) ) { perror(jobid_s); return 1; } /*context*/ edg_wll_InitContext(&ctx); edg_wll_SetParam(ctx, EDG_WLL_PARAM_QUERY_SERVER, server); if (port) edg_wll_SetParam(ctx, EDG_WLL_PARAM_QUERY_SERVER_PORT, port); /*end context*/ /*queryrec*/ jc[0].attr = EDG_WLL_QUERY_ATTR_USERTAG; jc[0].op = EDG_WLL_QUERY_OP_EQUAL; jc[0].attr_id.tag = "color"; jc[0].value.c = "red"; jc[1].attr = EDG_WLL_QUERY_ATTR_UNDEF; ec[0].attr = EDG_WLL_QUERY_ATTR_USERTAG; ec[0].op = EDG_WLL_QUERY_OP_EQUAL; ec[0].attr_id.tag = "color"; ec[0].value.c = "green"; ec[1].attr = EDG_WLL_QUERY_ATTR_UNDEF; /*end queryrec*/ /*query*/ err = edg_wll_QueryEvents(ctx, jc, ec, &eventsOut); /*end query*/ if ( err == E2BIG ) { fprintf(stderr,"Warning: only limited result returned!\n"); return 0; } else if (err) { char *et,*ed; edg_wll_Error(ctx,&et,&ed); fprintf(stderr,"%s: edg_wll_QueryEvents(): %s (%s)\n",argv[0],et,ed); free(et); free(ed); } if ( err == ENOENT ) return err; /*printevents*/ for (i = 0; eventsOut && (eventsOut[i].type); i++ ) { //printf("jobId : %s\n", edg_wlc_JobIdUnparse(eventsOut[i].jobId)); printf("event : %s\n\n", edg_wll_EventToString(eventsOut[i].type)); } /*end printevents*/ if ( eventsOut ) { for (i=0; &(eventsOut[i]); i++) edg_wll_FreeEvent(&(eventsOut[i])); free(eventsOut); } edg_wll_FreeContext(ctx); return err; }
int main(int argc,char **argv) { edg_wll_Context ctx; edg_wll_QueryRec **conditions = NULL; time_t valid = 0; char *errt, *errd; void *fields = NULL; int sock = -1, flags = 0; char *fake_addr = NULL; // sleep(20); me = argv[0]; if (edg_wll_InitContext(&ctx) != 0) { fprintf(stderr, "Couldn't create L&B context.\n"); exit(1); } if ( argc < 2 ) { usage(NULL); goto cleanup; } if ( (argc < 2) || !strcmp(argv[1], "help") || !strcmp(argv[1], "--help") || !strcmp(argv[1], "-h") || !strcmp(argv[1], "-?")) { usage(NULL); goto cleanup; } else if ( !strcmp(argv[1], "new") ) { int c; edg_wlc_JobId jid; edg_wll_NotifId id_out; int attr = 0, i = 0, excl = 0; edg_wll_GssCred mycred; edg_wll_GssStatus gss_code; static struct option long_options[] = { {"state", required_argument, 0, 'S'}, {"jdl", no_argument, 0, 'J'}, {"bootstrap", no_argument, 0, 'B'}, {"terminal", no_argument, 0, 'T'}, {"history", no_argument, 0, 'H'}, {"anonymize", no_argument, 0, 'N'}, {"type", no_argument, 0, 'E'}, {0, 0, 0, 0}}; int option_index = 0; char *single, *statelist, *notif_server, *typelist, *type, *typestor; edg_wll_JobStatCode single_code; enum edg_wll_StatJobtype typecode; int statno, stdelims, sti; unsigned int notif_server_port; #define MAX_NEW_CONDS 7 conditions = (edg_wll_QueryRec **)calloc(MAX_NEW_CONDS + 1,sizeof(edg_wll_QueryRec *)); conditions[0] = (edg_wll_QueryRec *)calloc(2,sizeof(edg_wll_QueryRec)); while ((c = getopt_long(argc-1,argv+1,"j:o:v:n:s:a:t:f:cOS:JBTHNE:",long_options,&option_index)) > 0) { switch (c) { case 'j': conditions[i] = (edg_wll_QueryRec *)calloc(2,sizeof(edg_wll_QueryRec)); conditions[i][0].attr = EDG_WLL_QUERY_ATTR_JOBID; conditions[i][0].op = EDG_WLL_QUERY_OP_EQUAL; if (edg_wlc_JobIdParse(optarg, &jid) ) { fprintf(stderr,"Job ID parameter not set propperly!\n"); usage("new"); goto cleanup; } conditions[i][0].value.j = jid; i++; edg_wll_GetParam(ctx, EDG_WLL_PARAM_NOTIF_SERVER, ¬if_server); if (!notif_server) { glite_jobid_getServerParts(jid, ¬if_server, ¬if_server_port); edg_wll_SetParam(ctx, EDG_WLL_PARAM_NOTIF_SERVER, notif_server); edg_wll_SetParamInt(ctx, EDG_WLL_PARAM_NOTIF_SERVER_PORT, notif_server_port); } free(notif_server); break; case 'o': if (excl) { usage("new"); return EX_USAGE; } else excl = 1; conditions[i] = (edg_wll_QueryRec *)calloc(2,sizeof(edg_wll_QueryRec)); conditions[i][0].attr = EDG_WLL_QUERY_ATTR_OWNER; conditions[i][0].op = EDG_WLL_QUERY_OP_EQUAL; conditions[i][0].value.c = optarg; i++; break; case 'v': conditions[i] = (edg_wll_QueryRec *)calloc(2,sizeof(edg_wll_QueryRec)); conditions[i][0].attr = EDG_WLL_QUERY_ATTR_JDL_ATTR; conditions[i][0].op = EDG_WLL_QUERY_OP_EQUAL; conditions[i][0].value.c = optarg; asprintf(&(conditions[i][0].attr_id.tag), "VirtualOrganisation"); i++; break; case 'n': conditions[i] = (edg_wll_QueryRec *)calloc(2,sizeof(edg_wll_QueryRec)); conditions[i][0].attr = EDG_WLL_QUERY_ATTR_NETWORK_SERVER; conditions[i][0].op = EDG_WLL_QUERY_OP_EQUAL; conditions[i][0].value.c = optarg; i++; break; case 's': if (fake_addr) { usage("new"); return EX_USAGE; } sock = atoi(optarg); break; case 'a': if (sock >= 0) { usage("new"); return EX_USAGE; } fake_addr = optarg; break; case 't': valid = time(NULL) + atol(optarg); break; case 'f': flags |= atoi(optarg); break; case 'J': flags |= EDG_WLL_STAT_CLASSADS; break; case 'B': flags |= EDG_WLL_NOTIF_BOOTSTRAP; break; case 'T': flags |= EDG_WLL_NOTIF_TERMINAL_STATES; break; case 'H': flags |= EDG_WLL_NOTIF_TERMINAL_STATES | EDG_WLL_NOTIF_HISTORY; break; case 'N': flags |= EDG_WLL_NOTIF_ANONYMIZE; break; case 'c': conditions[i] = (edg_wll_QueryRec *)calloc(2,sizeof(edg_wll_QueryRec)); conditions[i][0].attr = EDG_WLL_QUERY_ATTR_STATUS; conditions[i][0].op = EDG_WLL_QUERY_OP_CHANGED; i++; break; case 'O': if (excl) { usage("new"); return EX_USAGE; } else excl = 1; if ( !edg_wll_gss_acquire_cred(NULL, NULL, GSS_C_INITIATE, &mycred, &gss_code) ) { conditions[i] = (edg_wll_QueryRec *)calloc(2,sizeof(edg_wll_QueryRec)); conditions[i][0].attr = EDG_WLL_QUERY_ATTR_OWNER; conditions[i][0].op = EDG_WLL_QUERY_OP_EQUAL; conditions[i][0].value.c = strdup(mycred->name); edg_wll_gss_release_cred(&mycred, NULL); i++; } else { fprintf(stderr,"No credentials found! Exiting. \n"); goto cleanup; } break; case 'S': statelist = optarg; statno = 0; stdelims = 0; for (sti = 0; sti < strlen(statelist); sti++) if (statelist[sti] == ',') stdelims++; conditions[i] = (edg_wll_QueryRec *)calloc(stdelims+2,sizeof(edg_wll_QueryRec)); while((single = strtok(statelist, ","))) { single_code = edg_wll_StringToStat(single); if (single_code != -1) { conditions[i][statno].attr = EDG_WLL_QUERY_ATTR_STATUS; conditions[i][statno].op = EDG_WLL_QUERY_OP_EQUAL; conditions[i][statno].value.i = single_code; statelist = NULL; statno++; } else { fprintf(stderr,"'%s' is not a valid state name! Exitting.\n", single); goto cleanup; } } i++; break; case 'E': typelist = optarg; statno = 0; for( type = strtok_r(typelist, ",", &typestor); type ; type = strtok_r(NULL, ",", &typestor)) statno++; conditions[i] = (edg_wll_QueryRec *)calloc(statno+1,sizeof(edg_wll_QueryRec)); statno = 0; for( type = strtok_r(typelist, ",", &typestor); type ; type = strtok_r(NULL, ",", &typestor)) { typecode=edg_wll_JobtypeStrToCode(type); if (((int)typecode)<0) { fprintf(stderr,"'%s' is not a valid job type! Exitting.\n", type); goto cleanup; } else { conditions[i][statno].attr = EDG_WLL_QUERY_ATTR_JOB_TYPE; conditions[i][statno].op = EDG_WLL_QUERY_OP_EQUAL; conditions[i][statno].value.i = typecode; statelist = NULL; statno++; } } i++; break; default: usage("new"); return EX_USAGE; } if (i > MAX_NEW_CONDS) { usage("new"); return EX_USAGE; } } if ( !edg_wll_NotifNew(ctx, (edg_wll_QueryRec const* const*)conditions, flags, sock, fake_addr, &id_out, &valid)) fprintf(stdout,"notification ID: %s\nvalid: %s (%ld)\n", edg_wll_NotifIdUnparse(id_out), TimeToStr(valid), valid); edg_wll_NotifIdFree(id_out); if (attr == EDG_WLL_QUERY_ATTR_JOBID) edg_wlc_JobIdFree(jid); if (edg_wll_Error(ctx,&errt,&errd)) { fprintf(stderr, "%s: %s (%s)\n", me, errt, errd); return EX_IOERR; } } else if ( !strcmp(argv[1], "bind") ) { edg_wll_NotifId nid; int c; while ((c = getopt(argc-1,argv+1,"s:a:t:")) > 0) switch (c) { case 's': if (fake_addr) { usage("bind"); return EX_USAGE; } sock = atoi(optarg); break; case 'a': if (sock >= 0) { usage("bind"); return EX_USAGE; } fake_addr = optarg; break; case 't': valid = time(NULL) + atol(optarg); break; default: usage("bind"); return EX_USAGE; } if ( (optind+1 == argc) || edg_wll_NotifIdParse(argv[optind+1], &nid) ) { fprintf(stderr,"Notification ID parameter not set propperly!\n\n"); usage("bind"); return EX_USAGE; } if ( !edg_wll_NotifBind(ctx, nid, sock, fake_addr, &valid) ) printf("valid until: %s (%ld)\n", TimeToStr(valid), valid); edg_wll_NotifIdFree(nid); if (edg_wll_Error(ctx,&errt,&errd)) { fprintf(stderr, "%s: %s (%s)\n", me, errt, errd); return EX_IOERR; } } else if ( !strcmp(argv[1], "receive") ) { edg_wll_JobStat stat; edg_wll_NotifId nid = NULL; int c; char *field_arg = "owner",*err; time_t client_tout = time(NULL) + 600; int refresh = 0; struct timeval tout; time_t opt_valid = 0,do_refresh = client_tout,now; while ((c = getopt(argc-1,argv+1,"s:a:i:f:t:r")) > 0) switch (c) { case 's': if (fake_addr || refresh || opt_valid) { usage("receive"); return EX_USAGE; } sock = atoi(optarg); break; case 'a': if (sock >= 0) { usage("receive"); return EX_USAGE; } fake_addr = optarg; break; case 'i': client_tout = time(NULL) + atoi(optarg); break; case 'f': field_arg = optarg; break; case 't': if (sock >= 0) { usage("receive"); return EX_USAGE; } opt_valid = atol(optarg); break; case 'r': if (sock >= 0) { usage("receive"); return EX_USAGE; } refresh = 1; break; default: usage("receive"); return EX_USAGE; } if (opt_valid == 0) opt_valid = 3600; if ((err = glite_lb_parse_stat_fields(field_arg,&fields))) { fprintf(stderr,"%s: invalid argument\n",err); return EX_USAGE; } memset(&stat,0,sizeof stat); if (sock == -1) { int param = optind+1; if (param == argc) { fprintf(stderr, "Notification ID parameter not set propperly!\n\n"); usage("receive"); return EX_USAGE; } valid = time(NULL) + opt_valid; while (param < argc) { if (edg_wll_NotifIdParse(argv[param], &nid)) { fprintf(stderr, "Notification ID parameter not set propperly!\n\n"); usage("receive"); return EX_USAGE; } if (edg_wll_NotifBind(ctx, nid, -1, fake_addr, &valid) ) goto receive_err; fprintf(stderr,"notification is valid until: %s (%ld)\n", TimeToStr(valid), valid); param++; } now = time(NULL); do_refresh = now + (valid - now)/2; if (refresh) fprintf(stderr,"next refresh %s (%ld)\n", TimeToStr(do_refresh),do_refresh); } do { edg_wll_NotifId recv_nid = NULL; int err; tout.tv_sec = (refresh && client_tout >= do_refresh ? do_refresh : client_tout) - time(NULL); if (tout.tv_sec < 0) tout.tv_sec = 0; tout.tv_usec = 0; if ( (err = edg_wll_NotifReceive(ctx, sock, &tout, &stat, &recv_nid)) ) { edg_wll_NotifIdFree(recv_nid); recv_nid = NULL; if (err != ETIMEDOUT) goto receive_err; } else { glite_lb_print_stat_fields(fields,&stat); edg_wll_FreeStatus(&stat); stat.state = EDG_WLL_JOB_UNDEF; } if ((now = time(NULL)) >= client_tout) goto cleanup; if (refresh && now >= do_refresh) { valid = now + opt_valid; if (!edg_wll_NotifRefresh(ctx,nid,&valid)) { do_refresh = now + (valid - now)/2; fprintf(stderr,"notification is valid until: %s (%ld)\n",TimeToStr(valid), valid); fprintf(stderr,"next refresh %s (%ld)\n", TimeToStr(do_refresh),do_refresh); } else { char *et,*ed; edg_wll_Error(ctx,&et,&ed); do_refresh = now + (valid - now)/2; fprintf(stderr,"warning: edg_wll_NotifRefresh failed (%s, %s)\n" "next refresh %s (%ld)\n", et,ed,TimeToStr(do_refresh),do_refresh); } } /* original example */ #if 0 printf("\nnotification ID: %s\n", edg_wll_NotifIdUnparse(recv_nid)); if (stat.state != EDG_WLL_JOB_UNDEF) { char *jobid_s; jobid_s = edg_wlc_JobIdUnparse(stat.jobId); printf("Jobid:\t%s\nStatus:\t%s\n", jobid_s, edg_wll_StatToString(stat.state)); edg_wll_FreeStatus(&stat); free(jobid_s); stat.state = EDG_WLL_JOB_UNDEF; } #endif if (recv_nid) { edg_wll_NotifIdFree(recv_nid); recv_nid = NULL; } } while (1); // till timeout.... return 0; receive_err: if (stat.state != EDG_WLL_JOB_UNDEF) edg_wll_FreeStatus(&stat); if (nid) edg_wll_NotifIdFree(nid); edg_wll_NotifCloseFd(ctx); edg_wll_NotifClosePool(ctx); if (edg_wll_Error(ctx,&errt,&errd)) fprintf(stderr, "%s: %s (%s)\n", me, errt, errd); return EX_IOERR; } else if ( !strcmp(argv[1], "change") ) { edg_wlc_JobId jid; edg_wll_NotifId nid; if ( (argc < 3) || edg_wll_NotifIdParse(argv[2], &nid) ) { printf("Notification ID parameter not set propperly!\n"); usage("bind"); return 1; } if ( (argc < 4) || edg_wlc_JobIdParse(argv[3], &jid) ) { fprintf(stderr,"Job ID parameter not set propperly!\n"); usage("change"); goto cleanup; } conditions = (edg_wll_QueryRec **)calloc(2,sizeof(edg_wll_QueryRec *)); conditions[0] = (edg_wll_QueryRec *)calloc(2,sizeof(edg_wll_QueryRec)); conditions[0][0].attr = EDG_WLL_QUERY_ATTR_JOBID; conditions[0][0].op = EDG_WLL_QUERY_OP_EQUAL; conditions[0][0].value.j = jid; conditions[1] = NULL; /*conditions[1] = (edg_wll_QueryRec *)calloc(3, sizeof(edg_wll_QueryRec)); conditions[1][0].attr = EDG_WLL_QUERY_ATTR_STATUS; conditions[1][0].op = EDG_WLL_QUERY_OP_EQUAL; conditions[1][0].value.i = EDG_WLL_JOB_DONE; conditions[1][1].attr = EDG_WLL_QUERY_ATTR_STATUS; conditions[1][1].op = EDG_WLL_QUERY_OP_EQUAL; conditions[1][1].value.i = EDG_WLL_JOB_RUNNING;*/ edg_wll_NotifChange(ctx, nid, (edg_wll_QueryRec const * const *) conditions, EDG_WLL_NOTIF_REPLACE); edg_wlc_JobIdFree(jid); edg_wll_NotifIdFree(nid); } else if ( !strcmp(argv[1], "refresh") ) { edg_wll_NotifId nid; int c; while ((c = getopt(argc-1,argv+1,"t:")) > 0) switch (c) { case 't': valid = time(NULL) + atol(optarg); break; default: usage("refresh"); return EX_USAGE; } if ( (optind+1 == argc) || edg_wll_NotifIdParse(argv[optind+1], &nid) ) { fprintf(stderr,"Notification ID parameter not set propperly!\n\n"); usage("refresh"); return EX_USAGE; } if ( !edg_wll_NotifRefresh(ctx, nid, &valid) ) printf("valid until: %s (%ld)\n", TimeToStr(valid), valid); edg_wll_NotifIdFree(nid); } else if ( !strcmp(argv[1], "drop") ) { edg_wll_NotifId nid; if ( (argc < 3) || edg_wll_NotifIdParse(argv[2], &nid) ) { fprintf(stderr,"Notification ID parameter not set propperly!\n"); usage("drop"); return EX_USAGE; } edg_wll_NotifDrop(ctx, nid); edg_wll_NotifIdFree(nid); } else { usage(NULL); return EX_USAGE; } cleanup: if ( conditions ) { /* for ( i = 0; conditions[i][0].attr; i++ ) free(conditions[1]); */ free(conditions); } int retval; if (retval = edg_wll_Error(ctx,&errt,&errd)) fprintf(stderr, "%s: %s (%s)\n", me, errt, errd); edg_wll_NotifCloseFd(ctx); edg_wll_FreeContext(ctx); edg_wll_poolFree(); return retval; }
int main(int argc,char **argv) { edg_wll_Context ctx; char *errt,*errd; edg_wll_Event *events = NULL; edg_wlc_JobId job; int i,opt,delay = 1,count = 0, proxy = 0; if (argc < 2) help(argv[0]); if (edg_wll_InitContext(&ctx) != 0) { fprintf(stderr, "Couldn't create L&B context.\n"); return 1; } while ((opt=getopt(argc,argv,"r:d:xX:")) != -1) switch (opt) { case 'd': delay = atoi(optarg); break; case 'r': count = atoi(optarg); break; case 'x': proxy = 1; break; case 'X': proxy = 1; edg_wll_SetParam(ctx, EDG_WLL_PARAM_LBPROXY_SERVE_SOCK, optarg); break; default: help(argv[0]); } if (edg_wlc_JobIdParse(argv[optind],&job)) { fprintf(stderr,"%s: can't parse job ID\n",argv[1]); return 1; } #ifdef USE_CALLBACKS edg_wll_RegisterTestQueryEvents(query_events_cb); #endif if ( proxy ? edg_wll_JobLogProxy(ctx,job,&events) : edg_wll_JobLog(ctx,job,&events) ) { edg_wll_Error(ctx,&errt,&errd); fprintf(stderr,"%s: %s (%s)\n",argv[0],errt,errd); } for ( i = 0; events && events[i].type != EDG_WLL_EVENT_UNDEF; i++ ) { char *e = edg_wll_UnparseEvent(ctx,events+i); fputs(e,stdout); fputs("\n",stdout); free(e); } free_events(events); printf("\nFound %d events\n",i); while (count--) { puts("Sleeping ..."); sleep(delay); if (proxy ? edg_wll_JobLogProxy(ctx,job,&events) : edg_wll_JobLog(ctx,job,&events)) { edg_wll_Error(ctx,&errt,&errd); fprintf(stderr,"%s: %s (%s)\n",argv[0],errt,errd); free(errt); free(errd); errt = errd = NULL; free_events(events); } else puts("OK"); } edg_wlc_JobIdFree(job); edg_wll_FreeContext(ctx); #ifdef USE_CALLBACKS edg_wll_UnregisterTestQueryEvents(); #endif return 0; #ifdef USE_CALLBACKS edg_wll_UnregisterTestQueryEvents(); #endif switch (edg_wll_Error(ctx,&errt,&errd)) { case 0: break; case ENOENT: puts("No events found"); break; default: fprintf(stderr,"%s: %s (%s)\n",argv[0],errt,errd); return 1; } edg_wlc_JobIdFree(job); edg_wll_FreeContext(ctx); return 0; }
int main(int argc,char **argv) { edg_wll_Context ctx; char *errt,*errd,*e,a; edg_wll_Event *events; int i; edg_wll_QueryRec jq[2],eq[2]; edg_wlc_JobId job; edg_wll_Source src; if (argc != 3) help(argv[0]); puts( "*\n" "* USE WITH CARE, AT YOUR OWN RISK, UNDER ABNORMAL CONDITIONS ONLY,\n" "* AND BE ALWAYS SURE WHAT YOU ARE DOING.\n" "* \n" "* THIS PROGRAM IS A PERFECT EXAMPLE HOW L&B SEQENCE CODES SHOULD NOT BE USED\n" "* IN NORMAL OPERATION.\n" "\n" "Do you want to proceed?" ); scanf("%c",&a); if (a != 'y' && a != 'Y') return 1; if (edg_wll_InitContext(&ctx) != 0) { fprintf(stderr, "Couldn't create L&B context.\n"); return 1; } if (edg_wlc_JobIdParse(argv[1],&job)) { fprintf(stderr,"%s: can't parse job ID\n",argv[1]); return 1; } if (( src = edg_wll_StringToSource(argv[2])) == EDG_WLL_SOURCE_NONE) { fprintf(stderr,"%s: unknown event source\n",argv[2]); return 1; } jq[0].attr = EDG_WLL_QUERY_ATTR_JOBID; jq[0].op = EDG_WLL_QUERY_OP_EQUAL; jq[0].value.j = job; jq[1].attr = EDG_WLL_QUERY_ATTR_UNDEF; eq[0].attr = EDG_WLL_QUERY_ATTR_SOURCE; eq[0].op = EDG_WLL_QUERY_OP_EQUAL; eq[0].value.i = src; eq[1].attr = EDG_WLL_QUERY_ATTR_UNDEF; if ( edg_wll_QueryEvents(ctx,jq,eq,&events) ) { if ( edg_wll_Error(ctx, &errt, &errd) != E2BIG ) goto err; fprintf(stderr,"%s: %s (%s)\n",argv[0],errt,errd); } for ( i = 0; events[i].type != EDG_WLL_EVENT_UNDEF; i++ ); e = edg_wll_UnparseEvent(ctx,events+i-1); fputs(e,stdout); fputs("\n",stdout); if (edg_wll_SetParam(ctx,EDG_WLL_PARAM_SOURCE,src) || edg_wll_SetLoggingJob(ctx,job,events[i-1].any.seqcode,EDG_WLL_SEQ_NORMAL) || edg_wll_IncSequenceCode(ctx) || /* necessary to simulate this * call in last event logging * _after_ current seq. was used */ edg_wll_LogAbort(ctx,"manual abort")) goto err; free(e); free_events(events); edg_wll_FreeContext(ctx); return 0; err: switch (edg_wll_Error(ctx,&errt,&errd)) { case 0: break; case ENOENT: puts("No events found"); break; default: fprintf(stderr,"%s: %s (%s)\n",argv[0],errt,errd); return 1; } edg_wll_FreeContext(ctx); return 0; }
int main(int argc, char *argv[]) { char *server, *jobid_s, *user; edg_wlc_JobId jobid = NULL; int opt, err = 0; long i; int port = 0; server = jobid_s = user = NULL; while ( (opt = getopt_long(argc, argv, "hs:p:j:u:c:n:v:", opts, NULL)) != EOF) switch (opt) { case 'h': usage(argv[0]); return 0; case 's': server = strdup(optarg); break; case 'p': port = atoi(optarg); break; case 'j': jobid_s = strdup(optarg); break; case 'u': user = strdup(optarg); break; case '?': usage(argv[0]); return 1; } if ( !jobid_s ) { fprintf(stderr, "JobId not given\n"); return 1; } /*variables*/ edg_wll_Context ctx; edg_wll_QueryRec *jc[4]; edg_wll_JobStat *statesOut = NULL; edg_wlc_JobId *jobsOut = NULL; /*end variables*/ if ( (errno = edg_wlc_JobIdParse(jobid_s, &jobid)) ) { perror(jobid_s); return 1; } /*context*/ edg_wll_InitContext(&ctx); edg_wll_SetParam(ctx, EDG_WLL_PARAM_QUERY_SERVER, server); if (port) edg_wll_SetParam(ctx, EDG_WLL_PARAM_QUERY_SERVER_PORT, port); /*end context*/ /*queryrec*/ jc[0] = (edg_wll_QueryRec *) malloc(2*sizeof(edg_wll_QueryRec)); jc[0][0].attr = EDG_WLL_QUERY_ATTR_OWNER; jc[0][0].op = EDG_WLL_QUERY_OP_EQUAL; jc[0][0].value.c = NULL; jc[0][1].attr = EDG_WLL_QUERY_ATTR_UNDEF; jc[1] = (edg_wll_QueryRec *) malloc(2*sizeof(edg_wll_QueryRec)); jc[1][0].attr = EDG_WLL_QUERY_ATTR_STATUS; jc[1][0].op = EDG_WLL_QUERY_OP_EQUAL; jc[1][0].value.i = EDG_WLL_JOB_RUNNING; jc[1][1].attr = EDG_WLL_QUERY_ATTR_UNDEF; jc[2] = (edg_wll_QueryRec *) malloc(3*sizeof(edg_wll_QueryRec)); jc[2][0].attr = EDG_WLL_QUERY_ATTR_DESTINATION; jc[2][0].op = EDG_WLL_QUERY_OP_EQUAL; jc[2][0].value.c = "XXX"; jc[2][1].attr = EDG_WLL_QUERY_ATTR_DESTINATION; jc[2][1].op = EDG_WLL_QUERY_OP_EQUAL; jc[2][1].value.c = "YYY"; jc[2][2].attr = EDG_WLL_QUERY_ATTR_UNDEF; jc[3] = NULL; /*end queryrec*/ /*query*/ err = edg_wll_QueryJobsExt(ctx, (const edg_wll_QueryRec **)jc, 0, &jobsOut, &statesOut); /*end query*/ if ( err == E2BIG ) { fprintf(stderr,"Warning: only limited result returned!\n"); return 0; } else if (err) { char *et,*ed; edg_wll_Error(ctx,&et,&ed); fprintf(stderr,"%s: edg_wll_QueryJobs(): %s (%s)\n",argv[0],et,ed); free(et); free(ed); } /*printstates*/ for (i = 0; statesOut[i].state; i++ ) { printf("jobId : %s\n", edg_wlc_JobIdUnparse(statesOut[i].jobId)); printf("state : %s\n\n", edg_wll_StatToString(statesOut[i].state)); } /*end printstates*/ if ( jobsOut ) { for (i=0; jobsOut[i]; i++) edg_wlc_JobIdFree(jobsOut[i]); free(jobsOut); } if ( statesOut ) { for (i=0; statesOut[i].state; i++) edg_wll_FreeStatus(&statesOut[i]); free(statesOut); } free(jc[0]); free(jc[1]); free(jc[2]); edg_wll_FreeContext(ctx); return err; }
int main(int argc, char *argv[]) { char *destname= NULL,*hostname=NULL,*testname = NULL,*filename = NULL; char *event; int num_jobs = 1; int opt; int skip = -1; edg_wll_Context ctx; enum { DEST_UNDEF = 0, DEST_LL, DEST_IL, DEST_PROXY, DEST_BKSERVER, DEST_DUMP, } dest = 0; struct timeval log_timeout = { tv_sec: 2, tv_usec: 0 }; if (edg_wll_InitContext(&ctx) != 0) { fprintf(stderr, "Couldn't create L&B context.\n"); return 1; } opterr = 0; while ((opt = getopt_long(argc,argv,"hd:t:f:m:n:Ns:P::p:", long_options, (int *) 0)) != EOF) { switch (opt) { case 'd': destname = (char *) strdup(optarg); break; case 't': testname = (char *) strdup(optarg); break; case 'f': filename = (char *) strdup(optarg); break; case 'm': hostname = (char *) strdup(optarg); break; case 'p': logfile_prefix = (char*) strdup(optarg); break; case 's': il_socket = (char*) strdup(optarg); break; case 'n': num_jobs = atoi(optarg); break; case 'P': skip = optarg ? atoi(optarg) : 0; break; case 'h': default: usage(argv[0]); exit(0); } } if(destname) { if(!strncasecmp(destname, "pr", 2)) dest=DEST_PROXY; else if(!strncasecmp(destname, "lo", 2) || !strncasecmp(destname, "ll", 2)) dest=DEST_LL; else if(!strncasecmp(destname, "in", 2) || !strncasecmp(destname, "il", 2)) dest=DEST_IL; else if(!strncasecmp(destname, "bk", 2) || !strncasecmp(destname, "se", 2)) dest=DEST_BKSERVER; else if(!strncasecmp(destname, "du", 2)) dest=DEST_DUMP; else { fprintf(stderr,"%s: wrong destination\n",argv[0]); usage(argv[0]); exit(1); } } if((dest == DEST_IL) && (il_socket == NULL)) il_socket = DEFAULT_SOCKET; if((dest == DEST_PROXY) && il_socket) { char store_sock[256], serve_sock[256]; sprintf(store_sock, "%s%s", il_socket, "store.sock"); sprintf(serve_sock, "%s%s", il_socket, "serve.sock"); edg_wll_SetParam(ctx, EDG_WLL_PARAM_LBPROXY_STORE_SOCK, store_sock); edg_wll_SetParam(ctx, EDG_WLL_PARAM_LBPROXY_SERVE_SOCK, serve_sock); } if (num_jobs <= 0) { fprintf(stderr,"%s: wrong number of jobs\n",argv[0]); usage(argv[0]); exit(1); } if (!filename && destname) { fprintf(stderr,"%s: -f required\n",argv[0]); usage(argv[0]); exit(1); } if (glite_wll_perftest_init(hostname, NULL, testname, filename, num_jobs) < 0) { fprintf(stderr,"%s: glite_wll_perftest_init failed\n",argv[0]); exit(1); } if(dest) { char *jobid; int len; while ((len=glite_wll_perftest_produceEventString(&event, &jobid)) > 0) { switch(dest) { case DEST_PROXY: ctx->p_tmp_timeout = ctx->p_sync_timeout; if (edg_wll_DoLogEventServer(ctx,EDG_WLL_LOGFLAG_PROXY,event)) { char *et,*ed; edg_wll_Error(ctx,&et,&ed); fprintf(stderr,"edg_wll_DoLogEventServer(): %s (%s)\n",et,ed); fprintf(stderr,"Event:\n%s\n", event); exit(1); } break; case DEST_LL: #if defined(EVENTS_USER_PRESENT) /* erase DG.USER, will be added by LL */ do { char *p = strstr(event, "DG.USER"); if(p != NULL) { char *s = strchr(p+9, '"'); if(s == NULL) { s = strstr(p+7, "DG."); if(s == NULL) { s = event + len - 1; } } else { while(*++s == ' ') ; } memmove(p, s, event + len + 1 - s); } } while(0); #endif ctx->p_tmp_timeout = ctx->p_log_timeout; if (edg_wll_DoLogEvent(ctx,event)) { char *et,*ed; edg_wll_Error(ctx,&et,&ed); fprintf(stderr,"edg_wll_DoLogEvent(): %s (%s)\n",et,ed); fprintf(stderr,"Event:\n%s\n", event); exit(1); } break; case DEST_BKSERVER: ctx->p_tmp_timeout = ctx->p_log_timeout; edg_wlc_JobIdParse(jobid, &ctx->p_jobid); if (edg_wll_DoLogEventServer(ctx,EDG_WLL_LOGFLAG_DIRECT,event)) { char *et,*ed; edg_wll_Error(ctx,&et,&ed); fprintf(stderr,"edg_wll_DoLogEventServer(): %s (%s)\n",et,ed); fprintf(stderr,"Event:\n%s\n", event); exit(1); } break; case DEST_IL: ctx->p_tmp_timeout = log_timeout; /* ctx->p_log_timeout */; if (edg_wll_DoLogEventIl(ctx, event, jobid, len, skip)) { char *et,*ed; edg_wll_Error(ctx,&et,&ed); fprintf(stderr,"edg_wll_DoLogEventIl(): %s (%s)\n",et,ed); fprintf(stderr,"Event:\n%s\n", event); exit(1); } break; case DEST_DUMP: printf("%s", event); break; default: break; } free(event); } } else { /* no destination - only print jobid's that would be used */ char *jobid; while(jobid = glite_wll_perftest_produceJobId()) { fprintf(stdout, "%s\n", jobid); } } edg_wll_FreeContext(ctx); return 0; }
double lb_statistics(std::string const& queue_id, stats_t mode, int seconds) { std::string lbserver_fqdn( glite::wms::common::configuration::Configuration::instance()->wp() ->lbserver().front() ); std::string lbserver_host; int lbserver_port = 9000; static boost::regex const regex("(.*):([[:digit:]]*).*"); boost::smatch pieces; if (boost::regex_match(lbserver_fqdn, pieces, regex)) { lbserver_host.assign(pieces[1].first, pieces[1].second); lbserver_port = boost::lexical_cast<int>( std::string().assign(pieces[2].first, pieces[2].second) ); } std::string lbserver; if (lbserver_host.empty()) { lbserver = lbserver_fqdn; } else { lbserver = lbserver_host; } edg_wll_Context ctx; edg_wll_InitContext(&ctx); edg_wll_SetParam( ctx, EDG_WLL_PARAM_QUERY_SERVER, lbserver.c_str() ); edg_wll_SetParam(ctx, EDG_WLL_PARAM_QUERY_SERVER_PORT, lbserver_port); edg_wll_QueryRec group[2]; group[0].attr = EDG_WLL_QUERY_ATTR_DESTINATION; group[0].op = EDG_WLL_QUERY_OP_EQUAL; group[0].value.c = const_cast<char*>(queue_id.c_str()); group[1].attr = EDG_WLL_QUERY_ATTR_UNDEF; time_t now(::time(0)); time_t to(now); time_t from(now - seconds); float* durations = 0; float* dispersions = 0; char** groups = 0; int from_res, to_res; if (!edg_wll_StateDurationsFromTo( ctx, group, EDG_WLL_JOB_SUBMITTED, // TODO transition SCHEDULED -> RUNNING not implemented yet, lb server side EDG_WLL_JOB_RUNNING, 0, &from, &to, &durations, &dispersions, &groups, &from_res, &to_res) ) { if (mode == avg) { return durations[0]; } else { return dispersions[0]; } } return 0.0; }
int main(int argc, char *argv[]) { char *job = NULL,*server = NULL,*seq = NULL,*filename = NULL; char buf[MAXMSGSIZE]; int lbproxy = 0, num_subjobs = 0, lbdirect = 0; int done = 0, njobs = 1,i,j; edg_wll_Context ctx; edg_wlc_JobId jobid,*subjobs; FILE *f; if (edg_wll_InitContext(&ctx) != 0) { fprintf(stderr, "Couldn't create L&B context.\n"); return 1; } opterr = 0; me = strdup(argv[0]); do { switch (getopt(argc,argv,"m:xyN:n:f:")) { case 'm': server = strdup(optarg); break; case 'x': lbproxy = 1; break; case 'y': lbdirect = 1; break; case 'N': njobs = atoi(optarg); break; case 'n': num_subjobs = atoi(optarg); break; case 'f': filename = (char *) strdup(optarg); break; case '?': usage(); exit(EINVAL); case -1: done = 1; break; } } while (!done); if (lbproxy && lbdirect) { fprintf(stderr,"%s: only one of -x or -y options may be specified \n",me); usage(); exit(1); } if (!server) { fprintf(stderr,"%s: -m required\n",me); usage(); exit(1); } if ((njobs <= 0) || (num_subjobs < 0)) { fprintf(stderr,"%s: wrong number of jobs\n",me); usage(); exit(1); } if (!filename) { fprintf(stderr,"%s: -f required\n",me); usage(); exit(1); } if ( (f = fopen(filename,"r")) == NULL) { perror(filename); exit(1); } /* MAIN LOOP */ for (i = 0; i<njobs; i++) { /* create jobid */ if (!job) { char *p = strchr(server,':'); if (p) *p=0; edg_wlc_JobIdCreate(server,p?atoi(p+1):0,&jobid); *p=':'; job = edg_wlc_JobIdUnparse(jobid); fprintf(stdout,"new jobid: %s\n",job); } else if ((errno = edg_wlc_JobIdParse(job,&jobid))) { perror(job); exit(1); } /* register */ edg_wll_SetParam(ctx,EDG_WLL_PARAM_SOURCE,EDG_WLL_SOURCE_USER_INTERFACE); // edg_wll_SetParam(ctx,EDG_WLL_PARAM_SOURCE,edg_wll_StringToSource(src)); if (lbproxy) { if (edg_wll_RegisterJobProxy(ctx,jobid, num_subjobs?EDG_WLL_REGJOB_COLLECTION:EDG_WLL_REGJOB_SIMPLE, "JDL: blabla", "NNNSSSS", num_subjobs,NULL,&subjobs)) { char *et,*ed; edg_wll_Error(ctx,&et,&ed); fprintf(stderr,"edg_wll_RegisterJobProxy(%s): %s (%s)\n",job,et,ed); exit(1); } } else { if (edg_wll_RegisterJobSync(ctx,jobid, num_subjobs?EDG_WLL_REGJOB_COLLECTION:EDG_WLL_REGJOB_SIMPLE, "JDL: blabla", "NNNSSSS", num_subjobs,NULL,&subjobs)) { char *et,*ed; edg_wll_Error(ctx,&et,&ed); fprintf(stderr,"edg_wll_RegisterJobSync(%s): %s (%s)\n",job,et,ed); exit(1); } } /* log events */ while (!feof(f)) { edg_wll_LogLine logline; if (!fgets(buf,sizeof(buf),f)) break; if (strcmp(buf,"\n")) { // fprintf(stdout,"%d: %s\n",i,buf); asprintf(&logline,"DG.JOBID=\"%s\" %s",job,buf); if (lbproxy) { if (edg_wll_DoLogEventServer(ctx,EDG_WLL_LOGFLAG_PROXY,logline)) { char *et,*ed; edg_wll_Error(ctx,&et,&ed); fprintf(stderr,"edg_wll_DoLogEventServer(): %s (%s)\n",et,ed); exit(1); } } else if (lbdirect) { if (edg_wll_DoLogEventServer(ctx,EDG_WLL_LOGFLAG_DIRECT,logline)) { char *et,*ed; edg_wll_Error(ctx,&et,&ed); fprintf(stderr,"edg_wll_DoLogEventServer(): %s (%s)\n",et,ed); exit(1); } } else { if (edg_wll_DoLogEvent(ctx,logline)) { char *et,*ed; edg_wll_Error(ctx,&et,&ed); fprintf(stderr,"edg_wll_DoLogEvent(): %s (%s)\n",et,ed); exit(1); } } if (logline) free(logline); } } rewind(f); if (job) free(job); job = NULL; /* seq. code */ seq = edg_wll_GetSequenceCode(ctx); fprintf(stdout,"\n%s=\"%s\"\n",num_subjobs?"EDG_WL_COLLECTION_JOBID":"EDG_JOBID",job); fprintf(stdout,"EDG_WL_SEQUENCE=\"%s\"\n",seq); free(seq); if (num_subjobs) for (j=0; subjobs[j]; j++) { char *job_s = edg_wlc_JobIdUnparse(subjobs[j]); fprintf(stdout,"EDG_WL_SUB_JOBID[%d]=\"%s\"\n",j,job_s); free(job_s); } } /* MAIN LOOP */ fclose(f); edg_wll_FreeContext(ctx); return 0; }
int main(int argc,char *argv[]) { edg_wll_Context ctx; edg_wll_QueryResults rslts = EDG_WLL_QUERYRES_UNDEF; edg_wll_QueryRec **jc = NULL, **ec = NULL; edg_wll_JobStat *statesOut = NULL; edg_wlc_JobId *jobsOut = NULL; edg_wll_Event *eventsOut = NULL; char *fname = NULL, *server = NULL, *proxy_sock = NULL, *s; int result = 0, jobsLimit = 0, stdisp = 0, eventsLimit = 0, resultsLimit = 0, i, j, ret, errCode, flags = 0; myname = argv[0]; ret = 0; do { switch ( getopt(argc,argv,"hvsePp:i:m:r:J:E:CSNR:") ) { case 'h': usage(); exit(0); case '?': usage(); exit(EINVAL); case 'v': verbose = 1; break; case 'i': fname = strdup(optarg); break; case 'm': server = strdup(optarg); break; case 's': stdisp = 1; break; case 'e': query_jobs = 0; break; case 'P': query_lbproxy = 1; break; case 'p': proxy_sock = strdup(optarg); break; case 'r': if ( !strcasecmp(optarg, "limited") ) rslts = EDG_WLL_QUERYRES_LIMITED; else if ( !strcasecmp(optarg, "none") ) rslts = EDG_WLL_QUERYRES_NONE; else if ( !strcasecmp(optarg, "all") ) rslts = EDG_WLL_QUERYRES_ALL; else { usage(); exit(EINVAL); } break; case 'J': jobsLimit = atoi(optarg); break; case 'E': eventsLimit = atoi(optarg); break; case 'R': resultsLimit = atoi(optarg); break; case 'S': flags = flags | EDG_WLL_STAT_CHILDSTAT; break; case 'C': flags = flags | EDG_WLL_STAT_CLASSADS; break; case 'N': flags = flags | 1024; break; //crude, I know case -1: ret = 1; break; } } while ( !ret ); if ( edg_wll_InitContext(&ctx) ) { if ( verbose ) fprintf(stderr,"%s: cannot initialize edg_wll_Context\n",myname); exit(1); } if ( jobsLimit > 0 ) { edg_wll_SetParam(ctx, EDG_WLL_PARAM_QUERY_JOBS_LIMIT, jobsLimit); if ( verbose ) printf("Soft query limit for jobs: %d\n", jobsLimit); } else if ( verbose ) printf("Soft query limit for jobs not set\n"); if ( resultsLimit > 0 ) { edg_wll_SetParam(ctx, EDG_WLL_PARAM_QUERY_RESULTS, resultsLimit); if ( verbose ) printf("Results limit for jobs: %d\n", resultsLimit); } else if ( verbose ) printf("Results limit for jobs not set\n"); if ( query_events ) { if ( eventsLimit > 0 ) { edg_wll_SetParam(ctx, EDG_WLL_PARAM_QUERY_EVENTS_LIMIT, eventsLimit); if ( verbose ) printf("Soft query limit for events: %d\n", eventsLimit); } else if ( verbose ) printf("Soft query limit for events not set\n"); } if ( rslts != EDG_WLL_QUERYRES_UNDEF ) edg_wll_SetParam(ctx, EDG_WLL_PARAM_QUERY_RESULTS, rslts); else edg_wll_GetParam(ctx, EDG_WLL_PARAM_QUERY_RESULTS, &rslts); if ( verbose ) printf("When any limit overflows, the returned result set is: %s\n", rslts==EDG_WLL_QUERYRES_LIMITED? "limited": (rslts==EDG_WLL_QUERYRES_ALL? "unlimited": "empty")); if ( server ) { char *p = strchr(server, ':'); if ( p ) { edg_wll_SetParam(ctx, EDG_WLL_PARAM_QUERY_SERVER_PORT, atoi(p+1)); *p = 0; } edg_wll_SetParam(ctx, EDG_WLL_PARAM_QUERY_SERVER, server); free(server); } if ( proxy_sock ) { edg_wll_SetParam(ctx, EDG_WLL_PARAM_LBPROXY_SERVE_SOCK, proxy_sock); free(proxy_sock); } if ( fname ) { fin = fopen(fname, "r"); if ( !fin ) { if ( verbose ) fprintf(stderr, "Can't open given input file %s. Using stdin.\n", fname); fin = stdin; } free(fname); } else { if ( verbose ) fprintf(stderr, "No input file given. Using stdin.\n"); fin = stdin; } jobsOut = NULL; statesOut = NULL; eventsOut = NULL; do { if ( verbose && (fin == stdin) ) printf("Enter job conditions:\n"); ret = cond_parse(&jc, 1); if ( ret == PQRV_ERR ) { result = 1; goto cleanup; } if ( query_events && (ret != PQRV_EOF) ) { if ( verbose && (fin == stdin) ) printf("Enter event conditions:\n"); ret = cond_parse(&ec, 0); if ( ret == PQRV_ERR ) { result = 1; goto cleanup; } } if ( (ret == PQRV_EOF) && !jc && (query_jobs || (query_events && !ec)) ) break; if ( verbose ) { printf("job conditions list: "); printconds(jc); if ( query_events ) { printf("event condition list: "); printconds(ec); } } if ( query_jobs ) { if ( query_bkserver ) errCode = edg_wll_QueryJobsExt(ctx, (const edg_wll_QueryRec **) jc, flags, &jobsOut, stdisp? &statesOut: NULL); else errCode = edg_wll_QueryJobsExtProxy(ctx, (const edg_wll_QueryRec **) jc, flags, &jobsOut, stdisp? &statesOut: NULL); } else { if ( query_bkserver ) errCode = edg_wll_QueryEventsExt(ctx, (const edg_wll_QueryRec **) jc, (const edg_wll_QueryRec **) ec, &eventsOut); else errCode = edg_wll_QueryEventsExtProxy(ctx, (const edg_wll_QueryRec **) jc, (const edg_wll_QueryRec **) ec, &eventsOut); } if ( errCode ) { dgerr(ctx, NULL); if ( (errCode != EPERM) && (errCode != E2BIG) ) goto cycle_cleanup; } else if ( verbose ) { if ( query_jobs ) printf("Matched jobs: "); else printf("Matched events: "); } if ( verbose ) { if ( (query_jobs && jobsOut && jobsOut[0]) || (query_events && eventsOut && eventsOut[0].type) ) putchar('\n'); else printf("No one matches\n"); } if ( query_jobs && jobsOut && !stdisp ) { for ( i = 0; jobsOut[i]; i++ ) { s = edg_wlc_JobIdUnparse(jobsOut[i]); printf("jobId: %s\n", edg_wlc_JobIdUnparse(jobsOut[i])); free(s); edg_wlc_JobIdFree(jobsOut[i]); } free(jobsOut); jobsOut = NULL; } if ( query_jobs && statesOut ) { if ( stdisp ) for ( i = 0; statesOut[i].state; i++ ) printstat(statesOut[i]); for ( i = 0; statesOut[i].state; i++ ) edg_wll_FreeStatus(&statesOut[i]); free(statesOut); statesOut = NULL; } if ( query_events && eventsOut ) { for ( i = 0; eventsOut[i].type; i++ ) { s = edg_wlc_JobIdUnparse(eventsOut[i].any.jobId); printf("event: %-11s (jobid %s)\n", edg_wll_EventToString(eventsOut[i].type), s); free(s); } free(eventsOut); eventsOut = NULL; } cycle_cleanup: if ( jc ) { for ( i = 0; jc[i]; i++ ) { for ( j = 0; jc[i][j].attr; j++ ) free_QueryRec(&jc[i][j]); free(jc[i]); } free(jc); } if ( ec ) { for ( i = 0; ec[i]; i++ ) { for ( j = 0; ec[i][j].attr; j++ ) free_QueryRec(&ec[i][j]); free(ec[i]); } free(ec); } } while ( ret != PQRV_EOF ); cleanup: if ( fin != stdin ) fclose(fin); edg_wll_FreeContext(ctx); return result; }