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; } }
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) { /* VARIABLES DECLARATION */ edg_wll_Context ctx; struct tm tm; time_t from,to; int i, err = 0; /* VARIABLES INITIALIZATION */ edg_wll_QueryRec cond[4]; /* [3] is terminator */ edg_wll_Event *events = NULL; edg_wll_InitContext(&ctx); if (argc != 3) usage(argv[0]); memset(&tm,0,sizeof tm); if (sscanf(argv[1],"%d-%d-%d:%d:%d:%d", &tm.tm_year, &tm.tm_mon, &tm.tm_mday, &tm.tm_hour, &tm.tm_min, &tm.tm_sec)!= 6) usage(argv[0]); tm.tm_mon--; tm.tm_year -= 1900; from = timegm(&tm); memset(&tm,0,sizeof tm); if (sscanf(argv[2],"%d-%d-%d:%d:%d:%d", &tm.tm_year, &tm.tm_mon, &tm.tm_mday, &tm.tm_hour, &tm.tm_min, &tm.tm_sec) != 6) usage(argv[0]); tm.tm_mon--; tm.tm_year -= 1900; to = timegm(&tm); memset(cond,0,sizeof cond); /* QUERY CONDITIONS INITIALIZATION: ALL JOBS DONE WITHIN TIME INTERVAL */ cond[0].attr = EDG_WLL_QUERY_ATTR_TIME; cond[0].op = EDG_WLL_QUERY_OP_WITHIN; cond[0].value.t.tv_sec = from; cond[0].value2.t.tv_sec = to; cond[1].attr = EDG_WLL_QUERY_ATTR_EVENT_TYPE; cond[1].value.i = EDG_WLL_EVENT_TRANSFER; cond[2].attr = EDG_WLL_QUERY_ATTR_SOURCE; cond[2].value.i = EDG_WLL_SOURCE_JOB_SUBMISSION; if (edg_wll_QueryEventsProxy(ctx,NULL,cond,&events)) { char *et,*ed; et = ed = NULL; edg_wll_Error(ctx,&et,&ed); fprintf(stderr,"edg_wll_QueryEventsProxy: %s, %s\n", et,ed ? ed : ""); free(et); free(ed); err = 1; goto cleanup; } // printf("JOBS TRANSFERED TO CONDOR\n"); // printf("OWNER\tJOBID\tSOURCE\tQUEUE\tTIMESTAMP\tRESULT\n"); for (i=0; events[i].type; i++) { edg_wll_Event *e = events+i; if (e->transfer.result == 2) { char *job = glite_jobid_unparse(e->any.jobId); printf("%s\t%s\t%s", e->any.user, job, ctime(&e->transfer.timestamp.tv_sec) ); free(job); } } cleanup: if (events) { for (i=0; events[i].type; i++) edg_wll_FreeEvent(events+i); free(events); events = NULL; } edg_wll_FreeContext(ctx); return err; }
/* *---------------------------------------------------------------------- * * edg_wll_log_proto_server - handle incoming data * * Returns: 0 if done properly or errno * * Calls: * * Algorithm: * *---------------------------------------------------------------------- */ int edg_wll_log_proto_server(edg_wll_GssConnection *con, struct timeval *timeout, char *name, char *prefix, int noipc, int noparse) { char *buf,*dglllid,*dguser,*jobId,*name_esc; char header[EDG_WLL_LOG_SOCKET_HEADER_LENGTH+1]; char outfilename[FILENAME_MAX]; size_t count; int count_total,size; u_int8_t size_end[4]; size_t msg_size,dglllid_size,dguser_size; int i,answer,answer_sent; int msg_sock; char *msg,*msg_begin; int filedesc,filelock_status; long filepos; int priority; long lllid; int unique; int err; edg_wll_Context context; edg_wll_Event *event; edg_wlc_JobId j; edg_wll_GssStatus gss_stat; errno = i = answer = answer_sent = size = msg_size = dglllid_size = dguser_size = count = count_total = msg_sock = filedesc = filelock_status = /* priority */ unique = err = 0; buf = dglllid = dguser = jobId = name_esc = msg = msg_begin = NULL; event = NULL; /* init */ if (edg_wll_InitContext(&context) != 0) { glite_common_log(LOG_CATEGORY_ACCESS,LOG_PRIORITY_ERROR,"edg_wll_InitContex(): error.\n"); answer = ENOMEM; goto edg_wll_log_proto_server_end; } if (edg_wll_ResetError(context) != 0) { glite_common_log(LOG_CATEGORY_ACCESS,LOG_PRIORITY_ERROR,"edg_wll_ResetError(): error.\n"); answer = ENOMEM; goto edg_wll_log_proto_server_end; } /* look for the unique unused long local-logger id (LLLID) */ lllid = 1000*getpid(); for (i=0; (i<1000)&&(!unique); i++) { struct stat statbuf; lllid += i; snprintf(confirm_sock_name, sizeof(confirm_sock_name), "/tmp/dglogd_sock_%ld", lllid); if ((filedesc = stat(confirm_sock_name,&statbuf)) == 0) { glite_common_log(LOG_CATEGORY_ACCESS,LOG_PRIORITY_WARN,"Warning: LLLID %ld already in use.\n",lllid); } else { if (errno == ENOENT) { unique = 1; } else { glite_common_log_SYS_ERROR("stat"); } } } if (!unique) { glite_common_log(LOG_CATEGORY_ACCESS,LOG_PRIORITY_ERROR,"Cannot determine the unique long local-logger id (LLLID %ld)!\n",lllid); return EAGAIN; } glite_common_log(LOG_CATEGORY_ACCESS,LOG_PRIORITY_INFO,"Long local-logger id (LLLID): %ld ... [ok]\n",lllid); /* receive socket header */ memset(header, 0, EDG_WLL_LOG_SOCKET_HEADER_LENGTH+1); if ((err = edg_wll_gss_read_full(con, header, EDG_WLL_LOG_SOCKET_HEADER_LENGTH, timeout, &count, &gss_stat)) < 0) { if (err == EDG_WLL_GSS_ERROR_EOF) { glite_common_log(LOG_CATEGORY_ACCESS,LOG_PRIORITY_WARN,"Reading socket header - no data available.\n"); answer = err; answer_sent = 1; /* i.e. do not try to send answer back */ } else { glite_common_log(LOG_CATEGORY_ACCESS,LOG_PRIORITY_WARN,"Error reading socket header.\n"); answer = handle_gss_failures(err,&gss_stat,"Error reading socket header"); } goto edg_wll_log_proto_server_end; } else { glite_common_log(LOG_CATEGORY_ACCESS,LOG_PRIORITY_DEBUG,"Reading socket header... [ok]\n"); } /* Check socket header */ header[EDG_WLL_LOG_SOCKET_HEADER_LENGTH] = '\0'; if (strncmp(header,EDG_WLL_LOG_SOCKET_HEADER,EDG_WLL_LOG_SOCKET_HEADER_LENGTH)) { /* not the proper socket header text */ glite_common_log(LOG_CATEGORY_ACCESS,LOG_PRIORITY_WARN,"edg_wll_log_proto_server(): invalid socket header\n"); glite_common_log(LOG_CATEGORY_ACCESS,LOG_PRIORITY_DEBUG,"edg_wll_log_proto_server(): read header '%s' instead of '%s'\n", header,EDG_WLL_LOG_SOCKET_HEADER); answer = EINVAL; goto edg_wll_log_proto_server_end; } else { glite_common_log(LOG_CATEGORY_ACCESS,LOG_PRIORITY_DEBUG,"Read socket header: \"%s\" [ok]\n",header); } /* XXX: obsolete count = 0; if ((err = edg_wll_gss_read_full(con, &priority, sizeof(priority), timeout, &count, &gss_stat)) < 0) { glite_common_log(LOG_CATEGORY_ACCESS,LOG_PRIORITY_WARN,"Error reading message priority.\n"); answer = handle_gss_failures(err,&gss_stat,"Error receiving message priority"); goto edg_wll_log_proto_server_end; } else { glite_common_log(LOG_CATEGORY_ACCESS,LOG_PRIORITY_DEBUG,"Read message priority: %d [ok]\n",priority); } */ /* read message size */ count = 0; if ((err = edg_wll_gss_read_full(con, size_end, 4, timeout, &count,&gss_stat)) < 0) { glite_common_log(LOG_CATEGORY_ACCESS,LOG_PRIORITY_DEBUG,"Error reading message size.\n"); answer = handle_gss_failures(err,&gss_stat,"Error reading message size"); goto edg_wll_log_proto_server_end; } else { glite_common_log(LOG_CATEGORY_ACCESS,LOG_PRIORITY_DEBUG,"Reading message size... [ok]\n"); } size = size_end[3]; size <<=8; size |= size_end[2]; size <<=8; size |= size_end[1]; size <<=8; size |= size_end[0]; if (size <= 0) { /* probably wrong size in the header or nothing to read */ glite_common_log(LOG_CATEGORY_ACCESS,LOG_PRIORITY_WARN,"edg_wll_log_proto_server(): invalid size read from socket header\n"); glite_common_log(LOG_CATEGORY_ACCESS,LOG_PRIORITY_DEBUG,"Read message size '%d' [error].\n",size); answer = EINVAL; goto edg_wll_log_proto_server_end; } else { glite_common_log(LOG_CATEGORY_ACCESS,LOG_PRIORITY_DEBUG,"Read message size: %d bytes [ok].\n",size); } /* format the DG.LLLID string */ if (asprintf(&dglllid,"DG.LLLID=%ld ",lllid) == -1) { glite_common_log_SYS_ERROR("asprintf"); glite_common_log(LOG_CATEGORY_ACCESS,LOG_PRIORITY_WARN,"edg_wll_log_proto_server(): nomem for DG.LLLID\n"); answer = ENOMEM; goto edg_wll_log_proto_server_end; } dglllid_size = strlen(dglllid); /* format the DG.USER string */ name_esc = glite_lbu_EscapeULM(name); if (asprintf(&dguser,"DG.USER=\"%s\" ",name_esc) == -1) { glite_common_log_SYS_ERROR("asprintf"); glite_common_log(LOG_CATEGORY_ACCESS,LOG_PRIORITY_WARN,"edg_wll_log_proto_server(): nomem for DG.USER\n"); answer = ENOMEM; goto edg_wll_log_proto_server_end; } dguser_size = strlen(dguser); /* allocate enough memory for all data */ msg_size = dglllid_size + dguser_size + size + 1; if ((msg = malloc(msg_size)) == NULL) { glite_common_log_SYS_ERROR("malloc"); glite_common_log(LOG_CATEGORY_ACCESS,LOG_PRIORITY_WARN,"edg_wll_log_proto_server(): out of memory for allocating message\n"); answer = ENOMEM; goto edg_wll_log_proto_server_end; } strncpy(msg,dglllid,dglllid_size); msg_begin = msg + dglllid_size; // this is the "official" beginning of the message strncpy(msg_begin,dguser,dguser_size); /* receive message */ buf = msg_begin + dguser_size; count = 0; if ((err = edg_wll_gss_read_full(con, buf, size, timeout, &count, &gss_stat)) < 0) { glite_common_log(LOG_CATEGORY_ACCESS,LOG_PRIORITY_WARN,"Error reading message from socket.\n"); answer = handle_gss_failures(err,&gss_stat,"Error reading message from socket."); goto edg_wll_log_proto_server_end; } else { glite_common_log(LOG_CATEGORY_ACCESS,LOG_PRIORITY_DEBUG,"Reading message... [ok]\n"); // glite_common_log(LOG_CATEGORY_ACCESS,LOG_PRIORITY_TRACE,"Read message: \"%s\"\n",msg); } buf[count] = '\0'; /* parse message and get jobId and priority from it */ if (!noparse && strstr(msg, "DG.TYPE=\"command\"") == NULL) { if (edg_wll_ParseEvent(context,msg_begin,&event) != 0) { glite_common_log(LOG_CATEGORY_ACCESS,LOG_PRIORITY_WARN,"edg_wll_log_proto_server(): edg_wll_ParseEvent error\n"); glite_common_log(LOG_CATEGORY_ACCESS,LOG_PRIORITY_WARN,"edg_wll_ParseEvent(): %s\n",context->errDesc); answer = edg_wll_Error(context,NULL,NULL); goto edg_wll_log_proto_server_end; } else { glite_common_log(LOG_CATEGORY_ACCESS,LOG_PRIORITY_DEBUG,"Parsing message for correctness...[ok]\n"); } jobId = edg_wlc_JobIdGetUnique(event->any.jobId); priority = event->any.priority; edg_wll_FreeEvent(event); event->any.priority = priority; glite_common_log(LOG_CATEGORY_ACCESS,LOG_PRIORITY_DEBUG,"Getting jobId from message...[ok]\n"); } else { if ((event = edg_wll_InitEvent(EDG_WLL_EVENT_UNDEF)) == NULL) { glite_common_log(LOG_CATEGORY_ACCESS,LOG_PRIORITY_WARN, "edg_wll_InitEvent(): out of memory\n"); answer = ENOMEM; goto edg_wll_log_proto_server_end; } jobId = edg_wll_GetJobId(msg); if (!jobId || edg_wlc_JobIdParse(jobId,&j)) { glite_common_log(LOG_CATEGORY_ACCESS,LOG_PRIORITY_WARN,"Error getting jobId from message.\n"); glite_common_log(LOG_CATEGORY_ACCESS,LOG_PRIORITY_WARN,"edg_wlc_JobIdParse(%s)\n",jobId?jobId:"NULL"); answer = EINVAL; goto edg_wll_log_proto_server_end; } else { glite_common_log(LOG_CATEGORY_ACCESS,LOG_PRIORITY_DEBUG,"Getting jobId from message...[ok]\n"); } free(jobId); jobId = edg_wlc_JobIdGetUnique(j); edg_wlc_JobIdFree(j); /* TODO: get the priority from message some better way */ if (strstr(msg, "DG.PRIORITY=1") != NULL) event->any.priority = 1; else event->any.priority = 0; } if (event->any.priority & (EDG_WLL_LOGFLAG_SYNC|EDG_WLL_LOGFLAG_SYNC_COMPAT)) { if(init_confirmation() < 0) { glite_common_log(LOG_CATEGORY_ACCESS,LOG_PRIORITY_WARN,"Error initializing 2nd UNIX socket (%s) for priority messages confirmation.\n",confirm_sock_name); answer = errno; goto edg_wll_log_proto_server_end; } else { glite_common_log(LOG_CATEGORY_ACCESS,LOG_PRIORITY_DEBUG,"Initializing 2nd UNIX socket (%s) for priority messages confirmation...[ok]\n",confirm_sock_name); } } /* if not command, save message to file */ if(strstr(msg, "DG.TYPE=\"command\"") == NULL) { /* compose the name of the log file */ count = strlen(prefix); strncpy(outfilename,prefix,count); count_total=count; strncpy(outfilename+count_total,".",1); count_total+=1; count=strlen(jobId); strncpy(outfilename+count_total,jobId,count); count_total+=count; outfilename[count_total]='\0'; // glite_common_log(LOG_CATEGORY_ACCESS,LOG_PRIORITY_DEBUG,"Composing filename from prefix \"%s\" and unique jobId \"%s\"...[ok]",prefix,jobId); /* fopen and properly handle the filelock */ #ifdef LOGD_NOFILE glite_common_log(LOG_CATEGORY_ACCESS,LOG_PRIORITY_INFO,"NOT writing message to \"%s\".\n",outfilename); filepos = 0; #else if ( edg_wll_log_event_write(context, outfilename, msg, FCNTL_ATTEMPTS, FCNTL_TIMEOUT, &filepos) ) { char *errd; // FIXME: there is probably not a correct errno glite_common_log_SYS_ERROR("edg_wll_log_event_write"); answer = edg_wll_Error(context, NULL, &errd); glite_common_log(LOG_CATEGORY_ACCESS,LOG_PRIORITY_WARN,"edg_wll_log_event_write error: %s\n",errd); free(errd); goto edg_wll_log_proto_server_end; } else glite_common_log(LOG_CATEGORY_ACCESS,LOG_PRIORITY_INFO,"Writing message to \"%s\"... [ok]",outfilename); #endif } else { filepos = 0; } #ifdef LB_PERF glite_common_log(LOG_CATEGORY_ACCESS,LOG_PRIORITY_INFO,"Calling perftest\n"); glite_wll_perftest_consumeEventString(msg); glite_common_log(LOG_CATEGORY_ACCESS,LOG_PRIORITY_INFO,"Calling perftest... [done]\n"); #endif /* if not priority send now the answer back to client */ if (!(event->any.priority & (EDG_WLL_LOGFLAG_SYNC|EDG_WLL_LOGFLAG_SYNC_COMPAT))) { if (!send_answer_back(con,answer,timeout)) { answer_sent = 1; } } /* send message via IPC (UNIX socket) */ if (!noipc) { if ( edg_wll_log_event_send(context, socket_path, filepos, msg, msg_size, CONNECT_ATTEMPTS, timeout) ) { char *errd; // XXX: probably not a SYSTEM ERROR // glite_common_log_SYS_ERROR("edg_wll_log_event_send"); answer = edg_wll_Error(context, NULL, &errd); glite_common_log(LOG_CATEGORY_ACCESS,LOG_PRIORITY_WARN,"edg_wll_log_event_send error: %s\n",errd); free(errd); goto edg_wll_log_proto_server_end_1; } else glite_common_log(LOG_CATEGORY_ACCESS,LOG_PRIORITY_DEBUG, "Sending via IPC (UNIX socket \"%s\")\n\t" "the message position %ld (%ld bytes)... [ok]", socket_path, filepos, sizeof(filepos)); } else { glite_common_log(LOG_CATEGORY_ACCESS,LOG_PRIORITY_DEBUG,"NOT sending via IPC.\n"); } if (event->any.priority & (EDG_WLL_LOGFLAG_SYNC|EDG_WLL_LOGFLAG_SYNC_COMPAT)) { if ((count = wait_for_confirmation(timeout, &answer)) < 0) { glite_common_log(LOG_CATEGORY_ACCESS,LOG_PRIORITY_WARN,"Error waiting for confirmation.\n"); answer = errno; } else { glite_common_log(LOG_CATEGORY_ACCESS,LOG_PRIORITY_DEBUG,"Waiting for confirmation... [ok].\n"); if (count == 0) { glite_common_log(LOG_CATEGORY_ACCESS,LOG_PRIORITY_DEBUG,"Waking up, timeout expired.\n"); answer = EAGAIN; } else { glite_common_log(LOG_CATEGORY_ACCESS,LOG_PRIORITY_DEBUG,"Confirmation received, waking up.\n"); } } } edg_wll_log_proto_server_end: /* if not sent already, send the answer back to client */ if (!answer_sent) { answer = send_answer_back(con,answer,timeout); } /* clean */ edg_wll_FreeContext(context); if (name_esc) free(name_esc); if (dglllid) free(dglllid); if (dguser) free(dguser); if (jobId) free(jobId); if (msg) free(msg); if (event) free(event); // glite_common_log(LOG_CATEGORY_ACCESS,LOG_PRIORITY_INFO,"Done.\n"); return answer; edg_wll_log_proto_server_end_1: if (event->any.priority) { close(confirm_sock); unlink(confirm_sock_name); } goto edg_wll_log_proto_server_end; }
int main(int argc,char **argv) { /* VARIABLES DECLARATION */ edg_wll_Context ctx; struct tm tm; time_t from,to; int i, err = 0; /* VARIABLES INITIALIZATION */ edg_wll_QueryRec cond[3]; /* [2] is terminator */ edg_wll_Event *events = NULL; edg_wll_InitContext(&ctx); if (argc != 3) usage(argv[0]); memset(&tm,0,sizeof tm); if (sscanf(argv[1],"%d-%d-%d:%d:%d:%d", &tm.tm_year, &tm.tm_mon, &tm.tm_mday, &tm.tm_hour, &tm.tm_min, &tm.tm_sec)!= 6) usage(argv[0]); tm.tm_mon--; tm.tm_year -= 1900; from = timegm(&tm); memset(&tm,0,sizeof tm); if (sscanf(argv[2],"%d-%d-%d:%d:%d:%d", &tm.tm_year, &tm.tm_mon, &tm.tm_mday, &tm.tm_hour, &tm.tm_min, &tm.tm_sec) != 6) usage(argv[0]); tm.tm_mon--; tm.tm_year -= 1900; to = timegm(&tm); memset(cond,0,sizeof cond); /* QUERY CONDITIONS INITIALIZATION: ALL JOBS DONE WITHIN TIME INTERVAL */ cond[0].attr = EDG_WLL_QUERY_ATTR_TIME; cond[0].op = EDG_WLL_QUERY_OP_WITHIN; cond[0].value.t.tv_sec = from; cond[0].value2.t.tv_sec = to; cond[1].attr = EDG_WLL_QUERY_ATTR_EVENT_TYPE; cond[1].value.i = EDG_WLL_EVENT_DONE; if (edg_wll_QueryEventsProxy(ctx,NULL,cond,&events)) { char *et,*ed; et = ed = NULL; edg_wll_Error(ctx,&et,&ed); fprintf(stderr,"edg_wll_QueryEventsProxy: %s, %s\n", et,ed ? ed : ""); free(et); free(ed); err = 1; goto cleanup; } /* SELECTION OF DONE FAILED-OR-OK JOBS */ // printf("SELECTION OF DONE JOBS\n"); // printf("OWNER\tJOBID\tEXITCODE\tTIMESTAMP\tFAILUREREASON\n"); for (i=0; events[i].type; i++) { edg_wll_Event *e = events+i; if(e->done.status_code == EDG_WLL_DONE_OK) { char *job = glite_jobid_unparse(e->any.jobId); printf("%s\t%s\t%s", e->any.user, job, ctime(&e->done.timestamp.tv_sec) //asctime(gmtime(&e->done.timestamp.tv_sec)) ); free(job); } /* if (e->done.status_code == EDG_WLL_DONE_FAILED) { char *job = glite_jobid_unparse(e->any.jobId); printf("%s\t%s\t%d\t%s\t%s\n", e->any.user, job, e->done.status_code, ctime(&e->done.timestamp.tv_sec), e->done.reason ); free(job); } else if(e->done.status_code == EDG_WLL_DONE_OK) { char *job = glite_jobid_unparse(e->any.jobId); printf("%s\t%s\t%d\t%s\tNULL\n", e->any.user, job, e->done.status_code, ctime(&e->done.timestamp.tv_sec) ); free(job);}*/ } cleanup: if (events) { for (i=0; events[i].type; i++) edg_wll_FreeEvent(events+i); free(events); events = NULL; } edg_wll_FreeContext(ctx); return err; }
int event_queue_send(struct event_queue *eq) { OutputPlugin *output = (OutputPlugin*)eq->plugin_data; edg_wll_Context context; edg_wll_Event *notif_event; edg_wll_JobStat *state_out; il_octet_string_t event; char *jobstat_char; int ret; assert(output != NULL); edg_wll_InitContext(&context); while(!event_queue_empty(eq)) { struct server_msg *msg; cms::TextMessage *cms_msg; char *s; unsigned int i; std::string val; if(event_queue_get(eq, &msg) < 0) { goto err; } try { if(decode_il_msg(&event, msg->msg) < 0) { set_error(IL_LBAPI, EINVAL, "event_queue_send: error parsing notification event data"); goto err; } ret=edg_wll_ParseNotifEvent(context, event.data, ¬if_event); if(ret) { set_error(IL_LBAPI, ret, "event_queue_send: error parsing notification event"); goto err; } jobstat_char = glite_lbu_UnescapeXML((const char *) notif_event->notification.jobstat); if (jobstat_char == NULL) { set_error(IL_LBAPI, EINVAL, "event_queue_send: error unescaping job status"); goto err; } if ( edg_wll_ParseJobStat(context, jobstat_char, strlen(jobstat_char), state_out)) { set_error(IL_LBAPI, EINVAL, "event_queue_send: error parsing job status"); goto err; } cms_msg = output->session->createTextMessage(); /* ownerDn */ val.assign(state_out->owner); cms_msg->setStringProperty("ownerDn", val); /* voname */ s = edg_wll_JDLField(state_out,"VirtualOrganisation"); val.assign(s); free(s); cms_msg->setStringProperty("voname", val); /* bkHost */ glite_jobid_getServerParts(state_out->jobId, &s, &i); val.assign(s); free(s); cms_msg->setStringProperty("bkHost", val); /* networkServer */ /* TODO: XXX cut out hostname */ val.assign(state_out->network_server); cms_msg->setStringProperty("networkHost", val); timeval2str(&state_out->lastUpdateTime, &s); val.assign(s); if(s) free(s); cms_msg->setStringProperty("lastUpdateTime", val); /* stateName */ s = edg_wll_StatToString(state_out->state); val.assign(s); if(s) free(s); cms_msg->setStringProperty("stateName", val); timeval2str(&state_out->stateEnterTime, &s); val.assign(s); if(s) free(s); cms_msg->setStringProperty("stateStartTime", val); /* condorId */ val.assign(state_out->condorId); cms_msg->setStringProperty("condorId", val); /* destSite */ val.assign(state_out->destination); cms_msg->setStringProperty("destSite", val); /* exitCode */ cms_msg->setIntProperty("exitCode", state_out->exit_code); /* doneCode */ cms_msg->setIntProperty("doneCode", state_out->done_code); /* statusReason */ val.assign(state_out->reason); cms_msg->setStringProperty("statusReason", val); free(event.data); edg_wll_FreeEvent(notif_event); free(notif_event); edg_wll_FreeStatus(state_out); free(state_out); free(jobstat_char); } catch(cms::CMSException &e) { goto err; } try { output->send(cms_msg); delete cms_msg; if(event_store_commit(msg->es, msg->ev_len, queue_list_is_log(eq), msg->generation) < 0) { /* failure committing message, this is bad */ goto err; } event_queue_remove(eq); eq->first_event_sent = 1; } catch(cms::CMSException &e) { delete cms_msg; output->cleanup(); eq->timeout = TIMEOUT; edg_wll_FreeContext(context); return 0; } } edg_wll_FreeContext(context); return 1; err: if(event.data) { free(event.data); } if(notif_event) { edg_wll_FreeEvent(notif_event); free(notif_event); } if(jobstat_char) { free(jobstat_char); } if(state_out) { edg_wll_FreeStatus(state_out); free(state_out); } return -1; }
int event_queue_send(struct event_queue *eq, struct queue_thread *me) { OutputPlugin *output = (OutputPlugin*)eq->plugin_data; edg_wll_Context context; edg_wll_Event *notif_event; edg_wll_JobStat state_out; il_octet_string_t event; char *jobstat_char; int ret; assert(output != NULL); edg_wll_InitContext(&context); while(!event_queue_empty(eq)) { struct server_msg *msg; cms::Message *cms_msg = NULL; if(event_queue_get(eq, me, &msg) == 0) { break; } if(0 == msg->len) { glite_common_log(IL_LOG_CATEGORY, LOG_PRIORITY_DEBUG, " not sending empty message at offset %ld for job %s", msg->offset, msg->job_id_s); if(event_store_commit(msg->es, msg->ev_len, 0, msg->generation) < 0) { /* failure committing message, this is bad */ goto err; } event_queue_remove(eq, me); continue; } glite_common_log(IL_LOG_CATEGORY, LOG_PRIORITY_DEBUG, " trying to deliver event at offset %ld for job %s", msg->offset, msg->job_id_s); if(decode_il_msg(&event, msg->msg + 17) < 0) { set_error(IL_LBAPI, EINVAL, "event_queue_send: error parsing notification event data"); goto err; } ret=edg_wll_ParseNotifEvent(context, event.data, ¬if_event); if(ret) { set_error(IL_LBAPI, ret, "event_queue_send: error parsing notification event"); goto err; } jobstat_char = glite_lbu_UnescapeXML((const char *) notif_event->notification.jobstat); if (jobstat_char == NULL) { set_error(IL_LBAPI, EINVAL, "event_queue_send: error unescaping job status"); goto err; } if ( edg_wll_ParseJobStat(context, jobstat_char, strlen(jobstat_char), &state_out)) { set_error(IL_LBAPI, EINVAL, "event_queue_send: error parsing job status"); fprintf(stderr, "Status string: %s\n", jobstat_char); goto err; } try { cms_msg = output->createMessage(state_out); free(event.data); event.data = NULL; edg_wll_FreeEvent(notif_event); free(notif_event); notif_event = NULL; edg_wll_FreeStatus(&state_out); free(jobstat_char); jobstat_char = NULL; output->send(cms_msg); delete cms_msg; if(event_store_commit(msg->es, msg->ev_len, 0, msg->generation) < 0) { /* failure committing message, this is bad */ goto err; } glite_common_log(IL_LOG_CATEGORY, LOG_PRIORITY_DEBUG, " event sent to %s", eq->dest_name); } catch(cms::CMSException &e) { if(cms_msg) { delete cms_msg; } me->timeout = TIMEOUT; edg_wll_FreeContext(context); set_error(IL_DL, 0, e.what()); return 0; } event_queue_remove(eq, me); me->first_event_sent = 1; eq->last_sent = time(NULL); } edg_wll_FreeContext(context); return 1; err: if(event.data) { free(event.data); } if(notif_event) { edg_wll_FreeEvent(notif_event); free(notif_event); } if(jobstat_char) { free(jobstat_char); } edg_wll_FreeStatus(&state_out); return -1; }
static int dump_events(edg_wll_Context ctx, glite_jobid_const_t job, int dump, char **res) { edg_wll_Event e; int event; event = atoi(res[0]); free(res[0]); res[0] = NULL; res[0] = edg_wlc_JobIdUnparse(job); if (convert_event_head(ctx,res,&e) || edg_wll_get_event_flesh(ctx,event,&e)) { char *et,*ed, *dbjob; /* Most likely sort of internal inconsistency. * Must not be fatal -- just complain */ edg_wll_Error(ctx,&et,&ed); dbjob = edg_wlc_JobIdGetUnique(job); glite_common_log(LOG_CATEGORY_CONTROL, LOG_PRIORITY_WARN, "%s event %d: %s (%s)", dbjob, event, et, ed); free(et); free(ed); free(dbjob); edg_wll_ResetError(ctx); } else { char *event_s = edg_wll_UnparseEvent(ctx,&e); char arr_s[100]; int len, written, total; strcpy(arr_s, "DG.ARRIVED="); edg_wll_ULMTimevalToDate(e.any.arrived.tv_sec, e.any.arrived.tv_usec, arr_s+strlen("DG.ARRIVED=")); len = strlen(arr_s); total = 0; while (total != len) { written = write(dump,arr_s+total,len-total); if (written < 0 && errno != EAGAIN) { edg_wll_SetError(ctx,errno,"writing dump file"); free(event_s); return edg_wll_Error(ctx,NULL,NULL); } total += written; } write(dump, " ", 1); len = strlen(event_s); total = 0; while (total != len) { written = write(dump,event_s+total,len-total); if (written < 0 && errno != EAGAIN) { glite_common_log(LOG_CATEGORY_CONTROL, LOG_PRIORITY_ERROR, "dump to file"); dump = -1; /* XXX: likely to be a permanent error * give up writing but do purge */ break; } total += written; } /* write(dump,"\n",1); edg_wll_UnparseEvent does so */ free(event_s); } edg_wll_FreeEvent(&e); return edg_wll_Error(ctx,NULL,NULL); }
int main(int argc,char **argv) { edg_wll_Context ctx; struct tm tm; time_t from,to; int i, err = 0; edg_wll_QueryRec cond[3],jcond[2]; /* [2] is terminator */ edg_wll_Event *events = NULL; if (edg_wll_InitContext(&ctx) != 0) { fprintf(stderr, "Couldn't create L&B context.\n"); return 1; } if (argc != 3) usage(argv[0]); memset(&tm,0,sizeof tm); if (sscanf(argv[1],"%d-%d-%d:%d:%d", &tm.tm_year, &tm.tm_mon, &tm.tm_mday, &tm.tm_hour, &tm.tm_min) != 5) usage(argv[0]); tm.tm_mon--; tm.tm_year -= 1900; from = mktime(&tm); if (sscanf(argv[2],"%d-%d-%d:%d:%d", &tm.tm_year, &tm.tm_mon, &tm.tm_mday, &tm.tm_hour, &tm.tm_min) != 5) usage(argv[0]); tm.tm_mon--; tm.tm_year -= 1900; to = mktime(&tm); memset(jcond,0,sizeof jcond); jcond[0].attr = EDG_WLL_QUERY_ATTR_OWNER; jcond[0].op = EDG_WLL_QUERY_OP_UNEQUAL; jcond[0].value.c = "nonexistent"; memset(cond,0,sizeof cond); cond[0].attr = EDG_WLL_QUERY_ATTR_TIME; cond[0].op = EDG_WLL_QUERY_OP_WITHIN; cond[0].value.t.tv_sec = from; cond[0].value2.t.tv_sec = to; cond[1].attr = EDG_WLL_QUERY_ATTR_EVENT_TYPE; cond[1].value.i = EDG_WLL_EVENT_DONE; if (edg_wll_QueryEvents(ctx,jcond,cond,&events)) { char *et,*ed; et = ed = NULL; edg_wll_Error(ctx,&et,&ed); fprintf(stderr,"edg_wll_QueryEventsProxy: %s, %s\n", et,ed ? ed : ""); free(et); free(ed); err = 1; goto cleanup; } for (i=0; events[i].type; i++) { edg_wll_Event *e = events+i; if (e->done.status_code == EDG_WLL_DONE_FAILED) { char *job = glite_jobid_unparse(e->any.jobId); printf("%s\t%s\t%s\t%s\n", job, ctime(&e->done.timestamp.tv_sec), e->done.host, e->done.reason ); free(job); } } cleanup: if (events) { for (i=0; events[i].type; i++) edg_wll_FreeEvent(events+i); free(events); events = NULL; } edg_wll_FreeContext(ctx); return err; }