/*
* call-seq:
* get_option(key)
*
* key: the name of the option, as a string.
*
* Gets the value of a connection's option.
*
* Returns: the value of the given option, as a string, integer or boolean.
*/
static VALUE
rbz_connection_get_option (VALUE self, VALUE key)
{
ZOOM_connection connection;
const char *value;
connection = rbz_connection_get (self);
value = ZOOM_connection_option_get (connection,
RVAL2CSTR (key));
return zoom_option_value_to_ruby_value (value);
}
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)
{
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;
}
