int main(int argc, char **argv)
{
ZOOM_connection z;
ZOOM_resultset r;
int error;
const char *errmsg, *addinfo, *diagset;
if (argc < 3)
{
fprintf (stderr, "usage:\n%s target query\n", *argv);
fprintf (stderr,
"Verify: asynchronous single-target client\n");
exit (1);
}
/* create connection (don't connect yet) */
z = ZOOM_connection_create(0);
/* option: set sru/get operation (only applicable if http: is used) */
ZOOM_connection_option_set (z, "sru", "post");
/* option: set async operation */
ZOOM_connection_option_set (z, "async", "1");
/* connect to target and initialize */
ZOOM_connection_connect (z, argv[1], 0);
/* search using prefix query format */
r = ZOOM_connection_search_pqf (z, argv[2]);
/* block here: only one connection */
while (ZOOM_event (1, &z))
;
/* see if any error occurred */
if ((error = ZOOM_connection_error_x(z, &errmsg, &addinfo, &diagset)))
{
fprintf (stderr, "Error: %s: %s (%d) %s\n", diagset, errmsg, error,
addinfo);
exit (2);
}
else /* OK print hit count */
printf ("Result count: %ld\n", (long) ZOOM_resultset_size(r));
ZOOM_resultset_destroy (r);
ZOOM_connection_destroy (z);
exit (0);
}
/*
* call-seq: new(options=nil)
*
* options: options for the connection, as a Hash object.
*
* Creates a new connection object, but does not establish a network connection
* immediately, allowing you to specify options before (if given). You can
* thus establish the connection using ZOOM::Connection#connect.
*
* Returns: a newly created ZOOM::Connection object.
*/
static VALUE
rbz_connection_new (int argc, VALUE *argv, VALUE self)
{
ZOOM_options options;
ZOOM_connection connection;
VALUE rb_options;
rb_scan_args (argc, argv, "01", &rb_options);
if (NIL_P (rb_options))
options = ZOOM_options_create ();
else
options = ruby_hash_to_zoom_options (rb_options);
connection = ZOOM_connection_create (options);
ZOOM_options_destroy (options);
RAISE_IF_FAILED (connection);
return rbz_connection_make (connection);
}
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);
}
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 int connection_connect(struct connection *con, iochan_man_t iochan_man)
{
struct host *host = connection_get_host(con);
ZOOM_options zoptions = ZOOM_options_create();
const char *auth;
const char *charset;
const char *sru;
const char *sru_version = 0;
struct session_database *sdb = client_get_database(con->client);
const char *apdulog = session_setting_oneval(sdb, PZ_APDULOG);
assert(con);
ZOOM_options_set(zoptions, "async", "1");
ZOOM_options_set(zoptions, "implementationName", PACKAGE_NAME);
ZOOM_options_set(zoptions, "implementationVersion", VERSION);
if ((charset = session_setting_oneval(sdb, PZ_NEGOTIATION_CHARSET)))
ZOOM_options_set(zoptions, "charset", charset);
assert(host->ipport);
if (host->proxy)
{
yaz_log(YLOG_LOG, "proxy=%s", host->ipport);
ZOOM_options_set(zoptions, "proxy", host->ipport);
}
else
{
assert(host->tproxy);
yaz_log(YLOG_LOG, "tproxy=%s", host->ipport);
ZOOM_options_set(zoptions, "tproxy", host->ipport);
}
if (apdulog && *apdulog)
ZOOM_options_set(zoptions, "apdulog", apdulog);
if ((auth = session_setting_oneval(sdb, PZ_AUTHENTICATION)))
ZOOM_options_set(zoptions, "user", auth);
if ((sru = session_setting_oneval(sdb, PZ_SRU)) && *sru)
ZOOM_options_set(zoptions, "sru", sru);
if ((sru_version = session_setting_oneval(sdb, PZ_SRU_VERSION))
&& *sru_version)
ZOOM_options_set(zoptions, "sru_version", sru_version);
if (!(con->link = ZOOM_connection_create(zoptions)))
{
yaz_log(YLOG_FATAL|YLOG_ERRNO, "Failed to create ZOOM Connection");
ZOOM_options_destroy(zoptions);
return -1;
}
if (sru && *sru)
{
char http_hostport[512];
strcpy(http_hostport, "http://");
strcat(http_hostport, host->url);
yaz_log(YLOG_LOG, "SRU connect to : %s", http_hostport);
ZOOM_connection_connect(con->link, http_hostport, 0);
}
else
{
ZOOM_connection_connect(con->link, host->url, 0);
}
con->iochan = iochan_create(-1, connection_handler, 0, "connection_socket");
con->state = Conn_Connecting;
iochan_settimeout(con->iochan, con->operation_timeout);
iochan_setdata(con->iochan, con);
iochan_add(iochan_man, con->iochan);
client_set_state(con->client, Client_Connecting);
ZOOM_options_destroy(zoptions);
return 0;
}
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);
}
