xmlFree(result);
}
+static void session_enter(struct session *s)
+{
+ yaz_mutex_enter(s->mutex);
+}
+
+static void session_leave(struct session *s)
+{
+ yaz_mutex_leave(s->mutex);
+}
+
// Recursively traverse query structure to extract terms.
void pull_terms(NMEM nmem, struct ccl_rpn_node *n, char **termlist, int *num)
{
}
-
static void add_facet(struct session *s, const char *type, const char *value)
{
int i;
// Add static values from session database settings if applicable
static void insert_settings_parameters(struct session_database *sdb,
- struct session *se, char **parms)
+ struct conf_service *service,
+ char **parms,
+ NMEM nmem)
{
- struct conf_service *service = se->service;
int i;
int nparms = 0;
int offset = 0;
{
char *buf;
int len = strlen(val);
- buf = nmem_malloc(se->nmem, len + 3);
+ buf = nmem_malloc(nmem, len + 3);
buf[0] = '\'';
strcpy(buf + 1, val);
buf[len+1] = '\'';
}
static xmlDoc *normalize_record(struct session_database *sdb,
- struct session *se,
- const char *rec)
+ struct conf_service *service,
+ const char *rec, NMEM nmem)
{
xmlDoc *rdoc = record_to_xml(sdb, rec);
{
char *parms[MAX_XSLT_ARGS*2+1];
- insert_settings_parameters(sdb, se, parms);
+ insert_settings_parameters(sdb, service, parms, nmem);
if (normalize_record_transform(sdb->map, &rdoc, (const char **)parms))
{
}
else
{
- insert_settings_values(sdb, rdoc, se->service);
+ insert_settings_values(sdb, rdoc, service);
if (global_parameters.dump_records)
{
// Will be extended to take into account user associated with session
const char *session_setting_oneval(struct session_database *db, int offset)
{
- if (!db->settings[offset])
+ if (offset >= db->num_settings || !db->settings[offset])
return "";
return db->settings[offset]->value;
}
yaz_log(YLOG_DEBUG, "Search");
*addinfo = 0;
+
+ 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;
se->num_termlists = 0;
live_channels = select_targets(se, filter);
- if (live_channels)
+ if (!live_channels)
{
- se->reclist = reclist_create(se->nmem);
- }
- else
+ session_leave(se);
return PAZPAR2_NO_TARGETS;
+ }
+ se->reclist = reclist_create(se->nmem);
for (cl = se->clients; cl; cl = client_next_in_session(cl))
{
{
no_working++;
if (client_prep_connection(cl, se->service->z3950_operation_timeout,
- se->service->z3950_session_timeout))
+ se->service->z3950_session_timeout,
+ se->service->server->iochan_man))
client_start_search(cl);
}
}
+ session_leave(se);
if (no_working == 0)
{
if (no_failed > 0)
sizeof(struct settings *) * db->num_settings);
new->num_settings = db->num_settings;
for (i = 0; i < db->num_settings; i++)
- new->settings[i] = db->settings[i];
+ {
+ struct setting *setting = db->settings[i];
+ new->settings[i] = setting;
+ }
new->next = se->databases;
se->databases = new;
}
static struct session_database *load_session_database(struct session *se,
char *id)
{
- struct database *db = find_database(id, se->service);
+ struct database *db = new_database(id, se->session_nmem);
- resolve_database(db);
+ resolve_database(se->service, db);
session_init_databases_fun((void*) se, db);
+
// New sdb is head of se->databases list
return se->databases;
}
for (sdb = s->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);
}
session->watchlist[i].fun = 0;
}
session->normalize_cache = normalize_cache_create();
+ session->mutex = 0;
+ yaz_mutex_create(&session->mutex);
return session;
}
struct client *cl;
size_t sz = 0;
+ session_enter(se);
for (cl = se->clients; cl; cl = client_next_in_session(cl))
sz++;
res[*count].settings_xml = w;
(*count)++;
}
+ session_leave(se);
return res;
}
struct termlist_score **termlist(struct session *s, 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))
- return termlist_highscore(s->termlists[i].termlist, num);
- return 0;
+ {
+ tl = termlist_highscore(s->termlists[i].termlist, num);
+ break;
+ }
+ session_leave(s);
+ return tl;
}
#ifdef MISSING_HEADERS
}
#endif
-struct record_cluster *show_single(struct session *s, const char *id,
- struct record_cluster **prev_r,
- struct record_cluster **next_r)
+struct record_cluster *show_single_start(struct session *s, const char *id,
+ struct record_cluster **prev_r,
+ struct record_cluster **next_r)
{
struct record_cluster *r;
- reclist_rewind(s->reclist);
+ session_enter(s);
+ reclist_enter(s->reclist);
*prev_r = 0;
*next_r = 0;
while ((r = reclist_read_record(s->reclist)))
if (!strcmp(r->recid, id))
{
*next_r = reclist_read_record(s->reclist);
- return r;
+ break;
}
*prev_r = r;
}
- return 0;
+ reclist_leave(s->reclist);
+ if (!r)
+ session_leave(s);
+ return r;
}
-struct record_cluster **show(struct session *s, struct reclist_sortparms *sp,
- int start, int *num, int *total, Odr_int *sumhits,
- NMEM nmem_show)
+void show_single_stop(struct session *s, struct record_cluster *rec)
{
- struct record_cluster **recs = nmem_malloc(nmem_show, *num
+ session_leave(s);
+}
+
+struct record_cluster **show_range_start(struct session *s,
+ 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 reclist_sortparms *spp;
int i;
yaz_timing_t t = yaz_timing_create();
#endif
+ session_enter(s);
if (!s->relevance)
{
*num = 0;
}
reclist_sort(s->reclist, sp);
+ reclist_enter(s->reclist);
*total = reclist_get_num_records(s->reclist);
*sumhits = s->total_hits;
}
recs[i] = r;
}
+ reclist_leave(s->reclist);
}
#if USE_TIMING
yaz_timing_stop(t);
return recs;
}
+void show_range_stop(struct session *s, struct record_cluster **recs)
+{
+ session_leave(s);
+}
+
void statistics(struct session *se, struct statistics *stat)
{
struct client *cl;
stat->num_clients = count;
}
-
-// Master list of connections we're handling events to
-static IOCHAN channel_list = 0; /* thread pr */
-
-void pazpar2_add_channel(IOCHAN chan)
-{
- chan->next = channel_list;
- channel_list = chan;
-}
-
-void pazpar2_event_loop()
-{
- event_loop(&channel_list);
-}
-
static struct record_metadata *record_metadata_init(
NMEM nmem, const char *value, enum conf_metadata_type type,
struct _xmlAttr *attr)
}
+static int ingest_to_cluster(struct client *cl,
+ xmlDoc *xdoc,
+ xmlNode *root,
+ int record_no,
+ const char *mergekey_norm);
+
/** \brief ingest XML record
\param cl client holds the result set for record
\param rec record buffer (0 terminated)
\param record_no record position (1, 2, ..)
- \returns resulting record or NULL on failure
+ \retval 0 OK
+ \retval -1 failure
*/
-struct record *ingest_record(struct client *cl, const char *rec,
- int record_no)
+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);
- xmlDoc *xdoc = normalize_record(sdb, se, rec);
- xmlNode *root, *n;
- struct record *record;
- struct record_cluster *cluster;
- const char *mergekey_norm;
- xmlChar *type = 0;
- xmlChar *value = 0;
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 0;
+ return -1;
root = xmlDocGetRootElement(xdoc);
yaz_log(YLOG_WARN, "Filtered out record no %d from %s", record_no,
sdb->database->url);
xmlFreeDoc(xdoc);
- return 0;
+ return -1;
}
- mergekey_norm = get_mergekey(xdoc, cl, record_no, service, se->nmem);
+ mergekey_norm = get_mergekey(xdoc, cl, record_no, service, nmem);
if (!mergekey_norm)
{
yaz_log(YLOG_WARN, "Got no mergekey");
xmlFreeDoc(xdoc);
- return 0;
+ return -1;
}
- record = record_create(se->nmem,
- service->num_metadata, service->num_sortkeys, cl,
- record_no);
-
- cluster = reclist_insert(se->reclist,
- service,
- record, (char *) mergekey_norm,
- &se->total_merged);
+ session_enter(se);
+ ret = ingest_to_cluster(cl, xdoc, root, record_no, mergekey_norm);
+ session_leave(se);
+
+ xmlFreeDoc(xdoc);
+
+ return ret;
+}
+
+static int ingest_to_cluster(struct client *cl,
+ xmlDoc *xdoc,
+ xmlNode *root,
+ int record_no,
+ const char *mergekey_norm)
+{
+ xmlNode *n;
+ xmlChar *type = 0;
+ xmlChar *value = 0;
+ struct session_database *sdb = client_get_database(cl);
+ struct session *se = client_get_session(cl);
+ struct conf_service *service = se->service;
+ struct record *record = record_create(se->nmem,
+ service->num_metadata,
+ service->num_sortkeys, cl,
+ record_no);
+ struct record_cluster *cluster = reclist_insert(se->reclist,
+ service,
+ record,
+ mergekey_norm,
+ &se->total_merged);
if (!cluster)
- {
- /* no room for record */
- xmlFreeDoc(xdoc);
- return 0;
- }
+ return -1;
if (global_parameters.dump_records)
yaz_log(YLOG_LOG, "Cluster id %s from %s (#%d)", cluster->recid,
sdb->database->url, record_no);
if (value)
xmlFree(value);
- xmlFreeDoc(xdoc);
-
relevance_donerecord(se->relevance, cluster);
se->total_records++;
- return record;
+ return 0;
}
-
-
/*
* Local variables:
* c-basic-offset: 4
projects / pazpar2-moved-to-github.git / blobdiff