X-Git-Url: http://jsfdemo.indexdata.com/?a=blobdiff_plain;f=src%2Fsession.c;h=e923abf9956fe36999fa5298153835c32d71aa3f;hb=74f3e867802e2f6b4e1f803b2e98c1e886a515bf;hp=250734ebb5c76268de284a76fa7c3f1724ea7797;hpb=0aa1114a00aa7d78e6e9dd8099f4c9b3d93f5f94;p=pazpar2-moved-to-github.git diff --git a/src/session.c b/src/session.c index 250734e..e923abf 100644 --- a/src/session.c +++ b/src/session.c @@ -1,5 +1,5 @@ /* This file is part of Pazpar2. - Copyright (C) 2006-2012 Index Data + Copyright (C) 2006-2013 Index Data Pazpar2 is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free @@ -148,18 +148,52 @@ static void log_xml_doc(xmlDoc *doc) xmlFree(result); } -static void session_enter(struct session *s, const char *caller) +void session_enter_ro(struct session *s, const char *caller) { + assert(s); + if (caller) + session_log(s, YLOG_LOG, "Session read lock by %s", caller); + pazpar2_lock_rdwr_rlock(&s->lock); +} + +void session_enter_rw(struct session *s, const char *caller) +{ + assert(s); + if (caller) + session_log(s, YLOG_LOG, "Session write lock by %s", caller); + pazpar2_lock_rdwr_wlock(&s->lock); +} + +void session_upgrade(struct session *s, const char *caller) +{ + assert(s); if (caller) - session_log(s, YLOG_DEBUG, "Session lock by %s", caller); - yaz_mutex_enter(s->session_mutex); + session_log(s, YLOG_LOG, "Session upgrade lock by %s", caller); + pazpar2_lock_rdwr_upgrade(&s->lock); } -static void session_leave(struct session *s, const char *caller) +void session_leave_ro(struct session *s, const char *caller) { - yaz_mutex_leave(s->session_mutex); + assert(s); + if (caller) + session_log(s, YLOG_LOG, "Session read unlock by %s", caller); + pazpar2_lock_rdwr_runlock(&s->lock); +} + +void session_leave_rw(struct session *s, const char *caller) +{ + assert(s); + if (caller) + session_log(s, YLOG_LOG, "Session write unlock by %s", caller); + pazpar2_lock_rdwr_wunlock(&s->lock); +} + +void session_downgrade(struct session *s, const char *caller) +{ + assert(s); if (caller) - session_log(s, YLOG_DEBUG, "Session unlock by %s", caller); + session_log(s, YLOG_LOG, "Session write unlock by %s", caller); + pazpar2_lock_rdwr_downgrade(&s->lock); } static void session_normalize_facet(struct session *s, const char *type, @@ -464,7 +498,6 @@ int session_set_watch(struct session *s, int what, struct http_channel *chan) { int ret; - session_enter(s, "session_set_watch"); if (s->watchlist[what].fun) ret = -1; else @@ -476,14 +509,12 @@ int session_set_watch(struct session *s, int what, session_watch_cancel); ret = 0; } - session_leave(s, "session_set_watch"); return ret; } void session_alert_watch(struct session *s, int what) { assert(s); - session_enter(s, "session_alert_watch"); if (s->watchlist[what].fun) { /* our watch is no longer associated with http_channel */ @@ -500,13 +531,10 @@ void session_alert_watch(struct session *s, int what) s->watchlist[what].data = 0; s->watchlist[what].obs = 0; - session_leave(s, "session_alert_watch"); session_log(s, YLOG_DEBUG, "Alert Watch: %d calling function: %p", what, fun); fun(data); } - else - session_leave(s,"session_alert_watch"); } //callback for grep_databases @@ -546,18 +574,14 @@ static void session_reset_active_clients(struct session *se, { struct client_list *l; - session_enter(se, "session_reset_active_clients"); l = se->clients_active; se->clients_active = new_list; - session_leave(se, "session_reset_active_clients"); while (l) { struct client_list *l_next = l->next; - client_lock(l->client); client_set_session(l->client, 0); /* mark client inactive */ - client_unlock(l->client); xfree(l); l = l_next; @@ -570,18 +594,14 @@ static void session_remove_cached_clients(struct session *se) session_reset_active_clients(se, 0); - session_enter(se, "session_remove_cached_clients"); l = se->clients_cached; se->clients_cached = 0; - session_leave(se, "session_remove_cached_clients"); 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; @@ -644,7 +664,8 @@ static void session_clear_set(struct session *se, struct reclist_sortparms *sp) se->reclist = reclist_create(se->nmem); } -static void session_sort_unlocked(struct session *se, struct reclist_sortparms *sp) +static void session_sort_unlocked(struct session *se, + struct reclist_sortparms *sp) { struct reclist_sortparms *sr; struct client_list *l; @@ -653,7 +674,7 @@ static void session_sort_unlocked(struct session *se, struct reclist_sortparms * int type = sp->type; int clients_research = 0; - yaz_log(YLOG_LOG, "session_sort field=%s increasing=%d type=%d", field, increasing, type); + yaz_log(YLOG_DEBUG, "session_sort field=%s increasing=%d type=%d", field, increasing, type); /* see if we already have sorted for this criteria */ for (sr = se->sorted_results; sr; sr = sr->next) { @@ -713,68 +734,57 @@ static void session_sort_unlocked(struct session *se, struct reclist_sortparms * } } -void session_sort(struct session *se, struct reclist_sortparms *sp) { - //session_enter(se, "session_sort"); +void session_sort(struct session *se, struct reclist_sortparms *sp) +{ + session_enter_rw(se, "session_sort"); session_sort_unlocked(se, sp); - //session_leave(se, "session_sort"); + session_leave_rw(se, "session_sort"); } - -enum pazpar2_error_code session_search(struct session *se, - const char *query, - const char *startrecs, - const char *maxrecs, - const char *filter, - const char *limit, - const char **addinfo, - struct reclist_sortparms *sp) +static +enum pazpar2_error_code session_search_unlocked(struct session *se, + const char *query, + const char *startrecs, + const char *maxrecs, + const char *filter, + const char *limit, + const char **addinfo, + struct reclist_sortparms *sp) { int live_channels = 0; int no_working = 0; int no_failed_query = 0; int no_failed_limit = 0; struct client_list *l, *l0; - int same_sort_order = 0; session_log(se, YLOG_DEBUG, "Search"); *addinfo = 0; - if (se->settings_modified) { + if (se->settings_modified) session_remove_cached_clients(se); - } else session_reset_active_clients(se, 0); - session_enter(se, "session_search"); se->settings_modified = 0; - if (se->sorted_results) { - if (!reclist_sortparms_cmp(se->sorted_results, sp)) - same_sort_order = 1; - } session_clear_set(se, sp); relevance_destroy(&se->relevance); live_channels = select_targets(se, filter); if (!live_channels) - { - session_leave(se, "session_search"); return PAZPAR2_NO_TARGETS; - } facet_limits_destroy(se->facet_limits); se->facet_limits = facet_limits_create(limit); if (!se->facet_limits) { *addinfo = "limit"; - session_leave(se, "session_search"); return PAZPAR2_MALFORMED_PARAMETER_VALUE; } l0 = se->clients_active; se->clients_active = 0; - session_leave(se, "session_search"); for (l = l0; l; l = l->next) { @@ -816,10 +826,26 @@ enum pazpar2_error_code session_search(struct session *se, else return PAZPAR2_NO_TARGETS; } - session_log(se, YLOG_LOG, "session_start_search done"); return PAZPAR2_NO_ERROR; } +enum pazpar2_error_code session_search(struct session *se, + const char *query, + const char *startrecs, + const char *maxrecs, + const char *filter, + const char *limit, + const char **addinfo, + struct reclist_sortparms *sp) +{ + enum pazpar2_error_code c; + session_enter_rw(se, "session_search"); + c = session_search_unlocked(se, query, startrecs, maxrecs, filter, + limit, addinfo, sp); + session_leave_rw(se, "session_search"); + return c; +} + // Creates a new session_database object for a database static void session_init_databases_fun(void *context, struct database *db) { @@ -917,6 +943,8 @@ void session_apply_setting(struct session *se, char *dbname, char *setting, void session_destroy(struct session *se) { struct session_database *sdb; + + session_enter_rw(se, "session_destroy"); session_log(se, YLOG_DEBUG, "Destroying"); session_use(-1); session_remove_cached_clients(se); @@ -933,22 +961,24 @@ void session_destroy(struct session *se) facet_limits_destroy(se->facet_limits); nmem_destroy(se->nmem); service_destroy(se->service); - yaz_mutex_destroy(&se->session_mutex); + + session_leave_rw(se, "session_destroy"); + pazpar2_lock_rdwr_destroy(&se->lock); } size_t session_get_memory_status(struct session *session) { size_t session_nmem; if (session == 0) return 0; - session_enter(session, "session_get_memory_status"); + session_enter_ro(session, "session_get_memory_status"); session_nmem = nmem_total(session->nmem); - session_leave(session, "session_get_memory_status"); + session_leave_ro(session, "session_get_memory_status"); return session_nmem; } -struct session *new_session(NMEM nmem, struct conf_service *service, - unsigned session_id) +struct session *session_create(NMEM nmem, struct conf_service *service, + unsigned session_id) { int i; struct session *session = nmem_malloc(nmem, sizeof(*session)); @@ -981,8 +1011,9 @@ struct session *new_session(NMEM nmem, struct conf_service *service, session->watchlist[i].fun = 0; } session->normalize_cache = normalize_cache_create(); - session->session_mutex = 0; - pazpar2_mutex_create(&session->session_mutex, tmp_str); + + pazpar2_lock_rdwr_init(&session->lock); + session_use(1); return session; } @@ -1033,9 +1064,9 @@ static struct hitsbytarget *hitsbytarget_nb(struct session *se, struct hitsbytarget *get_hitsbytarget(struct session *se, int *count, NMEM nmem) { struct hitsbytarget *p; - session_enter(se, "get_hitsbytarget"); + session_enter_ro(se, "get_hitsbytarget"); p = hitsbytarget_nb(se, count, nmem); - session_leave(se, "get_hitsbytarget"); + session_leave_ro(se, "get_hitsbytarget"); return p; } @@ -1118,7 +1149,7 @@ void perform_termlist(struct http_channel *c, struct session *se, nmem_strsplit(nmem_tmp, ",", name, &names, &num_names); - session_enter(se, "perform_termlist"); + session_enter_ro(se, "perform_termlist"); for (j = 0; j < num_names; j++) { @@ -1181,7 +1212,7 @@ void perform_termlist(struct http_channel *c, struct session *se, wrbuf_puts(c->wrbuf, "\"/>\n"); } } - session_leave(se, "perform_termlist"); + session_leave_ro(se, "perform_termlist"); nmem_destroy(nmem_tmp); } @@ -1204,7 +1235,7 @@ struct record_cluster *show_single_start(struct session *se, const char *id, { struct record_cluster *r = 0; - session_enter(se, "show_single_start"); + session_enter_ro(se, "show_single_start"); *prev_r = 0; *next_r = 0; if (se->reclist) @@ -1224,79 +1255,71 @@ struct record_cluster *show_single_start(struct session *se, const char *id, reclist_leave(se->reclist); } if (!r) - session_leave(se, "show_single_start"); + session_leave_ro(se, "show_single_start"); return r; } void show_single_stop(struct session *se, struct record_cluster *rec) { - session_leave(se, "show_single_stop"); + session_leave_ro(se, "show_single_stop"); } struct record_cluster **show_range_start(struct session *se, struct reclist_sortparms *sp, - int start, int *num, int *total, Odr_int *sumhits, Odr_int *approx_hits) + int start, int *num, int *total, + Odr_int *sumhits, Odr_int *approx_hits) { - struct record_cluster **recs; + struct record_cluster **recs = 0; struct reclist_sortparms *spp; + struct client_list *l; int i; #if USE_TIMING yaz_timing_t t = yaz_timing_create(); #endif - session_enter(se, "show_range_start"); - recs = nmem_malloc(se->nmem, *num * sizeof(struct record_cluster *)); - if (!se->relevance) - { - *num = 0; - *total = 0; - *sumhits = 0; - *approx_hits = 0; - recs = 0; - } - else + *sumhits = 0; + *approx_hits = 0; + *total = 0; + reclist_limit(se->reclist, se); + if (se->relevance) { - struct client_list *l; - - reclist_limit(se->reclist, se); - for (spp = sp; spp; spp = spp->next) if (spp->type == Metadata_sortkey_relevance) { relevance_prepare_read(se->relevance, se->reclist); break; } - reclist_sort(se->reclist, sp); - - reclist_enter(se->reclist); - *total = reclist_get_num_records(se->reclist); - - *sumhits = 0; - *approx_hits = 0; for (l = se->clients_active; l; l = l->next) { *sumhits += client_get_hits(l->client); *approx_hits += client_get_approximation(l->client); } - for (i = 0; i < start; i++) - if (!reclist_read_record(se->reclist)) - { - *num = 0; - recs = 0; - break; - } + } + reclist_sort(se->reclist, sp); - for (i = 0; i < *num; i++) + reclist_enter(se->reclist); + *total = reclist_get_num_records(se->reclist); + + for (i = 0; i < start; i++) + if (!reclist_read_record(se->reclist)) { - struct record_cluster *r = reclist_read_record(se->reclist); - if (!r) - { - *num = i; - break; - } - recs[i] = r; + *num = 0; + break; } - reclist_leave(se->reclist); + + if (*num > 0) + recs = + nmem_malloc(se->nmem, *num * sizeof(struct record_cluster *)); + for (i = 0; i < *num; i++) + { + struct record_cluster *r = reclist_read_record(se->reclist); + if (!r) + { + *num = i; + break; + } + recs[i] = r; } + reclist_leave(se->reclist); #if USE_TIMING yaz_timing_stop(t); yaz_log(YLOG_LOG, "show %6.5f %3.2f %3.2f", @@ -1309,7 +1332,6 @@ struct record_cluster **show_range_start(struct session *se, void show_range_stop(struct session *se, struct record_cluster **recs) { - session_leave(se, "show_range_stop"); } void statistics(struct session *se, struct statistics *stat) @@ -1616,10 +1638,9 @@ int ingest_record(struct client *cl, const char *rec, xmlFreeDoc(xdoc); return -1; } - session_enter(se, "ingest_record"); - if (client_get_session(cl) == se) - ret = ingest_to_cluster(cl, xdoc, root, record_no, mergekey_norm); - session_leave(se, "ingest_record"); + assert(client_get_session(cl) == se); + + ret = ingest_to_cluster(cl, xdoc, root, record_no, mergekey_norm); xmlFreeDoc(xdoc); return ret; @@ -1781,6 +1802,7 @@ static int ingest_to_cluster(struct client *cl, struct conf_service *service = se->service; int term_factor = 1; struct record_cluster *cluster; + struct record_metadata **metadata0; struct session_database *sdb = client_get_database(cl); struct record *record = record_create(se->nmem, service->num_metadata, @@ -1854,7 +1876,7 @@ static int ingest_to_cluster(struct client *cl, cluster = reclist_insert(se->reclist, service, record, mergekey_norm, &se->total_merged); if (!cluster) - return -1; + return 0; // complete match with existing record { const char *use_term_factor_str = @@ -1876,6 +1898,11 @@ static int ingest_to_cluster(struct client *cl, relevance_newrec(se->relevance, cluster); + // original metadata, to check if first existence of a field + metadata0 = xmalloc(sizeof(*metadata0) * service->num_metadata); + memcpy(metadata0, cluster->metadata, + sizeof(*metadata0) * service->num_metadata); + // now parsing XML record and adding data to cluster or record metadata for (n = root->children; n; n = n->next) { @@ -1921,6 +1948,9 @@ static int ingest_to_cluster(struct client *cl, // merged metadata rec_md = record_metadata_init(se->nmem, (const char *) value, ser_md->type, 0); + + // see if the field was not in cluster already (from beginning) + if (!rec_md) continue; @@ -1929,9 +1959,16 @@ static int ingest_to_cluster(struct client *cl, wheretoput = &cluster->metadata[md_field_id]; - // and polulate with data: - // assign cluster or record based on merge action - if (ser_md->merge == Metadata_merge_unique) + if (ser_md->merge == Metadata_merge_first) + { + if (!metadata0[md_field_id]) + { + while (*wheretoput) + wheretoput = &(*wheretoput)->next; + *wheretoput = rec_md; + } + } + else if (ser_md->merge == Metadata_merge_unique) { while (*wheretoput) { @@ -2057,6 +2094,7 @@ static int ingest_to_cluster(struct client *cl, if (value) xmlFree(value); + xfree(metadata0); relevance_donerecord(se->relevance, cluster); se->total_records++;