#include <config.h>
#endif
+#include <time.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <yaz/timing.h>
#endif
+#include "ppmutex.h"
#include "parameters.h"
#include "session.h"
#include "eventl.h"
0 // debug_mode
};
+struct client_list {
+ struct client *client;
+ struct client_list *next;
+};
+
static void log_xml_doc(xmlDoc *doc)
{
FILE *lf = yaz_log_file();
static void session_enter(struct session *s)
{
- yaz_mutex_enter(s->mutex);
+ yaz_mutex_enter(s->session_mutex);
}
static void session_leave(struct session *s)
{
- yaz_mutex_leave(s->mutex);
+ yaz_mutex_leave(s->session_mutex);
}
// Recursively traverse query structure to extract terms.
}
}
sdb->map = normalize_cache_get(se->normalize_cache,
- se->service, s);
+ se->service->server->config, s);
if (!sdb->map)
return -1;
}
session_watchfun fun, void *data,
struct http_channel *chan)
{
+ int ret;
+ session_enter(s);
if (s->watchlist[what].fun)
- return -1;
- s->watchlist[what].fun = fun;
- s->watchlist[what].data = data;
- s->watchlist[what].obs = http_add_observer(chan, &s->watchlist[what],
- session_watch_cancel);
+ ret = -1;
+ else
+ {
+
+ s->watchlist[what].fun = fun;
+ s->watchlist[what].data = data;
+ s->watchlist[what].obs = http_add_observer(chan, &s->watchlist[what],
+ session_watch_cancel);
+ ret = 0;
+ }
+ session_leave(s);
return 0;
}
void session_alert_watch(struct session *s, int what)
{
+ assert(s);
+ session_enter(s);
if (s->watchlist[what].fun)
{
/* our watch is no longer associated with http_channel */
s->watchlist[what].data = 0;
s->watchlist[what].obs = 0;
+ session_leave(s);
fun(data);
}
+ else
+ session_leave(s);
}
//callback for grep_databases
{
struct session *se = (struct session*) context;
struct client *cl = client_create();
+ struct client_list *l;
client_set_database(cl, db);
+
client_set_session(cl, se);
+ l = xmalloc(sizeof(*l));
+ l->client = cl;
+ l->next = se->clients;
+ se->clients = l;
+}
+
+static void session_remove_clients(struct session *se)
+{
+ struct client_list *l;
+
+ session_enter(se);
+ l = se->clients;
+ se->clients = 0;
+ session_leave(se);
+
+ while (l)
+ {
+ struct client_list *l_next = l->next;
+ client_lock(l->client);
+ client_set_session(l->client, 0);
+ client_set_database(l->client, 0);
+ client_unlock(l->client);
+ client_destroy(l->client);
+ xfree(l);
+ l = l_next;
+ }
}
// Associates a set of clients with a session;
// setting overrides
static int select_targets(struct session *se, const char *filter)
{
- while (se->clients)
- client_destroy(se->clients);
-
return session_grep_databases(se, filter, select_targets_callback);
}
int session_active_clients(struct session *s)
{
- struct client *c;
+ struct client_list *l;
int res = 0;
- for (c = s->clients; c; c = client_next_in_session(c))
- if (client_is_active(c))
+ for (l = s->clients; l; l = l->next)
+ if (client_is_active(l->client))
res++;
return res;
int live_channels = 0;
int no_working = 0;
int no_failed = 0;
- struct client *cl;
+ struct client_list *l;
+ struct timeval tval;
yaz_log(YLOG_DEBUG, "Search");
*addinfo = 0;
+
+ session_remove_clients(se);
session_enter(se);
- nmem_reset(se->nmem);
- se->relevance = 0;
- se->total_records = se->total_hits = se->total_merged = 0;
reclist_destroy(se->reclist);
se->reclist = 0;
+ relevance_destroy(&se->relevance);
+ nmem_reset(se->nmem);
+ se->total_records = se->total_hits = se->total_merged = 0;
se->num_termlists = 0;
live_channels = select_targets(se, filter);
if (!live_channels)
}
se->reclist = reclist_create(se->nmem);
- for (cl = se->clients; cl; cl = client_next_in_session(cl))
+ gettimeofday(&tval, 0);
+
+ tval.tv_sec += 5;
+
+ for (l = se->clients; l; l = l->next)
{
+ struct client *cl = l->client;
+
if (maxrecs)
client_set_maxrecs(cl, atoi(maxrecs));
if (startrecs)
client_set_startrecs(cl, atoi(startrecs));
if (prepare_session_database(se, client_get_database(cl)) < 0)
- continue;
- // Parse query for target
- if (client_parse_query(cl, query) < 0)
+ ;
+ else if (client_parse_query(cl, query) < 0)
no_failed++;
else
{
no_working++;
if (client_prep_connection(cl, se->service->z3950_operation_timeout,
se->service->z3950_session_timeout,
- se->service->server->iochan_man))
+ se->service->server->iochan_man,
+ &tval))
client_start_search(cl);
}
}
}
}
-void destroy_session(struct session *s)
+void destroy_session(struct session *se)
{
struct session_database *sdb;
- while (s->clients)
- client_destroy(s->clients);
- for (sdb = s->databases; sdb; sdb = sdb->next)
+ yaz_log(YLOG_DEBUG, "%p Pazpar2 session destroy", se);
+ session_remove_clients(se);
+
+ for (sdb = se->databases; sdb; sdb = sdb->next)
session_database_destroy(sdb);
- normalize_cache_destroy(s->normalize_cache);
- reclist_destroy(s->reclist);
- nmem_destroy(s->nmem);
- service_destroy(s->service);
- yaz_mutex_destroy(&s->mutex);
- wrbuf_destroy(s->wrbuf);
+ normalize_cache_destroy(se->normalize_cache);
+ relevance_destroy(&se->relevance);
+ reclist_destroy(se->reclist);
+ nmem_destroy(se->nmem);
+ service_destroy(se->service);
+ yaz_mutex_destroy(&se->session_mutex);
+ wrbuf_destroy(se->wrbuf);
}
-struct session *new_session(NMEM nmem, struct conf_service *service)
+struct session *new_session(NMEM nmem, struct conf_service *service,
+ const char *name)
{
int i;
struct session *session = nmem_malloc(nmem, sizeof(*session));
- yaz_log(YLOG_DEBUG, "New Pazpar2 session");
+ yaz_log(YLOG_DEBUG, "%p New Pazpar2 session", session);
session->service = service;
session->relevance = 0;
session->watchlist[i].fun = 0;
}
session->normalize_cache = normalize_cache_create();
- session->mutex = 0;
- yaz_mutex_create(&session->mutex);
+ session->session_mutex = 0;
+ pazpar2_mutex_create(&session->session_mutex, name);
return session;
}
struct hitsbytarget *hitsbytarget(struct session *se, int *count, NMEM nmem)
{
struct hitsbytarget *res = 0;
- struct client *cl;
+ struct client_list *l;
size_t sz = 0;
session_enter(se);
- for (cl = se->clients; cl; cl = client_next_in_session(cl))
+ for (l = se->clients; l; l = l->next)
sz++;
res = nmem_malloc(nmem, sizeof(*res) * sz);
*count = 0;
- for (cl = se->clients; cl; cl = client_next_in_session(cl))
+ for (l = se->clients; l; l = l->next)
{
+ struct client *cl = l->client;
WRBUF w = wrbuf_alloc();
const char *name = session_setting_oneval(client_get_database(cl),
PZ_NAME);
return res;
}
-struct termlist_score **termlist(struct session *s, const char *name, int *num)
+struct termlist_score **termlist(struct session *se, const char *name, int *num)
{
int i;
struct termlist_score **tl = 0;
- session_enter(s);
- for (i = 0; i < s->num_termlists; i++)
- if (!strcmp((const char *) s->termlists[i].name, name))
+ session_enter(se);
+ for (i = 0; i < se->num_termlists; i++)
+ if (!strcmp((const char *) se->termlists[i].name, name))
{
- tl = termlist_highscore(s->termlists[i].termlist, num);
+ tl = termlist_highscore(se->termlists[i].termlist, num);
break;
}
- session_leave(s);
+ session_leave(se);
return tl;
}
}
#endif
-struct record_cluster *show_single_start(struct session *s, const char *id,
+struct record_cluster *show_single_start(struct session *se, const char *id,
struct record_cluster **prev_r,
struct record_cluster **next_r)
{
struct record_cluster *r;
- session_enter(s);
- reclist_enter(s->reclist);
+ session_enter(se);
+ reclist_enter(se->reclist);
*prev_r = 0;
*next_r = 0;
- while ((r = reclist_read_record(s->reclist)))
+ while ((r = reclist_read_record(se->reclist)))
{
if (!strcmp(r->recid, id))
{
- *next_r = reclist_read_record(s->reclist);
+ *next_r = reclist_read_record(se->reclist);
break;
}
*prev_r = r;
}
- reclist_leave(s->reclist);
+ reclist_leave(se->reclist);
if (!r)
- session_leave(s);
+ session_leave(se);
return r;
}
-void show_single_stop(struct session *s, struct record_cluster *rec)
+void show_single_stop(struct session *se, struct record_cluster *rec)
{
- session_leave(s);
+ session_leave(se);
}
-struct record_cluster **show_range_start(struct session *s,
+struct record_cluster **show_range_start(struct session *se,
struct reclist_sortparms *sp,
int start, int *num, int *total, Odr_int *sumhits)
{
- struct record_cluster **recs = nmem_malloc(s->nmem, *num
- * sizeof(struct record_cluster *));
+ struct record_cluster **recs;
struct reclist_sortparms *spp;
int i;
#if USE_TIMING
yaz_timing_t t = yaz_timing_create();
#endif
-
- session_enter(s);
- if (!s->relevance)
+ session_enter(se);
+ recs = nmem_malloc(se->nmem, *num * sizeof(struct record_cluster *));
+ if (!se->relevance)
{
*num = 0;
*total = 0;
for (spp = sp; spp; spp = spp->next)
if (spp->type == Metadata_sortkey_relevance)
{
- relevance_prepare_read(s->relevance, s->reclist);
+ relevance_prepare_read(se->relevance, se->reclist);
break;
}
- reclist_sort(s->reclist, sp);
+ reclist_sort(se->reclist, sp);
- reclist_enter(s->reclist);
- *total = reclist_get_num_records(s->reclist);
- *sumhits = s->total_hits;
+ reclist_enter(se->reclist);
+ *total = reclist_get_num_records(se->reclist);
+ *sumhits = se->total_hits;
for (i = 0; i < start; i++)
- if (!reclist_read_record(s->reclist))
+ if (!reclist_read_record(se->reclist))
{
*num = 0;
recs = 0;
for (i = 0; i < *num; i++)
{
- struct record_cluster *r = reclist_read_record(s->reclist);
+ struct record_cluster *r = reclist_read_record(se->reclist);
if (!r)
{
*num = i;
}
recs[i] = r;
}
- reclist_leave(s->reclist);
+ reclist_leave(se->reclist);
}
#if USE_TIMING
yaz_timing_stop(t);
return recs;
}
-void show_range_stop(struct session *s, struct record_cluster **recs)
+void show_range_stop(struct session *se, struct record_cluster **recs)
{
- session_leave(s);
+ session_leave(se);
}
void statistics(struct session *se, struct statistics *stat)
{
- struct client *cl;
+ struct client_list *l;
int count = 0;
memset(stat, 0, sizeof(*stat));
- for (cl = se->clients; cl; cl = client_next_in_session(cl))
+ for (l = se->clients; l; l = l->next)
{
+ struct client *cl = l->client;
if (!client_get_connection(cl))
stat->num_no_connection++;
switch (client_get_state(cl))
{
const char *norm_str;
pp2_relevance_token_t prt =
- pp2_relevance_tokenize(
- service->mergekey_pct,
- (const char *) value, 0);
+ pp2_relevance_tokenize(service->mergekey_pct);
+ pp2_relevance_first(prt, (const char *) value, 0);
if (wrbuf_len(norm_wr) > 0)
wrbuf_puts(norm_wr, " ");
wrbuf_puts(norm_wr, name);
{
const char *norm_str;
pp2_relevance_token_t prt =
- pp2_relevance_tokenize(
- service->mergekey_pct,
- (const char *) mergekey, 0);
-
+ pp2_relevance_tokenize(service->mergekey_pct);
+
+ pp2_relevance_first(prt, (const char *) mergekey, 0);
while ((norm_str = pp2_relevance_token_next(prt)))
{
if (*norm_str)
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 = 0;
+ 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)
{
return -1;
}
session_enter(se);
- ret = ingest_to_cluster(cl, xdoc, root, record_no, mergekey_norm);
+ if (client_get_session(cl) == se)
+ ret = ingest_to_cluster(cl, xdoc, root, record_no, mergekey_norm);
session_leave(se);
-
+
xmlFreeDoc(xdoc);
-
return ret;
}
nmem_malloc(se->nmem,
sizeof(union data_types));
- prt = pp2_relevance_tokenize(
- service->sort_pct,
- rec_md->data.text.disp, skip_article);
+ prt = pp2_relevance_tokenize(service->sort_pct);
+
+ pp2_relevance_first(prt, rec_md->data.text.disp,
+ skip_article);
pp2_relevance_token_next(prt);