-<Proxy *>
+<Proxy http://localhost:8004/*>
AddDefaultCharset off
Order deny,allow
Allow from all
ProxyVia Off
ProxyPass /pazpar2/search.pz2 http://localhost:8004/search.pz2
-
#include "connection.h"
#include "settings.h"
#include "relevance.h"
+#include "incref.h"
/** \brief Represents client state for a connection to one search target */
struct client {
struct show_raw *show_raw;
struct client *next; // next client in session or next in free list
ZOOM_resultset resultset;
+ YAZ_MUTEX mutex;
+ int ref_count;
};
struct show_raw {
cl->state = st;
/* no need to check for all client being non-active if this one
already is. Note that session_active_clients also LOCKS session */
+#if 0
if (!client_is_active(cl) && cl->session)
{
int no_active = session_active_clients(cl->session);
if (no_active == 0)
session_alert_watch(cl->session, SESSION_WATCH_SHOW);
}
+#endif
}
static void client_show_raw_error(struct client *cl, const char *addinfo);
ZOOM_connection link = connection_get_link(co);
ZOOM_resultset resultset = cl->resultset;
const char *error, *addinfo = 0;
-
+
if (ZOOM_connection_error(link, &error, &addinfo))
{
cl->hits = 0;
client_set_state(cl, Client_Error);
yaz_log(YLOG_WARN, "Search error %s (%s): %s",
- error, addinfo, client_get_url(cl));
+ error, addinfo, client_get_url(cl));
}
else
{
cl->record_offset = cl->startrecs;
cl->hits = ZOOM_resultset_size(resultset);
- se->total_hits += cl->hits;
+ if (se)
+ se->total_hits += cl->hits;
}
}
+void client_got_records(struct client *cl)
+{
+ if (cl->session)
+ {
+ session_alert_watch(cl->session, SESSION_WATCH_SHOW);
+ session_alert_watch(cl->session, SESSION_WATCH_RECORD);
+ }
+}
void client_record_response(struct client *cl)
{
if ((rec = ZOOM_resultset_record(resultset, offset)))
{
cl->record_offset++;
- if (ZOOM_record_error(rec, &msg, &addinfo, 0))
+ if (cl->session == 0)
+ ;
+ else if (ZOOM_record_error(rec, &msg, &addinfo, 0))
yaz_log(YLOG_WARN, "Record error %s (%s): %s (rec #%d)",
error, addinfo, client_get_url(cl),
cl->record_offset);
if (ingest_record(cl, xmlrec, cl->record_offset, nmem))
yaz_log(YLOG_WARN, "Failed to ingest from %s",
client_get_url(cl));
- else
- {
- session_alert_watch(cl->session, SESSION_WATCH_SHOW);
- session_alert_watch(cl->session, SESSION_WATCH_RECORD);
- }
}
nmem_destroy(nmem);
}
-
}
else
{
r->show_raw = 0;
r->resultset = 0;
r->next = 0;
+ r->mutex = 0;
+ yaz_mutex_create(&r->mutex);
+ r->ref_count = 1;
+
return r;
}
-void client_destroy(struct client *c)
+void client_incref(struct client *c)
{
- struct session *se = c->session;
- if (c == se->clients)
- se->clients = c->next;
- else
+ pazpar2_incref(&c->ref_count, c->mutex);
+ yaz_log(YLOG_DEBUG, "client_incref %s %d", client_get_url(c), c->ref_count);
+}
+
+int client_destroy(struct client *c)
+{
+ if (c)
{
- struct client *cc;
- for (cc = se->clients; cc && cc->next != c; cc = cc->next)
- ;
- if (cc)
- cc->next = c->next;
+ yaz_log(YLOG_DEBUG, "client_destroy %s %d",
+ client_get_url(c), c->ref_count);
+ if (!pazpar2_decref(&c->ref_count, c->mutex))
+ {
+ c->next = 0;
+ xfree(c->pquery);
+ c->pquery = 0;
+ xfree(c->cqlquery);
+ c->cqlquery = 0;
+
+ ZOOM_resultset_destroy(c->resultset);
+ yaz_mutex_destroy(&c->mutex);
+ xfree(c);
+ return 1;
+ }
}
- xfree(c->pquery);
- xfree(c->cqlquery);
-
- if (c->connection)
- connection_release(c->connection);
-
- ZOOM_resultset_destroy(c->resultset);
- xfree(c);
+ return 0;
}
void client_set_connection(struct client *cl, struct connection *con)
{
- cl->connection = con;
+ if (con)
+ {
+ assert(cl->connection == 0);
+ cl->connection = con;
+ client_incref(cl);
+ }
+ else
+ {
+ cl->connection = con;
+ client_destroy(cl);
+ }
}
void client_disconnect(struct client *cl)
return 0;
}
+
+void client_remove_from_session(struct client *c)
+{
+ struct session *se;
+ client_incref(c);
+
+ se = c->session;
+ assert(se);
+ if (se)
+ {
+ struct client **ccp = &se->clients;
+
+ while (*ccp && *ccp != c)
+ ccp = &(*ccp)->next;
+ assert(*ccp == c);
+ *ccp = c->next;
+
+ c->session = 0;
+ c->next = 0;
+ }
+ client_destroy(c);
+}
+
void client_set_session(struct client *cl, struct session *se)
{
cl->session = se;
void client_continue(struct client *cl);
struct client *client_create(void);
-void client_destroy(struct client *c);
+int client_destroy(struct client *c);
void client_set_connection(struct client *cl, struct connection *con);
void client_disconnect(struct client *cl);
const char *client_get_url(struct client *cl);
void client_set_maxrecs(struct client *cl, int v);
void client_set_startrecs(struct client *cl, int v);
-
+void client_remove_from_session(struct client *c);
+void client_incref(struct client *c);
+void client_got_records(struct client *c);
#endif
/*
}
yaz_log(YLOG_DEBUG, "Connection destroy %s", co->host->hostport);
- remove_connection_from_host(co);
if (co->client)
{
client_disconnect(co->client);
}
+
+ remove_connection_from_host(co);
xfree(co->zproxy);
xfree(co);
}
static void non_block_events(struct connection *co)
{
- struct client *cl = co->client;
+ 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);
+
+ client_incref(cl);
#if 0
yaz_log(YLOG_LOG, "ZOOM_EVENT_%s", ZOOM_get_event_str(ev));
#endif
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_url(cl));
}
+ client_destroy(cl);
+ }
+ if (got_records)
+ {
+ struct client *cl = co->client;
+ if (cl)
+ {
+ client_incref(cl);
+ client_got_records(cl);
+ client_destroy(cl);
+ }
}
}
void session_alert_watch(struct session *s, int what)
{
+ assert(s);
session_enter(s);
if (s->watchlist[what].fun)
{
client_set_session(cl, se);
}
+static void session_remove_clients(struct session *se)
+{
+ struct client *cl = se->clients;
+ while (cl)
+ {
+ struct client *cl_next = client_next_in_session(cl);
+ client_remove_from_session(cl);
+ client_destroy(cl);
+ cl = cl_next;
+ }
+ se->clients = 0;
+}
+
// Associates a set of clients with a session;
// Note: Session-databases represent databases with per-session
// setting overrides
static int select_targets(struct session *se, const char *filter)
{
- while (se->clients)
- client_destroy(se->clients);
-
+ session_remove_clients(se);
return session_grep_databases(se, filter, select_targets_callback);
}
*addinfo = 0;
session_enter(se);
+ reclist_destroy(se->reclist);
+ se->reclist = 0;
nmem_reset(se->nmem);
se->relevance = 0;
se->total_records = se->total_hits = se->total_merged = 0;
- reclist_destroy(se->reclist);
- se->reclist = 0;
se->num_termlists = 0;
live_channels = select_targets(se, filter);
if (!live_channels)
{
struct session_database *sdb;
- while (s->clients)
- client_destroy(s->clients);
+ session_remove_clients(s);
+
for (sdb = s->databases; sdb; sdb = sdb->next)
session_database_destroy(sdb);
normalize_cache_destroy(s->normalize_cache);
int ingest_record(struct client *cl, const char *rec,
int record_no, NMEM nmem)
{
- struct session_database *sdb = client_get_database(cl);
struct session *se = client_get_session(cl);
+ int ret;
+ struct session_database *sdb = client_get_database(cl);
struct conf_service *service = se->service;
xmlDoc *xdoc = normalize_record(sdb, service, rec, nmem);
xmlNode *root;
const char *mergekey_norm;
- int ret;
-
+
if (!xdoc)
return -1;
-
+
root = xmlDocGetRootElement(xdoc);
-
+
if (!check_record_filter(root, sdb))
{
yaz_log(YLOG_WARN, "Filtered out record no %d from %s", record_no,
- sdb->database->url);
+ sdb->database->url);
xmlFreeDoc(xdoc);
return -1;
}
-
+
mergekey_norm = get_mergekey(xdoc, cl, record_no, service, nmem);
if (!mergekey_norm)
{
session_enter(se);
ret = ingest_to_cluster(cl, xdoc, root, record_no, mergekey_norm);
session_leave(se);
-
+
xmlFreeDoc(xdoc);
-
return ret;
}