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;
}
