int main(int argc, char **argv)
{
ZOOM_connection z;
ZOOM_resultset r;
ZOOM_query q = ZOOM_query_create();
int error;
const char *errmsg, *addinfo;
int ccl_error_code, ccl_error_pos;
const char *ccl_error_string;
if (argc != 3)
{
fprintf (stderr, "usage:\n%s target cclquery\n", *argv);
fprintf (stderr, " eg. bagel.indexdata.dk/gils \"ti=utah\"\n");
exit (1);
}
if (ZOOM_query_ccl2rpn(q, argv[2],
"term t=l,r s=al\n" "ti u=4 s=pw\n",
&ccl_error_code, &ccl_error_string, &ccl_error_pos))
{
printf("CCL Error %d: %s\n", ccl_error_code, ccl_error_string);
if (ccl_error_pos >= 0)
printf("%s\n%*s^\n", argv[2], ccl_error_pos, "");
ZOOM_query_destroy(q);
}
else
{
z = ZOOM_connection_new (argv[1], 0);
if ((error = ZOOM_connection_error(z, &errmsg, &addinfo)))
{
fprintf (stderr, "Error: %s (%d) %s\n", errmsg, error, addinfo);
exit (2);
}
r = ZOOM_connection_search (z, q);
ZOOM_query_destroy(q);
if ((error = ZOOM_connection_error(z, &errmsg, &addinfo)))
fprintf (stderr, "Error: %s (%d) %s\n", errmsg, error, addinfo);
else
printf ("Result count: %ld\n", (long) ZOOM_resultset_size(r));
ZOOM_resultset_destroy (r);
ZOOM_connection_destroy (z);
}
exit (0);
}
resultSet::resultSet(connection &c, const query &q) : owner(c) {
ZOOM_connection yazc = c._getYazConnection();
rs = ZOOM_connection_search(yazc, q._getYazQuery());
int errcode;
const char *errmsg; // unused: carries same info as `errcode'
const char *addinfo;
if ((errcode = ZOOM_connection_error(yazc, &errmsg, &addinfo)) != 0) {
ZOOM_resultset_destroy(rs);
throw bib1Exception(errcode, addinfo);
}
}
int main(int argc, char **argv)
{
ZOOM_connection z;
ZOOM_options o = ZOOM_options_create ();
const char *errmsg, *addinfo;
if (argc != 4)
{
fprintf (stderr, "usage:\nzoom-ka sleepinterval target query\n");
exit(1);
}
/* async mode */
ZOOM_options_set (o, "async", "1");
z = ZOOM_connection_create(o);
while(1)
{
int i, error;
ZOOM_resultset rset;
ZOOM_connection_connect (z, argv[2], 0);
rset = ZOOM_connection_search_pqf(z, argv[3]);
while ((i = ZOOM_event(1, &z)))
{
printf ("no = %d event = %d\n", i-1,
ZOOM_connection_last_event(z));
}
if ((error = ZOOM_connection_error(z, &errmsg, &addinfo)))
{
fprintf(stderr, "%s error: %s (%d) %s\n",
ZOOM_connection_option_get(z, "host"),
errmsg, error, addinfo);
}
ZOOM_resultset_destroy(rset);
sleep(atoi(argv[1]));
}
ZOOM_connection_destroy (z);
ZOOM_options_destroy(o);
}
void connection_continue(struct connection *co)
{
int r = ZOOM_connection_exec_task(co->link);
if (!r)
{
const char *error, *addinfo;
int err;
if ((err = ZOOM_connection_error(co->link, &error, &addinfo)))
{
if (co->client)
{
yaz_log(YLOG_LOG, "Error %s from %s",
error, client_get_id(co->client));
client_set_diagnostic(co->client, err, addinfo);
client_set_state_nb(co->client, Client_Error);
}
}
}
else
{
iochan_setflags(co->iochan, ZOOM_connection_get_mask(co->link));
iochan_setfd(co->iochan, ZOOM_connection_get_socket(co->link));
}
}
int main(int argc, char **argv)
{
int i;
int no = argc-2;
ZOOM_connection z[500]; /* allow at most 500 connections */
ZOOM_scanset s[500]; /* and scan sets .. */
ZOOM_options o = ZOOM_options_create ();
if (argc < 3)
{
fprintf (stderr, "usage:\n%s target1 target2 ... targetN scan\n",
*argv);
exit (1);
}
if (no > 500)
no = 500;
/* async mode */
ZOOM_options_set (o, "async", "1");
/* connect to all */
for (i = 0; i<no; i++)
{
/* create connection - pass options (they are the same for all) */
z[i] = ZOOM_connection_create (o);
/* connect and init */
ZOOM_connection_connect (z[i], argv[1+i], 0);
}
/* scan all */
for (i = 0; i<no; i++)
{
/* set number of scan terms to be returned. */
ZOOM_connection_option_set (z[i], "number", "7");
/* and perform scan */
s[i] = ZOOM_connection_scan(z[i], argv[argc-1]);
}
/* network I/O. pass number of connections and array of connections */
while (ZOOM_event (no, z))
;
for (i = 0; i<no; i++)
{
int error;
const char *errmsg, *addinfo;
if ((error = ZOOM_connection_error(z[i], &errmsg, &addinfo)))
fprintf (stderr, "%s error: %s (%d) %s\n",
ZOOM_connection_option_get(z[i], "host"),
errmsg, error, addinfo);
else
{
int j;
printf ("%s\n", ZOOM_connection_option_get(z[i], "host"));
for (j = 0; j < (int) ZOOM_scanset_size (s[i]); j++)
{
size_t occur, len;
const char *term;
term = ZOOM_scanset_term (s[i], j, &occur, &len);
if (term)
printf ("%d %.*s %d\n", j, (int) len, term, (int) occur);
}
}
}
/* destroy and exit */
for (i = 0; i<no; i++)
{
ZOOM_scanset_destroy (s[i]);
ZOOM_connection_destroy (z[i]);
}
ZOOM_options_destroy(o);
exit (0);
}
int main(int argc, char **argv)
{
struct time_type time;
ZOOM_connection *z;
ZOOM_resultset *r;
int *elc;
struct event_line_t *els;
ZOOM_options o;
int i;
int k;
init_statics();
read_params(argc, argv, ¶meters);
z = (ZOOM_connection *) xmalloc(sizeof(*z) * parameters.concurrent);
r = (ZOOM_resultset *) xmalloc(sizeof(*r) * parameters.concurrent);
elc = (int *) xmalloc(sizeof(*elc) * parameters.concurrent * parameters.repeat);
els = (struct event_line_t *) xmalloc(
sizeof(*els) * parameters.concurrent * parameters.repeat * 10);
o = ZOOM_options_create();
/* async mode */
ZOOM_options_set (o, "async", "1");
/* get first record of result set (using piggypack) */
if (parameters.piggypack)
ZOOM_options_set (o, "count", "1");
/* set proxy */
if (strlen(parameters.proxy))
ZOOM_options_set (o, "proxy", parameters.proxy);
/* preferred record syntax */
if (0){
ZOOM_options_set (o, "preferredRecordSyntax", "usmarc");
ZOOM_options_set (o, "elementSetName", "F");
}
time_init(&time);
/* repeat loop */
for (k = 0; k < parameters.repeat; k++){
/* progress zeroing */
for (i = 0; i < 4096; i++){
parameters.progress[i] = k * 5 -1;
}
/* connect to all concurrent connections*/
for ( i = 0; i < parameters.concurrent; i++){
/* set event count to zero */
elc[k * parameters.concurrent + i] = 0;
/* create connection - pass options (they are the same for all) */
z[i] = ZOOM_connection_create(o);
/* connect and init */
ZOOM_connection_connect(z[i], parameters.host, 0);
}
/* search all */
for (i = 0; i < parameters.concurrent; i++)
r[i] = ZOOM_connection_search_pqf (z[i], parameters.query);
/* network I/O. pass number of connections and array of connections */
while ((i = ZOOM_event (parameters.concurrent, z))){
int event = ZOOM_connection_last_event(z[i-1]);
const char *errmsg;
const char *addinfo;
int error = 0;
//int progress = zoom_progress[event];
if (event == ZOOM_EVENT_SEND_DATA || event == ZOOM_EVENT_RECV_DATA)
continue;
time_stamp(&time);
/* updating events and event list */
error = ZOOM_connection_error(z[i-1] , &errmsg, &addinfo);
if (error)
parameters.progress[i] = zoom_progress[ZOOM_EVENT_UNKNOWN];
//parameters.progress[i] = zoom_progress[ZOOM_EVENT_NONE];
else if (event == ZOOM_EVENT_CONNECT)
parameters.progress[i] = zoom_progress[event];
else
//parameters.progress[i] = zoom_progress[event];
parameters.progress[i] += 1;
update_events(elc, els,
k, i-1,
time_sec(&time), time_usec(&time),
parameters.progress[i],
event, zoom_events[event],
error, errmsg);
}
/* destroy connections */
for (i = 0; i<parameters.concurrent; i++)
{
ZOOM_resultset_destroy (r[i]);
ZOOM_connection_destroy (z[i]);
}
} /* for (k = 0; k < parameters.repeat; k++) repeat loop */
/* output */
if (parameters.gnuplot){
printf("# gnuplot data and instruction file \n");
printf("# gnuplot thisfile \n");
printf("\n");
printf("set title \"Z39.50 connection plot\"\n");
printf("set xlabel \"Connection\"\n");
printf("set ylabel \"Time Seconds\"\n");
printf("set zlabel \"Progress\"\n");
printf("set ticslevel 0\n");
printf("set grid\n");
printf("set pm3d\n");
printf("splot '-' using ($1):($2):($3) t '' with points\n");
printf("\n");
printf("\n");
}
print_table_header();
print_events(elc, els, parameters.concurrent);
if (parameters.gnuplot){
printf("end\n");
printf("pause -1 \"Hit ENTER to return\"\n");
}
/* destroy data structures and exit */
xfree(z);
xfree(r);
xfree(elc);
xfree(els);
ZOOM_options_destroy(o);
exit (0);
}
int main(int argc, char **argv)
{
int i;
int no = argc-3;
ZOOM_connection z[500]; /* allow at most 500 connections */
ZOOM_resultset r[500]; /* and result sets .. */
ZOOM_query q;
ZOOM_options o;
o = ZOOM_options_create ();
if (argc < 4)
{
fprintf (stderr, "usage:\n%s target1 .. targetN query sort\n",
*argv);
exit (2);
}
if (no > 500)
no = 500;
/* function my_callback called when reading options .. */
ZOOM_options_set_callback (o, my_callback, 0);
/* get 20 (at most) records from beginning */
ZOOM_options_set (o, "count", "20");
ZOOM_options_set (o, "implementationName", "sortapp");
ZOOM_options_set (o, "preferredRecordSyntax", "usmarc");
ZOOM_options_set (o, "elementSetName", "B");
/* create query */
q = ZOOM_query_create ();
if (ZOOM_query_prefix (q, argv[argc-2]))
{
printf ("bad PQF: %s\n", argv[argc-2]);
exit (1);
}
if (ZOOM_query_sortby (q, argv[argc-1]))
{
printf ("bad sort spec: %s\n", argv[argc-1]);
exit (1);
}
/* connect - and search all */
for (i = 0; i<no; i++)
{
z[i] = ZOOM_connection_create (o);
ZOOM_connection_connect (z[i], argv[i+1], 0);
r[i] = ZOOM_connection_search (z[i], q);
}
/* network I/O */
while (ZOOM_event (no, z))
;
/* handle errors */
for (i = 0; i<no; i++)
{
int error;
const char *errmsg, *addinfo;
if ((error = ZOOM_connection_error(z[i], &errmsg, &addinfo)))
fprintf (stderr, "%s error: %s (%d) %s\n",
ZOOM_connection_option_get(z[i], "host"),
errmsg, error, addinfo);
else
{
/* OK, no major errors. Look at the result count */
int pos;
printf ("%s: %ld hits\n", ZOOM_connection_option_get(z[i], "host"),
(long) ZOOM_resultset_size(r[i]));
/* go through first 20 records at target */
for (pos = 0; pos < 20; pos++)
{
ZOOM_record rec;
const char *db, *syntax, *str;
int len;
rec = ZOOM_resultset_record (r[i], pos);
/* get database for record and record itself at pos */
db = ZOOM_record_get (rec, "database", 0);
str = ZOOM_record_get (rec, "xml", &len);
syntax = ZOOM_record_get (rec, "syntax", &len);
/* if rec is non-null, we got a record for display */
if (str)
{
printf ("%d %s %s\n", pos+1, syntax,
(db ? db : "unknown"));
if (rec)
{
if (fwrite (str, 1, len, stdout) != (size_t) len)
printf("write to stdout failed\n");
}
printf ("\n");
}
}
}
}
/* destroy stuff and exit */
ZOOM_query_destroy (q);
for (i = 0; i<no; i++)
{
ZOOM_resultset_destroy (r[i]);
ZOOM_connection_destroy (z[i]);
}
ZOOM_options_destroy(o);
exit(0);
}
static void non_block_events(struct connection *co)
{
int got_records = 0;
IOCHAN iochan = co->iochan;
ZOOM_connection link = co->link;
while (1)
{
struct client *cl = co->client;
int ev;
int r = ZOOM_event_nonblock(1, &link);
if (!r)
break;
if (!cl)
continue;
ev = ZOOM_connection_last_event(link);
#if 1
yaz_log(YLOG_DEBUG, "%p Connection ZOOM_EVENT_%s", co, ZOOM_get_event_str(ev));
#endif
switch (ev)
{
case ZOOM_EVENT_END:
{
const char *error, *addinfo;
int err;
if ((err = ZOOM_connection_error(link, &error, &addinfo)))
{
yaz_log(YLOG_LOG, "Error %s from %s",
error, client_get_id(cl));
client_set_diagnostic(cl, err, addinfo);
client_set_state(cl, Client_Error);
}
else
{
iochan_settimeout(iochan, co->session_timeout);
client_set_state(cl, Client_Idle);
}
yaz_cond_broadcast(co->host->cond_ready);
}
break;
case ZOOM_EVENT_SEND_DATA:
break;
case ZOOM_EVENT_RECV_DATA:
break;
case ZOOM_EVENT_UNKNOWN:
break;
case ZOOM_EVENT_SEND_APDU:
client_set_state(co->client, Client_Working);
iochan_settimeout(iochan, co->operation_timeout);
break;
case ZOOM_EVENT_RECV_APDU:
break;
case ZOOM_EVENT_CONNECT:
yaz_log(YLOG_LOG, "Connected to %s", client_get_id(cl));
co->state = Conn_Open;
break;
case ZOOM_EVENT_RECV_SEARCH:
client_search_response(cl);
break;
case ZOOM_EVENT_RECV_RECORD:
client_record_response(cl);
got_records = 1;
break;
default:
yaz_log(YLOG_LOG, "Unhandled event (%d) from %s",
ev, client_get_id(cl));
break;
}
}
if (got_records)
{
struct client *cl = co->client;
if (cl)
{
client_check_preferred_watch(cl);
client_got_records(cl);
}
}
}
int main(int argc, char **argv)
{
int block;
int i, j;
ZOOM_connection z;
ZOOM_resultset r[10]; /* and result sets .. */
ZOOM_options o;
o = ZOOM_options_create ();
z = ZOOM_connection_new ("localhost", 9999);
if (ZOOM_connection_error (z, 0, 0))
{
printf ("error - couldn't connect?\n");
exit (1);
}
ZOOM_connection_destroy (z);
for (block = 0; block < 3; block++)
{
switch (block)
{
case 0:
printf ("blocking - not calling ZOOM_events\n");
break;
case 1:
printf ("blocking - calling ZOOM_events\n");
break;
case 2:
printf ("non-blocking - calling ZOOM_events\n");
break;
}
if (block > 1)
ZOOM_options_set (o, "async", "1");
for (i = 0; i<10; i++)
{
char host[40];
printf ("session %2d", i);
sprintf (host, "localhost:9999/%d", i);
z = ZOOM_connection_create (o);
ZOOM_connection_connect (z, host, 0);
for (j = 0; j < 10; j++)
{
ZOOM_record recs[2];
char query[40];
ZOOM_query s = ZOOM_query_create ();
sprintf (query, "i%dr%d", i, j);
if (ZOOM_query_prefix (s, query))
{
printf ("bad PQF: %s\n", query);
exit (2);
}
ZOOM_options_set (o, "start", "0");
ZOOM_options_set (o, "count", "0");
r[j] = ZOOM_connection_search (z, s); /* non-piggy */
ZOOM_resultset_records (r[j], recs, 0, 2); /* first two */
ZOOM_resultset_records (r[j], recs, 1, 2); /* third */
ZOOM_resultset_records (r[j], recs, 0, 0); /* ignored */
if (ZOOM_resultset_size (r[j]) > 2)
{
if (!recs[0])
{
fprintf (stderr, "\nrecord missing\n");
exit (1);
}
}
ZOOM_query_destroy (s);
printf (".");
if (block > 0)
while (ZOOM_event (1, &z))
;
}
for (j = 0; j<i; j++)
ZOOM_resultset_destroy (r[j]);
ZOOM_connection_destroy (z);
for (; j < 10; j++)
ZOOM_resultset_destroy (r[j]);
printf ("10 searches, 20 presents done\n");
}
for (i = 0; i<1; i++)
{
ZOOM_query q = ZOOM_query_create ();
char host[40];
printf ("session %2d", i+10);
sprintf (host, "localhost:9999/%d", i);
z = ZOOM_connection_create (o);
ZOOM_connection_connect (z, host, 0);
for (j = 0; j < 10; j++)
{
char query[40];
sprintf (query, "i%dr%d", i, j);
ZOOM_options_set (o, "count", "0");
r[j] = ZOOM_connection_search_pqf (z, query);
printf (".");
if (block > 0)
while (ZOOM_event (1, &z))
;
}
ZOOM_connection_destroy (z);
for (j = 0; j < 10; j++)
{
ZOOM_resultset_records (r[j], 0, 0, 1);
}
for (j = 0; j < 10; j++)
ZOOM_resultset_destroy (r[j]);
ZOOM_query_destroy (q);
printf ("10 searches, 10 ignored presents done\n");
}
for (i = 0; i<1; i++)
{
char host[40];
ZOOM_scanset scan = 0;
printf ("session %2d", i);
sprintf (host, "localhost:9999/%d", i);
z = ZOOM_connection_create (o);
ZOOM_connection_connect (z, host, 0);
scan = ZOOM_connection_scan(z, "@attr 1=4 a");
if (block > 0)
while (ZOOM_event (1, &z))
;
printf (" scan size = %ld\n", (long) ZOOM_scanset_size(scan));
for (j = 0; j < (int) ZOOM_scanset_size (scan); j++)
{
int occur, len;
const char *term;
term = ZOOM_scanset_term (scan, j, &occur, &len);
if (term)
printf ("%d %.*s %d\n", j, len, term, occur);
}
ZOOM_scanset_destroy (scan);
ZOOM_connection_destroy (z);
}
}
ZOOM_options_destroy (o);
exit (0);
}