X-Git-Url: http://jsfdemo.indexdata.com/?a=blobdiff_plain;f=src%2Fhttp_command.c;h=d4b4a77672c6c49acfe48790d9530e7ec5218287;hb=946cb4dbcb08fd17b6245acfc0da2b467b7449e6;hp=f736b38b6af8632b54ff80ef4fa531b2a0e9e8e9;hpb=ef0a61b93862f0bbb99b88f2d4460ad75509c814;p=pazpar2-moved-to-github.git

diff --git a/src/http_command.c b/src/http_command.c
index f736b38..d4b4a77 100644
--- a/src/http_command.c
+++ b/src/http_command.c
@@ -1,5 +1,5 @@
 /* This file is part of Pazpar2.
-   Copyright (C) 2006-2011 Index Data
+   Copyright (C) 2006-2012 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
@@ -93,6 +93,16 @@ struct http_sessions {
 static YAZ_MUTEX g_http_session_mutex = 0;
 static int g_http_sessions = 0;
 
+int get_version(struct http_request *rq) {
+    const char *version = http_argbyname(rq, "version");
+    int version_no = 0;
+    if (version && strcmp(version, "")) {
+        version_no = atoi(version);
+    }
+    return version_no;
+}
+
+
 int http_session_use(int delta)
 {
     int sessions;
@@ -166,7 +176,7 @@ struct http_session *http_session_create(struct conf_service *service,
 
     r->timeout_iochan = iochan_create(-1, session_timeout, 0, "http_session_timeout");
     iochan_setdata(r->timeout_iochan, r);
-    yaz_log(http_sessions->log_level, "%p Session %u created. timeout chan=%p timeout=%d", r, sesid, r->timeout_iochan, service->session_timeout);
+    yaz_log(http_sessions->log_level, "Session %u created. timeout chan=%p timeout=%d", sesid, r->timeout_iochan, service->session_timeout);
     iochan_settimeout(r->timeout_iochan, service->session_timeout);
 
     iochan_add(service->server->iochan_man, r->timeout_iochan);
@@ -180,7 +190,7 @@ void http_session_destroy(struct http_session *s)
 
     http_sessions_t http_sessions = s->http_sessions;
 
-    yaz_log(http_sessions->log_level, "%p HTTP Session %u destroyed", s, s->session_id);
+    yaz_log(http_sessions->log_level, "Session %u destroy", s->session_id);
     yaz_mutex_enter(http_sessions->mutex);
     /* only if http_session has no active http sessions on it can be destroyed */
     if (s->destroy_counter == s->activity_counter)
@@ -197,15 +207,15 @@ void http_session_destroy(struct http_session *s)
     yaz_mutex_leave(http_sessions->mutex);
     if (must_destroy)
     {   /* destroying for real */
-        yaz_log(http_sessions->log_level, "%p HTTP Session %u destroyed", s, s->session_id);
+        yaz_log(http_sessions->log_level, "Session %u destroyed", s->session_id);
         iochan_destroy(s->timeout_iochan);
         session_destroy(s->psession);
         http_session_use(-1);
         nmem_destroy(s->nmem);
     }
     else {
-        yaz_log(http_sessions->log_level, "%p HTTP Session %u destroyed delayed. Active clients (%d-%d). Waiting for new timeout.",
-                s, s->session_id, s->activity_counter, s->destroy_counter);
+        yaz_log(http_sessions->log_level, "Session %u destroying delayed. Active clients (%d-%d). Waiting for new timeout.",
+                s->session_id, s->activity_counter, s->destroy_counter);
     }
 
 }
@@ -441,11 +451,11 @@ static void cmd_init(struct http_channel *c)
     sesid = make_sessionid();
     s = http_session_create(service, c->http_sessions, sesid);
     
-    yaz_log(c->http_sessions->log_level, "%p Session init %u ", s, sesid);
+    yaz_log(c->http_sessions->log_level, "Session init %u ", sesid);
     if (!clear || *clear == '0')
         session_init_databases(s->psession);
     else
-        yaz_log(YLOG_LOG, "HTTP Session %u init: No databases preloaded", sesid);
+        yaz_log(YLOG_LOG, "Session %u init: No databases preloaded", sesid);
     
     if (process_settings(s->psession, c->request, c->response) < 0)
         return;
@@ -491,6 +501,7 @@ static void cmd_settings(struct http_channel *c)
         if (!doc)
         {
             error(rs, PAZPAR2_MALFORMED_SETTING, 0);
+            release_session(c,s);
             return;
         }
         root_n = xmlDocGetRootElement(doc);
