From b970ae19545d3c78e62d1bce766131b12e04baa6 Mon Sep 17 00:00:00 2001 From: =?utf8?q?Milo=C5=A1=20Mula=C4=8D?= Date: Wed, 10 Nov 2004 09:33:23 +0000 Subject: [PATCH] "Fake" implementation of the consumer API. --- org.glite.lb.client/examples/consumer_fake.c | 158 +++++++++++++++++++++++++++ org.glite.lb.client/examples/job_log.c | 142 ++++++++++++++++++++++++ 2 files changed, 300 insertions(+) create mode 100644 org.glite.lb.client/examples/consumer_fake.c create mode 100644 org.glite.lb.client/examples/job_log.c diff --git a/org.glite.lb.client/examples/consumer_fake.c b/org.glite.lb.client/examples/consumer_fake.c new file mode 100644 index 0000000..fabda90 --- /dev/null +++ b/org.glite.lb.client/examples/consumer_fake.c @@ -0,0 +1,158 @@ +/* $Id: */ + +#include +#include + +#include "glite/lb/consumer.h" +#include "glite/lb/context-int.h" +#include "glite/lb/consumer_fake.h" + + +#define NUM_EVENTS 3 + + +static edg_wll_QueryEvents_cb_f *QueryEvents_cb = NULL; +static edg_wll_QueryListener_cb_f *QueryListener_cb = NULL; + + +/* register the query callback */ +int edg_wll_RegisterTestQueryEvents(edg_wll_QueryEvents_cb_f *cb) { + if (QueryEvents_cb) return 0; + + QueryEvents_cb = cb; + return 1; +} + + +/* register the listener callback */ +int edg_wll_RegisterTestQueryListener(edg_wll_QueryListener_cb_f *cb) { + if (QueryListener_cb) return 0; + + QueryListener_cb = cb; + return 1; +} + + +/* unregister the query callback */ +void edg_wll_UnregisterTestQueryEvents() { + QueryEvents_cb = NULL; +} + + +/* unregister the listener callback */ +void edg_wll_UnregisterTestQueryListener() { + QueryEvents_cb = NULL; +} + + +/* (belongs to common/src/events.c.T) */ +static void edg_wll_PrepareEvent(edg_wll_EventCode eventcode, edg_wll_Event *event) { + edg_wll_Event *tmpevent; + + // hide not clean code here :-) + tmpevent = edg_wll_InitEvent(eventcode); + memcpy(event, tmpevent, sizeof(edg_wll_Event)); + free(tmpevent); +} + + +/* fake implementation of QueryEvents() */ +int edg_wll_QueryEvents( + edg_wll_Context context, + const edg_wll_QueryRec *job_conditions, + const edg_wll_QueryRec *event_conditions, + edg_wll_Event **events +) { + edg_wll_EventCode event_code; + int i, j, err; + edg_wlc_JobId jobid; + + edg_wll_ResetError(context); + + // get asked event type or use _EVENT_CHKPT + i = 0; + while (event_conditions[i].attr != EDG_WLL_QUERY_ATTR_UNDEF && (event_conditions[i].attr != EDG_WLL_QUERY_ATTR_EVENT_TYPE || event_conditions[i].op != EDG_WLL_QUERY_OP_EQUAL)) i++; + if (event_conditions[i].attr == EDG_WLL_QUERY_ATTR_UNDEF) + event_code = EDG_WLL_EVENT_CHKPT; + else + event_code = event_conditions[i].value.i; + + // create events + *events = calloc(NUM_EVENTS + 1, sizeof(edg_wll_Event)); + for (i = 0; i < NUM_EVENTS; i++) { + edg_wll_PrepareEvent(event_code, &(*events)[i]); + } + (*events)[NUM_EVENTS].type = EDG_WLL_EVENT_UNDEF; + + // adjust events according to the query parameters + i = 0; + while (job_conditions[i].attr != EDG_WLL_QUERY_ATTR_UNDEF) { + if (job_conditions[i].attr == EDG_WLL_QUERY_ATTR_JOBID && job_conditions[i].op == EDG_WLL_QUERY_OP_EQUAL) { + jobid = job_conditions[i].value.j; + for (j = 0; j < NUM_EVENTS; j++) { + if ((err = edg_wlc_JobIdDup(jobid, &(*events)[i].any.jobId)) != 0) goto error; + } + break; + } + i++; + } + + // adjusting callback + if (QueryEvents_cb) + QueryEvents_cb(context, events); + + if ((err = edg_wll_Error(context, NULL, NULL)) == 0) return 0; + +error: + i = 0; + while ((*events)[i].type != EDG_WLL_EVENT_UNDEF) { + edg_wll_FreeEvent(&(*events)[i]); + i++; + } + free(*events); + + return edg_wll_SetError(context, err, NULL); +} + + +/* fake implementation of QueryListener() */ +int edg_wll_QueryListener( + edg_wll_Context context, + edg_wlc_JobId jobId, + const char *name, + char **host, + uint16_t *port +) { + edg_wll_ResetError(context); + + if (QueryListener_cb) return QueryListener_cb(context, host, port); + else { + *host = strdup("localhost"); + *port = 12345; + + return edg_wll_Error(context, NULL, NULL); + } +} + + +/* cut'nd pasted from consumer.c */ +int edg_wll_JobLog( + edg_wll_Context ctx, + edg_wlc_JobId job, + edg_wll_Event **eventsOut) +{ + edg_wll_QueryRec j[2], e[2]; + + memset(j,0,sizeof j); + memset(e,0,sizeof e); + + j[0].attr = EDG_WLL_QUERY_ATTR_JOBID; + j[0].op = EDG_WLL_QUERY_OP_EQUAL; + j[0].value.j = job; + + e[0].attr = EDG_WLL_QUERY_ATTR_LEVEL; + e[0].op = EDG_WLL_QUERY_OP_LESS; + e[0].value.i = ctx->p_level + 1; + + return edg_wll_QueryEvents(ctx,j,e,eventsOut); +} diff --git a/org.glite.lb.client/examples/job_log.c b/org.glite.lb.client/examples/job_log.c new file mode 100644 index 0000000..ca1c09e --- /dev/null +++ b/org.glite.lb.client/examples/job_log.c @@ -0,0 +1,142 @@ +#ident "$Header$" + +#ifndef _GNU_SOURCE +#define _GNU_SOURCE +#endif + +#include +#include +#include +#include + +#include "glite/lb/events_parse.h" +#include "glite/lb/consumer.h" +#include "glite/wmsutils/jobid/cjobid.h" +#ifdef USE_CALLBACKS + #include "glite/lb/consumer_fake.h" +#endif + +static void free_events(edg_wll_Event *); + +static void help(const char* n) +{ + fprintf(stderr,"usage: %s [-r repeat] [-d delay] \n", n); + exit(1); +} + +#ifdef USE_CALLBACKS +static int query_events_cb(edg_wll_Context context, edg_wll_Event **events) { + int i; + edg_wll_Event *event; + + i = 0; + while ((event = (*events) + i)->type != EDG_WLL_EVENT_UNDEF) { + event->any.timestamp.tv_sec = (double)rand() / RAND_MAX * 1000000000; + event->any.timestamp.tv_usec = (double)rand() / RAND_MAX * 1000000; + i++; + } + + return 0; +} +#endif + +int main(int argc,char **argv) +{ + edg_wll_Context ctx; + char *errt,*errd; + edg_wll_Event *events; + edg_wlc_JobId job; + int i,opt,delay = 1,count = 0; + + if (argc < 2) + help(argv[0]); + + while ((opt=getopt(argc,argv,"r:d:")) != -1) + switch (opt) { + case 'd': delay = atoi(optarg); break; + case 'r': count = atoi(optarg); break; + default: + help(argv[0]); + } + + edg_wll_InitContext(&ctx); + 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 ( edg_wll_JobLog(ctx,job,&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++ ) + { + 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 (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; + +err: +#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; +} + +static void free_events(edg_wll_Event *events) +{ + int i; + + if (events) { + for (i=0; events[i].type != EDG_WLL_EVENT_UNDEF; i++) edg_wll_FreeEvent(&(events[i])); + edg_wll_FreeEvent(&(events[i])); /* free last line */ + free(events); + events = NULL; + } +} -- 1.8.2.3