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: * connect(host, port=nil) * * host: hostname of the target to connect to. * * port: network port of the target to connect to. * * Establishes a network connection to the target specified by the given * arguments. If no port is given, 210 will be used. A colon in the host * string denotes the beginning of a port number. If the host string includes * a slash, the following part specifies a database for the connection. * * You can also prefix the host string with a scheme followed by a colon. * The default scheme is tcp (Z39.50 protocol). The scheme http selects SRW * over HTTP. * * This method raises an exception on error. * * Returns: self. */ static VALUE rbz_connection_connect (int argc, VALUE *argv, VALUE self) { ZOOM_connection connection; VALUE host; VALUE port; rb_scan_args (argc, argv, "11", &host, &port); connection = rbz_connection_get (self); ZOOM_connection_connect (connection, RVAL2CSTR (host), NIL_P (port) ? 0 : FIX2INT (port)); RAISE_IF_FAILED (connection); return self; }
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); }
// Ensure that client has a connection associated int client_prep_connection(struct client *cl, int operation_timeout, int session_timeout, iochan_man_t iochan_man, const struct timeval *abstime) { struct connection *co; struct session_database *sdb = client_get_database(cl); const char *zproxy = session_setting_oneval(sdb, PZ_ZPROXY); const char *url = session_setting_oneval(sdb, PZ_URL); const char *sru = session_setting_oneval(sdb, PZ_SRU); struct host *host = 0; int default_port = *sru ? 80 : 210; if (zproxy && zproxy[0] == '\0') zproxy = 0; if (!url || !*url) url = sdb->database->id; host = find_host(client_get_session(cl)->service->server->database_hosts, url, zproxy, default_port, iochan_man); yaz_log(YLOG_DEBUG, "client_prep_connection: target=%s url=%s", client_get_id(cl), url); if (!host) return 0; co = client_get_connection(cl); if (co) { assert(co->host); if (co->host == host && client_get_state(cl) == Client_Idle) { return 2; } client_incref(cl); connection_release(co); co = 0; } if (!co) { int max_connections = 0; int reuse_connections = 1; const char *v = session_setting_oneval(client_get_database(cl), PZ_MAX_CONNECTIONS); if (v && *v) max_connections = atoi(v); v = session_setting_oneval(client_get_database(cl), PZ_REUSE_CONNECTIONS); if (v && *v) reuse_connections = atoi(v); // See if someone else has an idle connection // We should look at timestamps here to select the longest-idle connection yaz_mutex_enter(host->mutex); while (1) { int num_connections = 0; for (co = host->connections; co; co = co->next) num_connections++; if (reuse_connections) { for (co = host->connections; co; co = co->next) { if (connection_is_idle(co) && (!co->client || client_get_state(co->client) == Client_Idle) && !strcmp(ZOOM_connection_option_get(co->link, "user"), session_setting_oneval(client_get_database(cl), PZ_AUTHENTICATION))) { if (zproxy == 0 && co->zproxy == 0) break; if (zproxy && co->zproxy && !strcmp(zproxy, co->zproxy)) break; } } if (co) { yaz_log(YLOG_LOG, "num_connections = %d (reusing)", num_connections); break; } } if (max_connections <= 0 || num_connections < max_connections) { yaz_log(YLOG_LOG, "num_connections = %d (new); max = %d", num_connections, max_connections); break; } yaz_log(YLOG_LOG, "num_connections = %d (waiting) max = %d", num_connections, max_connections); if (yaz_cond_wait(host->cond_ready, host->mutex, abstime)) { yaz_log(YLOG_LOG, "out of connections %s", client_get_id(cl)); client_set_state(cl, Client_Error); yaz_mutex_leave(host->mutex); return 0; } } if (co) { yaz_log(YLOG_LOG, "%p Connection reuse. state: %d", co, co->state); connection_release(co); client_set_connection(cl, co); co->client = cl; /* ensure that connection is only assigned to this client by marking the client non Idle */ client_set_state(cl, Client_Working); yaz_mutex_leave(host->mutex); co->operation_timeout = operation_timeout; co->session_timeout = session_timeout; /* tells ZOOM to reconnect if necessary. Disabled becuase the ZOOM_connection_connect flushes the task queue */ ZOOM_connection_connect(co->link, 0, 0); } else { yaz_mutex_leave(host->mutex); co = connection_create(cl, host, operation_timeout, session_timeout, iochan_man); } assert(co->host); } if (co && co->link) return 1; else return 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); }