@@ -509,12 +520,12 @@ static void cmd_settings(struct http_channel *c)
     release_session(c, s);
 }
 
-static void termlist_response(struct http_channel *c)
+static void termlist_response(struct http_channel *c, struct http_session *s, const char *cmd_status)
 {
     struct http_request *rq = c->request;
-    struct http_session *s = locate_session(c);
-    const char *name = http_argbyname(rq, "name");
-    const char *nums = http_argbyname(rq, "num");
+    const char *name    = http_argbyname(rq, "name");
+    const char *nums    = http_argbyname(rq, "num");
+    int version = get_version(rq);
     int num = 15;
     int status;
 
@@ -524,19 +535,31 @@ static void termlist_response(struct http_channel *c)
     status = session_active_clients(s->psession);
 
     response_open_no_status(c, "termlist");
+    /* new protocol add a status to response. Triggered by a status parameter */
+    if (cmd_status != 0) {
+        wrbuf_printf(c->wrbuf, "<status>%s</status>\n", cmd_status);
+    }
     wrbuf_printf(c->wrbuf, "<activeclients>%d</activeclients>\n", status);
 
-    perform_termlist(c, s->psession, name, num);
+    perform_termlist(c, s->psession, name, num, version);
 
     response_close(c, "termlist");
-    release_session(c, s);
 }
 
 static void termlist_result_ready(void *data)
 {
     struct http_channel *c = (struct http_channel *) data;
-    yaz_log(c->http_sessions->log_level, "termlist watch released");
-    termlist_response(c);
+    struct http_request *rq = c->request;
+    const char *report = http_argbyname(rq, "report");
+    const char *status = 0;
+    struct http_session *s = locate_session(c);
+    if (report && !strcmp("status", report))
+        status = "OK";
+    if (s) {
+        yaz_log(c->http_sessions->log_level, "Session %u termlist watch released", s->session_id);
+        termlist_response(c, s, status);
+        release_session(c,s);
+    }
 }
 
 static void cmd_termlist(struct http_channel *c)
@@ -545,30 +568,51 @@ static void cmd_termlist(struct http_channel *c)
     struct http_response *rs = c->response;
     struct http_session *s = locate_session(c);
     const char *block = http_argbyname(rq, "block");
+    const char *report = http_argbyname(rq, "report");
+    int report_status = 0;
+    int report_error = 0;
+    const char *status_message = 0;
     int active_clients;
+    if (report  && !strcmp("error", report)) {
+        report_error = 1;
+        status_message = "OK";
+    }
+    if (report  && !strcmp("status", report)) {
+        report_status = 1;
+        status_message = "OK";
+    }
     if (!s)
         return;
 
     active_clients = session_active_clients(s->psession);
-
     if (block && !strcmp("1", block) && active_clients)
     {
         // if there is already a watch/block. we do not block this one
         if (session_set_watch(s->psession, SESSION_WATCH_TERMLIST,
                               termlist_result_ready, c, c) != 0)
         {
-            yaz_log(YLOG_WARN, "Attempt to block multiple times on termlist block. Not supported!");
-            error(rs, PAZPAR2_ALREADY_BLOCKED, "termlist");
+            yaz_log(YLOG_WARN, "Session %u: Attempt to block multiple times on termlist block. Not supported!", s->session_id);
+            if (report_error) {
+                error(rs, PAZPAR2_ALREADY_BLOCKED, "termlist");
+                release_session(c, s);
+                return;
+            }
+            else if (report_status) {
+                status_message = "WARNING (Already blocked on termlist)";
+            }
+            else {
+                yaz_log(YLOG_WARN, "Session %u: Ignoring termlist block. Return current result", s->session_id);
+            }
         }
         else
         {
-            yaz_log(c->http_sessions->log_level, "%p Session %u: Blocking on command termlist", s, s->session_id);
+            yaz_log(c->http_sessions->log_level, "Session %u: Blocking on command termlist", s->session_id);
+            release_session(c, s);
+            return;
         }
-        release_session(c, s);
-        return;
     }
 
-    termlist_response(c);
+    termlist_response(c, s, status_message);
     release_session(c, s);
 }
 
@@ -638,15 +682,22 @@ static void cmd_server_status(struct http_channel *c)
     xmalloc_trav(0);
 }
 
