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;
}
/*
*----------------------------------------------------------------------
*
* 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)
{
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
plugin_confirm_authorization(lcas_request_t request, lcas_cred_id_t lcas_cred)
{
char *user_dn;
int ret;
edg_wll_Context ctx;
struct _edg_wll_GssPrincipal_data princ;
X509 *cert = NULL;
STACK_OF(X509) * chain = NULL;
void *cred = NULL;
struct vomsdata *voms_info = NULL;
int err;
authz_action action;
memset(&princ, 0, sizeof(princ));
lcas_log_debug(1,"\t%s-plugin: checking LB access policy\n",
modname);
if (edg_wll_InitContext(&ctx) != 0) {
lcas_log(0, "Couldn't create L&B context\n");
ret = LCAS_MOD_FAIL;
goto end;
}
if ((action = find_authz_action(request)) == ACTION_UNDEF) {
lcas_log(0, "lcas.mod-lb() error: unsupported action\n");
ret = LCAS_MOD_FAIL;
goto end;
}
user_dn = lcas_get_dn(lcas_cred);
if (user_dn == NULL) {
lcas_log(0, "lcas.mod-lb() error: user DN empty\n");
ret = LCAS_MOD_FAIL;
goto end;
}
princ.name = user_dn;
cred = lcas_get_gss_cred(lcas_cred);
if (cred == NULL) {
lcas_log(0, "lcas.mod-lb() warning: user gss credential empty\n");
#if 0
ret = LCAS_MOD_FAIL;
goto end;
#endif
}
#ifndef NO_GLOBUS_GSSAPI
if (cred) {
voms_info = VOMS_Init(NULL, NULL);
if (voms_info == NULL) {
lcas_log(0, "lcas.mod-lb() failed to initialize VOMS\n");
ret = LCAS_MOD_FAIL;
goto end;
}
ret = VOMS_RetrieveFromCred(cred, RECURSE_CHAIN, voms_info, &err);
if (ret == 1)
edg_wll_get_fqans(ctx, voms_info, &princ.fqans);
}
#endif
ret = check_authz_policy(edg_wll_get_server_policy(), &princ, action);
ret = (ret == 1) ? LCAS_MOD_SUCCESS : LCAS_MOD_FAIL;
end:
edg_wll_FreeContext(ctx);
#ifndef NO_GLOBUS_GSSAPI
if (voms_info)
VOMS_Destroy(voms_info);
#endif
if (cert)
X509_free(cert);
if (chain)
sk_X509_pop_free(chain, X509_free);
return ret;
}
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 *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) {
/* 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 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
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;
}
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;
}
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;
}
int
glite_wll_perftest_init(const char *host,
const char *user,
const char *testname,
const char *filename,
int n)
{
edg_wll_Context ctx;
if (edg_wll_InitContext(&ctx) != 0) {
fprintf(stderr, "edg_wll_InitContext() failed\n");
return(-1);
}
if(trio_asprintf(&termination_string, EDG_WLL_FORMAT_USERTAG,
PERFTEST_END_TAG_NAME, PERFTEST_END_TAG_VALUE) < 0)
return(-1);
/* set parameters */
if(user)
test_user = strdup(user);
else {
test_user = getenv("PERFTEST_USER");
if(test_user == NULL)
test_user = "******";
}
if(testname)
test_name = strdup(testname);
else {
test_name = getenv("PERFTEST_NAME");
if(test_name == NULL)
test_name = "unspecified";
}
if(host == NULL) {
host = getenv("PERFTEST_HOST");
if(host == NULL)
host = "localhost";
}
{
char *p;
p = strrchr(host, ':');
if(p)
*p = 0;
dest_host = strdup(host);
if(p) {
*p++ = ':';
dest_port = atoi(p);
} else
dest_port = GLITE_JOBID_DEFAULT_PORT;
}
/* reset event source */
cur_event = cur_job = 0;
njobs = n;
/* if we are asked to read events in, read them */
if(filename) {
int fd;
if((fd=open(filename, O_RDONLY)) < 0) {
fprintf(stderr, "glite_wll_perftest_init: Could not open event file %s: %s",
filename, strerror(errno));
return(-1);
}
if((nevents=read_events(fd)) < 0)
return(-1);
close(fd);
fprintf(stderr, "PERFTEST_JOB_SIZE=%d\n", nevents);
fprintf(stderr, "PERFTEST_NUM_JOBS=%d\n", njobs);
fprintf(stderr, "PERFTEST_NUM_SUBJOBS=%d\n", nsubjobs);
}
/* we suppose nsubjobs was filled in by read_events() */
/* generate final_jobid */
do {
glite_jobid_t jobid;
if(glite_wll_perftest_createJobId(dest_host,
dest_port,
test_user,
test_name,
n,
&jobid) != 0) {
fprintf(stderr, "produceJobId: error creating jobid\n");
return(-1);
}
if((final_jobid=edg_wlc_JobIdUnparse(jobid)) == NULL) {
fprintf(stderr, "produceJobId: error unparsing jobid\n");
return(-1);
}
glite_jobid_free(jobid);
} while(0);
/* generate jobids[0..njobs-1, 0..nsubjobs] */
jobids = calloc(njobs*(nsubjobs + 1), sizeof(char*));
if(jobids == NULL) {
fprintf(stderr, "glite_wll_perftest_init: not enough memory for job id's\n");
return(-1);
}
while (--n >= 0) {
glite_jobid_t jobid;
glite_jobid_t *subjobid;
int i;
if(glite_wll_perftest_createJobId(dest_host,
dest_port,
test_user,
test_name,
n,
&jobid) != 0) {
fprintf(stderr, "produceJobId: error creating jobid\n");
return(-1);
}
if((jobids[n*(nsubjobs+1)]=edg_wlc_JobIdUnparse(jobid)) == NULL) {
fprintf(stderr, "produceJobId: error unparsing jobid\n");
return(-1);
}
/* generate subjob ids */
if(nsubjobs > 0) {
if(edg_wll_GenerateSubjobIds(ctx, jobid, nsubjobs, test_name,
&subjobid) < 0) {
fprintf(stderr, "produceJobId: error generating subjob ids\n");
return -1;
}
}
for(i = 1; i <= nsubjobs; i++) {
if((jobids[n*(nsubjobs+1) + i] = edg_wlc_JobIdUnparse(subjobid[i-1])) == NULL) {
fprintf(stderr, "produceJobId: error unparsing jobid\n");
return(-1);
}
glite_jobid_free(subjobid[i-1]);
}
glite_jobid_free(jobid);
}
return(0);
}
int main() {
int round, retval, i, j;
char *query;
edg_wll_QueryRec **conds;
edg_wll_Context ctx;
if (edg_wll_InitContext(&ctx) != 0) {
fprintf(stderr, "Couldn't create L&B context.\n");
return 1;
}
for (round = 0; 1 ;round++) {
switch(round) {
case 0:
// Simple query
asprintf(&query,"status=running");
break;
case 1:
// ANDed query
asprintf(&query,"status=running&owner=testowner");
break;
case 2:
// ANDed and ORed query
asprintf(&query,"status=running|=submitted&jobtype<>simple");
break;
case 3:
// Bad attribute name
asprintf(&query,"sXatus=running");
break;
case 4:
// Bad attribute value
asprintf(&query,"status=ruXning");
break;
case 5:
// Query Empty
query = strdup("");
break;
case 6:
// No Operator
query = strdup("status=running&owner");
break;
case 7:
// No Operator in ORed condition
query = strdup("status=running&owner=I|You");
break;
case 8:
// No rval
query = strdup("status=running&owner=");
break;
case 9:
// Multiple operators
query = strdup("status=running=submitted");
break;
case 10:
// Empty AND section
query = strdup("status=running&");
break;
case 11:
// Empty AND section inbetween
asprintf(&query,"status=running&&owner=testowner");
break;
case 12:
// Empty OR section inbetween
asprintf(&query,"status=running|||=submitted&jobtype<>simple");
break;
case 13:
// Confused operator
asprintf(&query,"status==running");
break;
default:
goto done;
}
retval = edg_wll_ParseQueryConditions(ctx, query, &conds);
//fprintf(stderr, "%s\n", ctx->errDesc);
switch(round) {
case 0:
case 10:
assert(conds[0] != NULL);
assert(conds[0][0].attr == EDG_WLL_QUERY_ATTR_STATUS);
assert(conds[0][0].op == EDG_WLL_QUERY_OP_EQUAL);
assert(conds[0][0].value.i == EDG_WLL_JOB_RUNNING);
assert(conds[0][1].attr == EDG_WLL_QUERY_ATTR_UNDEF);
assert(conds[1] == NULL);
assert(retval == 0);
assert(ctx->errDesc == NULL);
break;
case 1:
case 11:
assert(retval == 0);
assert(conds[0] != NULL);
assert(conds[0][0].attr == EDG_WLL_QUERY_ATTR_STATUS);
assert(conds[0][0].op == EDG_WLL_QUERY_OP_EQUAL);
assert(conds[0][0].value.i == EDG_WLL_JOB_RUNNING);
assert(conds[0][1].attr == EDG_WLL_QUERY_ATTR_UNDEF);
assert(conds[1] != NULL);
assert(conds[1][0].attr == EDG_WLL_QUERY_ATTR_OWNER);
assert(conds[1][0].op == EDG_WLL_QUERY_OP_EQUAL);
assert(!strcmp(conds[1][0].value.c, "testowner"));
assert(conds[1][1].attr == EDG_WLL_QUERY_ATTR_UNDEF);
assert(conds[2] == NULL);
assert(retval == 0);
assert(ctx->errDesc == NULL);
break;
case 2:
case 12:
assert(retval == 0);
assert(conds[0] != NULL);
assert(conds[0][0].attr == EDG_WLL_QUERY_ATTR_STATUS);
assert(conds[0][0].op == EDG_WLL_QUERY_OP_EQUAL);
assert(conds[0][0].value.i == EDG_WLL_JOB_RUNNING);
assert(conds[0][1].attr == EDG_WLL_QUERY_ATTR_STATUS);
assert(conds[0][1].op == EDG_WLL_QUERY_OP_EQUAL);
assert(conds[0][1].value.i == EDG_WLL_JOB_SUBMITTED);
assert(conds[0][2].attr == EDG_WLL_QUERY_ATTR_UNDEF);
assert(conds[1] != NULL);
assert(conds[1][0].attr == EDG_WLL_QUERY_ATTR_JOB_TYPE);
assert(conds[1][0].op == EDG_WLL_QUERY_OP_UNEQUAL);
assert(conds[1][0].value.i == EDG_WLL_STAT_SIMPLE);
assert(conds[1][1].attr == EDG_WLL_QUERY_ATTR_UNDEF);
assert(conds[2] == NULL);
assert(retval == 0);
assert(ctx->errDesc == NULL);
break;
case 3:
assert(retval == EINVAL);
assert(strstr(ctx->errDesc, "Unknown argument"));
break;
case 4:
assert(retval == EINVAL);
assert(strstr(ctx->errDesc, "Unknown job state"));
break;
case 5:
assert(retval == 0);
assert(conds == NULL);
break;
case 6:
assert(retval == EINVAL);
assert(strstr(ctx->errDesc, "Missing operator in condition"));
break;
case 7:
assert(retval == EINVAL);
assert(strstr(ctx->errDesc, "Missing operator before"));
break;
case 8:
assert(retval == EINVAL);
assert(strstr(ctx->errDesc, "No value given for attribute"));
break;
case 9:
assert(retval == EINVAL);
assert(strstr(ctx->errDesc, "Unknown job state"));
break;
case 13:
assert(retval == EINVAL);
assert(strstr(ctx->errDesc, "Unknown operator"));
break;
}
edg_wll_ResetError(ctx);
free(query); query=NULL;
if (conds) {
for (j = 0; conds[j]; j++) {
for (i = 0 ; (conds[j][i].attr != EDG_WLL_QUERY_ATTR_UNDEF); i++ )
edg_wll_QueryRecFree(&conds[j][i]);
free(conds[j]);
}
free(conds); conds = NULL;
}
}
done:
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) {
/* 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;
}
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 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_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;
}