-static void bytarget_response(struct http_channel *c) {
+static void bytarget_response(struct http_channel *c, struct http_session *s, const char *cmd_status) {
     int count, i;
     struct hitsbytarget *ht;
     struct http_request *rq = c->request;
     const char *settings = http_argbyname(rq, "settings");
-    struct http_session *s = locate_session(c);
-
+    int version = get_version(rq);
     ht = get_hitsbytarget(s->psession, &count, c->nmem);
-    response_open(c, "bytarget");
+    if (!cmd_status)
+        /* Old protocol, always ok */
+        response_open(c, "bytarget");
+    else {
+        /* New protocol, OK or WARNING (...)*/
+        response_open_no_status(c, "bytarget");
+        wrbuf_printf(c->wrbuf, "<status>%s</status>", cmd_status);
+    }
+
     if (count == 0)
         yaz_log(YLOG_WARN, "Empty bytarget Response. No targets found!");
     for (i = 0; i < count; i++)
@@ -674,8 +725,11 @@ static void bytarget_response(struct http_channel *c) {
             wrbuf_puts(c->wrbuf, "</addinfo>\n");
         }
 
-        wrbuf_printf(c->wrbuf, "<records>%d</records>\n", ht[i].records);
-
+        wrbuf_printf(c->wrbuf, "<records>%d</records>\n", ht[i].records - ht[i].filtered);
+        if (version >= 2) {
+            wrbuf_printf(c->wrbuf, "<filtered>%d</filtered>\n", ht[i].filtered);
+            wrbuf_printf(c->wrbuf, "<approximation>" ODR_INT_PRINTF "</approximation>\n", ht[i].approximation);
+        }
         wrbuf_puts(c->wrbuf, "<state>");
         wrbuf_xmlputs(c->wrbuf, ht[i].state);
         wrbuf_puts(c->wrbuf, "</state>\n");
@@ -693,14 +747,21 @@ static void bytarget_response(struct http_channel *c) {
         wrbuf_puts(c->wrbuf, "</target>");
     }
     response_close(c, "bytarget");
-    release_session(c, s);
 }
 
 static void bytarget_result_ready(void *data)
 {
     struct http_channel *c = (struct http_channel *) data;
-    yaz_log(c->http_sessions->log_level, "bytarget watch released");
-    bytarget_response(c);
+    struct http_session *s = locate_session(c);
+    const char *status_message = "OK";
+    if (s) {
+        yaz_log(c->http_sessions->log_level, "Session %u: bytarget watch released", s->session_id);
+        bytarget_response(c, s, status_message);
+        release_session(c, s);
+    }
+    else {
+        yaz_log(c->http_sessions->log_level, "No Session found for released bytarget watch");
+    }
 }
 
 
@@ -710,30 +771,50 @@ static void cmd_bytarget(struct http_channel *c)
     struct http_response *rs = c->response;
     struct http_session *s = locate_session(c);
     const char *block = http_argbyname(rq, "block");
+    const char *report = http_argbyname(rq, "report");
+    int report_error = 0;
+    int report_status = 0;
+    const char *status_message = "OK";
     int no_active;
 
+    if (report && !strcmp("error", report)) {
+        report_error = 1;
+    }
+    if (report && !strcmp("status", report)) {
+        report_status = 1;
+    }
+
     if (!s)
         return;
 
     no_active = session_active_clients(s->psession);
-
     if (block && !strcmp("1",block) && no_active)
     {
         // if there is already a watch/block. we do not block this one
         if (session_set_watch(s->psession, SESSION_WATCH_BYTARGET,
                               bytarget_result_ready, c, c) != 0)
         {
-            yaz_log(YLOG_WARN, "Attempt to block multiple times on bytarget block. Not supported!");
-            error(rs, PAZPAR2_ALREADY_BLOCKED, "bytarget"); 
+            yaz_log(YLOG_WARN, "Session %u: Attempt to block multiple times on bytarget block. Not supported!", s->session_id);
+            if (report_error) {
+                error(rs, PAZPAR2_ALREADY_BLOCKED, "bytarget");
+                release_session(c, s);
+                return;
+            }
+            else if (report_status) {
+                status_message = "WARNING (Already blocked on bytarget)";
+            }
+            else {
+                yaz_log(YLOG_WARN, "Session %u: Ignoring bytarget block. Return current result.", s->session_id);
+            }
         }
         else
         {
-            yaz_log(c->http_sessions->log_level, "%p Session %u: Blocking on command bytarget", s, s->session_id);
+            yaz_log(c->http_sessions->log_level, "Session %u: Blocking on command bytarget", s->session_id);
+            release_session(c, s);
+            return;
         }
-        release_session(c, s);
-        return;
     }
-    bytarget_response(c);
+    bytarget_response(c, s, status_message);
     release_session(c, s);
 }
 
@@ -772,6 +853,7 @@ static void write_metadata(WRBUF w, struct conf_service *service,
                     break;
                 default:
                     wrbuf_puts(w, "[can't represent]");
+                    break;
             }
             wrbuf_printf(w, "</md-%s>", cmd->name);
         }
@@ -845,11 +927,10 @@ void show_raw_reset(void *data, struct http_channel *c, void *data2)
 
 static void cmd_record_ready(void *data);
 
-static void cmd_record(struct http_channel *c)
+static void show_record(struct http_channel *c, struct http_session *s)
 {
     struct http_response *rs = c->response;
     struct http_request *rq = c->request;
-    struct http_session *s = locate_session(c);
     struct record_cluster *rec, *prev_r, *next_r;
     struct record *r;
     struct conf_service *service;
@@ -877,7 +958,6 @@ static void cmd_record(struct http_channel *c)
         {
             error(rs, PAZPAR2_RECORD_MISSING, idstr);
         }
-        release_session(c, s);
         return;
     }
     if (offsetstr)
@@ -888,7 +968,8 @@ static void cmd_record(struct http_channel *c)
         int i;
         struct record*r = rec->records;
         int binary = 0;
-
+        const char *nativesyntax = http_argbyname(rq, "nativesyntax");
+        
         if (binarystr && *binarystr != '0')
             binary = 1;
 
@@ -903,13 +984,14 @@ static void cmd_record(struct http_channel *c)
             http_channel_observer_t obs =
                 http_add_observer(c, r->client, show_raw_reset);
             int ret = client_show_raw_begin(r->client, r->position,
-                                        syntax, esn, 
-                                        obs /* data */,
-                                        show_raw_record_error,
-                                        (binary ? 
-                                         show_raw_record_ok_binary : 
-                                         show_raw_record_ok),
-                                        (binary ? 1 : 0));
+                                            syntax, esn,
+                                            obs /* data */,
+                                            show_raw_record_error,
+                                            (binary ? 
+                                             show_raw_record_ok_binary : 
+                                             show_raw_record_ok),
+                                            (binary ? 1 : 0),
+                                            nativesyntax);
             if (ret == -1)
             {
                 http_remove_observer(obs);
@@ -943,30 +1025,45 @@ static void cmd_record(struct http_channel *c)
         response_close(c, "record");
     }
     show_single_stop(s->psession, rec);
-    release_session(c, s);
 }
 
 static void cmd_record_ready(void *data)
 {
     struct http_channel *c = (struct http_channel *) data;
-    yaz_log(c->http_sessions->log_level, "record watch released");
-    cmd_record(c);
+    struct http_session *s = locate_session(c);
+    if (s) {
+        yaz_log(c->http_sessions->log_level, "Session %u: record watch released", s->session_id);
+        show_record(c, s);
+        release_session(c,s);
+    }
 }
 
-static void show_records(struct http_channel *c, int active)
+static void cmd_record(struct http_channel *c)
+{
+    struct http_session *s = locate_session(c);
+    if (s) {
+        show_record(c, s);
+        release_session(c,s);
+    }
+}
+
+
+static void show_records(struct http_channel *c, struct http_session *s, int active)
 {
     struct http_request *rq = c->request;
     struct http_response *rs = c->response;
-    struct http_session *s = locate_session(c);
     struct record_cluster **rl;
     struct reclist_sortparms *sp;
     const char *start = http_argbyname(rq, "start");
     const char *num = http_argbyname(rq, "num");
     const char *sort = http_argbyname(rq, "sort");
+    int version = get_version(rq);
+
     int startn = 0;
     int numn = 20;
     int total;
     Odr_int total_hits;
+    Odr_int approx_hits;
     int i;
 
     if (!s)
@@ -985,18 +1082,19 @@ static void show_records(struct http_channel *c, int active)
     if (!(sp = reclist_parse_sortparms(c->nmem, sort, s->psession->service)))
     {
         error(rs, PAZPAR2_MALFORMED_PARAMETER_VALUE, "sort");
-        release_session(c, s);
         return;
 
     }
-
     
-    rl = show_range_start(s->psession, sp, startn, &numn, &total, &total_hits);
+    rl = show_range_start(s->psession, sp, startn, &numn, &total, &total_hits, &approx_hits);
 
     response_open(c, "show");
     wrbuf_printf(c->wrbuf, "\n<activeclients>%d</activeclients>\n", active);
     wrbuf_printf(c->wrbuf, "<merged>%d</merged>\n", total);
     wrbuf_printf(c->wrbuf, "<total>" ODR_INT_PRINTF "</total>\n", total_hits);
+    if (version >= 2) {
+        wrbuf_printf(c->wrbuf, "<approximation>" ODR_INT_PRINTF "</approximation>\n", approx_hits);
+    }
     wrbuf_printf(c->wrbuf, "<start>%d</start>\n", startn);
     wrbuf_printf(c->wrbuf, "<num>%d</num>\n", numn);
 
@@ -1025,14 +1123,20 @@ static void show_records(struct http_channel *c, int active)
     show_range_stop(s->psession, rl);
 
     response_close(c, "show");
-    release_session(c, s);
 }
 
 static void show_records_ready(void *data)
 {
     struct http_channel *c = (struct http_channel *) data;
-    yaz_log(c->http_sessions->log_level, "show watch released");
-    show_records(c, -1);
+    struct http_session *s = locate_session(c);
+    if (s) {
+        yaz_log(c->http_sessions->log_level, "Session %u: show watch released", s->session_id);
+        show_records(c, s, -1);
+    }
+    else {
+        /* some error message  */
+    }
+    release_session(c,s);
 }
 
 static void cmd_show(struct http_channel *c)
@@ -1042,9 +1146,14 @@ static void cmd_show(struct http_channel *c)
     struct http_session *s = locate_session(c);
     const char *block = http_argbyname(rq, "block");
     const char *sort = http_argbyname(rq, "sort");
+    const char *block_error = http_argbyname(rq, "report");
+
     struct reclist_sortparms *sp;
     int status;
-
+    int report_error = 0;
+    if (block_error && !strcmp("1", block_error)) {
+        report_error = 1;
+    }    
     if (!s)
         return;
 
@@ -1070,15 +1179,23 @@ static void cmd_show(struct http_channel *c)
                                   show_records_ready, c, c) == 0)
             {
                 yaz_log(c->http_sessions->log_level,
-                        "%p Session %u: Blocking on command show (preferred targets)", s, s->session_id);
+                        "Session %u: Blocking on command show (preferred targets)", s->session_id);
+                release_session(c, s);
+                return;
             }
             else
             {
-                yaz_log(YLOG_WARN, "Attempt to block multiple times on show (preferred targets) block. Not supported!");
-                error(rs, PAZPAR2_ALREADY_BLOCKED, "show (preferred targets)"); 
+                yaz_log(YLOG_WARN, "Session %u: Attempt to block multiple times on show (preferred targets) block. Not supported!", 
+                    s->session_id);
+                if (report_error) {
+                    error(rs, PAZPAR2_ALREADY_BLOCKED, "show (preferred targets)");
+                    release_session(c, s);
+                    return;
+                }
+                else {
+                    yaz_log(YLOG_WARN, "Session %u: Ignoring show(preferred) block. Returning current result.", s->session_id);
+                }
             }
-            release_session(c, s);
-            return;
 
         }
         else if (status)
@@ -1087,18 +1204,25 @@ static void cmd_show(struct http_channel *c)
             if (session_set_watch(s->psession, SESSION_WATCH_SHOW,
                                   show_records_ready, c, c) != 0)
             {
-                yaz_log(YLOG_WARN, "Attempt to block multiple times on show block. Not supported!");
-                error(rs, PAZPAR2_ALREADY_BLOCKED, "show"); 
+                yaz_log(YLOG_WARN, "Session %u: Attempt to block multiple times on show block. Not supported!", s->session_id);
+                if (report_error) {
+                    error(rs, PAZPAR2_ALREADY_BLOCKED, "show");
+                    release_session(c, s);
+                    return;
+                }
+                else {
+                    yaz_log(YLOG_WARN, "Session %u: Ignoring show block. Returning current result.", s->session_id);
+                }
             }
             else
             {
-                yaz_log(c->http_sessions->log_level, "%p Session %u: Blocking on command show", s, s->session_id);
+                yaz_log(c->http_sessions->log_level, "Session %u: Blocking on command show", s->session_id);
+                release_session(c, s);
+                return;
             }
-            release_session(c, s);
-            return;
         }
     }
-    show_records(c, status);
+    show_records(c, s, status);
     release_session(c, s);
 }