X-Git-Url: http://git.indexdata.com/?a=blobdiff_plain;f=src%2Ffilter_multi.cpp;h=ccdcc4a2ae47d0ff4dd3f86b38b88c7be70fa0b7;hb=b9e8337ac04be2e5fb43c9256aafdb1a4a9c8725;hp=61d001c4b450059df723ecd27861a1948a13f90a;hpb=e6d572ef110d14fa55115021505b808620457bd3;p=metaproxy-moved-to-github.git diff --git a/src/filter_multi.cpp b/src/filter_multi.cpp index 61d001c..ccdcc4a 100644 --- a/src/filter_multi.cpp +++ b/src/filter_multi.cpp @@ -1,5 +1,5 @@ /* This file is part of Metaproxy. - Copyright (C) 2005-2010 Index Data + Copyright (C) 2005-2012 Index Data Metaproxy 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 @@ -88,6 +88,7 @@ namespace metaproxy_1 { std::string m_backend_database; std::string m_vhost; std::string m_route; + std::string m_auth; void operator() (void); // thread operation }; struct Multi::Frontend { @@ -105,18 +106,22 @@ namespace metaproxy_1 { void present(Package &package, Z_APDU *apdu); void scan1(Package &package, Z_APDU *apdu); void scan2(Package &package, Z_APDU *apdu); + void relay_apdu(Package &package, Z_APDU *apdu); Rep *m_p; }; class Multi::Map { std::string m_target_pattern; std::string m_route; + std::string m_auth; public: - Map(std::string pattern, std::string route) : - m_target_pattern(pattern), m_route(route) {}; - bool match(const std::string target, std::string *ret) const { + Map(std::string pattern, std::string route, std::string auth) : + m_target_pattern(pattern), m_route(route), m_auth(auth) {}; + bool match(const std::string target, std::string *ret, + std::string *auth) const { if (yaz_match_glob(m_target_pattern.c_str(), target.c_str())) { *ret = m_route; + *auth = m_auth; return true; } return false; @@ -135,6 +140,7 @@ namespace metaproxy_1 { boost::condition m_cond_session_ready; std::map m_clients; bool m_hide_unavailable; + bool m_hide_errors; multi_merge_type m_merge_type; }; } @@ -143,6 +149,7 @@ namespace metaproxy_1 { yf::Multi::Rep::Rep() { m_hide_unavailable = false; + m_hide_errors = false; m_merge_type = round_robin; } @@ -392,7 +399,7 @@ void yf::Multi::Frontend::init(mp::Package &package, Z_GDU *gdu) std::list::const_iterator it = m_p->m_route_patterns.begin(); while (it != m_p->m_route_patterns.end()) { - if (it->match(*t_it, &b->m_route)) + if (it->match(*t_it, &b->m_route, &b->m_auth)) break; it++; } @@ -417,16 +424,31 @@ void yf::Multi::Frontend::init(mp::Package &package, Z_GDU *gdu) mp::util::set_vhost_otherinfo(&init_apdu->u.initRequest->otherInfo, odr, vhost_one); - Z_InitRequest *req = init_apdu->u.initRequest; + + Z_InitRequest *breq = init_apdu->u.initRequest; + + if (b->m_auth.length()) + { + breq->idAuthentication = + (Z_IdAuthentication *) + odr_malloc(odr, sizeof(*breq->idAuthentication)); + breq->idAuthentication->which = Z_IdAuthentication_open; + breq->idAuthentication->u.open = odr_strdup(odr, b->m_auth.c_str()); + } + else + breq->idAuthentication = req->idAuthentication; - ODR_MASK_SET(req->options, Z_Options_search); - ODR_MASK_SET(req->options, Z_Options_present); - ODR_MASK_SET(req->options, Z_Options_namedResultSets); - ODR_MASK_SET(req->options, Z_Options_scan); + *breq->preferredMessageSize = *req->preferredMessageSize; + *breq->maximumRecordSize = *req->maximumRecordSize; + + ODR_MASK_SET(breq->options, Z_Options_search); + ODR_MASK_SET(breq->options, Z_Options_present); + ODR_MASK_SET(breq->options, Z_Options_namedResultSets); + ODR_MASK_SET(breq->options, Z_Options_scan); - ODR_MASK_SET(req->protocolVersion, Z_ProtocolVersion_1); - ODR_MASK_SET(req->protocolVersion, Z_ProtocolVersion_2); - ODR_MASK_SET(req->protocolVersion, Z_ProtocolVersion_3); + ODR_MASK_SET(breq->protocolVersion, Z_ProtocolVersion_1); + ODR_MASK_SET(breq->protocolVersion, Z_ProtocolVersion_2); + ODR_MASK_SET(breq->protocolVersion, Z_ProtocolVersion_3); b->m_package->request() = init_apdu; @@ -443,6 +465,7 @@ void yf::Multi::Frontend::init(mp::Package &package, Z_GDU *gdu) ODR_MASK_SET(f_resp->options, Z_Options_search); ODR_MASK_SET(f_resp->options, Z_Options_present); ODR_MASK_SET(f_resp->options, Z_Options_namedResultSets); + ODR_MASK_SET(f_resp->options, Z_Options_scan); ODR_MASK_SET(f_resp->protocolVersion, Z_ProtocolVersion_1); ODR_MASK_SET(f_resp->protocolVersion, Z_ProtocolVersion_2); @@ -450,6 +473,9 @@ void yf::Multi::Frontend::init(mp::Package &package, Z_GDU *gdu) int no_failed = 0; int no_succeeded = 0; + + Odr_int preferredMessageSize = *req->preferredMessageSize; + Odr_int maximumRecordSize = *req->maximumRecordSize; for (bit = m_backend_list.begin(); bit != m_backend_list.end(); ) { PackagePtr p = (*bit)->m_package; @@ -461,8 +487,6 @@ void yf::Multi::Frontend::init(mp::Package &package, Z_GDU *gdu) bit = m_backend_list.erase(bit); continue; } - no_succeeded++; - Z_GDU *gdu = p->response().get(); if (gdu && gdu->which == Z_GDU_Z3950 && gdu->u.z3950->which == Z_APDU_initResponse) @@ -481,28 +505,44 @@ void yf::Multi::Frontend::init(mp::Package &package, Z_GDU *gdu) for (i = 0; i <= Z_ProtocolVersion_3; i++) if (!ODR_MASK_GET(b_resp->protocolVersion, i)) ODR_MASK_CLEAR(f_resp->protocolVersion, i); - // reject if any of the backends reject - if (!*b_resp->result) - *f_resp->result = 0; + if (*b_resp->result) + { + no_succeeded++; + if (preferredMessageSize > *b_resp->preferredMessageSize) + preferredMessageSize = *b_resp->preferredMessageSize; + if (maximumRecordSize > *b_resp->maximumRecordSize) + maximumRecordSize = *b_resp->maximumRecordSize; + } + else + { + if (!f_resp->userInformationField + && b_resp->userInformationField) + f_resp->userInformationField = b_resp->userInformationField; + no_failed++; + } } else - { - // if any target does not return init return that (close or - // similar ) - package.response() = p->response(); - return; - } + no_failed++; bit++; } + *f_resp->preferredMessageSize = preferredMessageSize; + *f_resp->maximumRecordSize = maximumRecordSize; + if (m_p->m_hide_unavailable) { if (no_succeeded == 0) + { + *f_resp->result = 0; package.session().close(); + } } else { if (no_failed) + { + *f_resp->result = 0; package.session().close(); + } } package.response() = f_apdu; } @@ -513,14 +553,14 @@ void yf::Multi::Frontend::search(mp::Package &package, Z_APDU *apdu_req) Z_SearchRequest *req = apdu_req->u.searchRequest; // save these for later - int smallSetUpperBound = *req->smallSetUpperBound; - int largeSetLowerBound = *req->largeSetLowerBound; - int mediumSetPresentNumber = *req->mediumSetPresentNumber; + Odr_int smallSetUpperBound = *req->smallSetUpperBound; + Odr_int largeSetLowerBound = *req->largeSetLowerBound; + Odr_int mediumSetPresentNumber = *req->mediumSetPresentNumber; // they are altered now - to disable piggyback *req->smallSetUpperBound = 0; *req->largeSetLowerBound = 1; - *req->mediumSetPresentNumber = 1; + *req->mediumSetPresentNumber = 0; int default_num_db = req->num_databaseNames; char **default_db = req->databaseNames; @@ -546,67 +586,115 @@ void yf::Multi::Frontend::search(mp::Package &package, Z_APDU *apdu_req) // look at each response FrontendSet resultSet(std::string(req->resultSetName)); - int result_set_size = 0; - Z_Records *z_records_diag = 0; // no diagnostics (yet) + mp::odr odr; + Odr_int result_set_size = 0; + Z_DiagRecs *z_diag = 0; + int no_successful = 0; + PackagePtr close_p; + for (bit = m_backend_list.begin(); bit != m_backend_list.end(); bit++) { PackagePtr p = (*bit)->m_package; - if (p->session().is_closed()) // if any backend closes, close frontend - package.session().close(); - + // save closing package for at least one target + if (p->session().is_closed()) + close_p = p; + Z_GDU *gdu = p->response().get(); if (gdu && gdu->which == Z_GDU_Z3950 && gdu->u.z3950->which == Z_APDU_searchResponse) { Z_APDU *b_apdu = gdu->u.z3950; Z_SearchResponse *b_resp = b_apdu->u.searchResponse; - + // see we get any errors (AKA diagnstics) if (b_resp->records) { - if (b_resp->records->which == Z_Records_NSD - || b_resp->records->which == Z_Records_multipleNSD) - z_records_diag = b_resp->records; - // we may set this multiple times (TOO BAD!) + if (b_resp->records->which == Z_Records_NSD) + { + if (!z_diag) + { + z_diag = (Z_DiagRecs *) + odr_malloc(odr, sizeof(*z_diag)); + z_diag->num_diagRecs = 0; + z_diag->diagRecs = (Z_DiagRec**) + odr_malloc(odr, sizeof(*z_diag->diagRecs)); + } + else + { + Z_DiagRec **n = (Z_DiagRec **) + odr_malloc(odr, + (1+z_diag->num_diagRecs) * sizeof(*n)); + memcpy(n, z_diag->diagRecs, z_diag->num_diagRecs + * sizeof(*n)); + z_diag->diagRecs = n; + } + Z_DiagRec *nr = (Z_DiagRec *) odr_malloc(odr, sizeof(*nr)); + nr->which = Z_DiagRec_defaultFormat; + nr->u.defaultFormat = + b_resp->records->u.nonSurrogateDiagnostic; + z_diag->diagRecs[z_diag->num_diagRecs++] = nr; + } + else if (b_resp->records->which == Z_Records_multipleNSD) + { + // we may set this multiple times (TOO BAD!) + z_diag = b_resp->records->u.multipleNonSurDiagnostics; + } + else + no_successful++; // probably piggyback } + else + no_successful++; // no records and no diagnostics BackendSet backendSet; backendSet.m_backend = *bit; backendSet.m_count = *b_resp->resultCount; result_set_size += *b_resp->resultCount; resultSet.m_backend_sets.push_back(backendSet); } - else - { - // if any target does not return search response - return that - package.response() = p->response(); - return; - } } - mp::odr odr; Z_APDU *f_apdu = odr.create_searchResponse(apdu_req, 0, 0); Z_SearchResponse *f_resp = f_apdu->u.searchResponse; + yaz_log(YLOG_LOG, "no_successful=%d is_closed=%s hide_errors=%s", + no_successful, + close_p ? "true" : "false", + m_p->m_hide_errors ? "true" : "false"); *f_resp->resultCount = result_set_size; - if (z_records_diag) + if (close_p && (no_successful == 0 || !m_p->m_hide_errors)) { - // search error - f_resp->records = z_records_diag; - package.response() = f_apdu; + package.session().close(); + package.response() = close_p->response(); return; } + if (z_diag && (no_successful == 0 || !m_p->m_hide_errors)) + { + f_resp->records = (Z_Records *) + odr_malloc(odr, sizeof(*f_resp->records)); + if (z_diag->num_diagRecs > 1) + { + f_resp->records->which = Z_Records_multipleNSD; + f_resp->records->u.multipleNonSurDiagnostics = z_diag; + } + else + { + f_resp->records->which = Z_Records_NSD; + f_resp->records->u.nonSurrogateDiagnostic = + z_diag->diagRecs[0]->u.defaultFormat; + } + } // assume OK m_sets[resultSet.m_setname] = resultSet; - int number; + Odr_int number; mp::util::piggyback(smallSetUpperBound, - largeSetLowerBound, - mediumSetPresentNumber, - result_set_size, - number); + largeSetLowerBound, + mediumSetPresentNumber, + 0, 0, + result_set_size, + number, 0); Package pp(package.session(), package.origin()); - if (number > 0) + if (z_diag == 0 && number > 0) { pp.copy_filter(package); Z_APDU *p_apdu = zget_APDU(odr, Z_APDU_presentRequest); @@ -766,6 +854,14 @@ void yf::Multi::Frontend::present(mp::Package &package, Z_APDU *apdu_req) f_resp->records = z_records_diag; *f_resp->presentStatus = Z_PresentStatus_failure; } + else if (number < 0 || (size_t) number > jobs.size()) + { + f_apdu = + odr.create_presentResponse( + apdu_req, + YAZ_BIB1_PRESENT_REQUEST_OUT_OF_RANGE, + 0); + } else { f_resp->records = (Z_Records *) odr_malloc(odr, sizeof(Z_Records)); @@ -897,6 +993,30 @@ Z_Entry *yf::Multi::ScanTermInfo::get_entry(ODR odr) return e; } +void yf::Multi::Frontend::relay_apdu(mp::Package &package, Z_APDU *apdu_req) +{ + std::list::const_iterator bit; + for (bit = m_backend_list.begin(); bit != m_backend_list.end(); bit++) + { + PackagePtr p = (*bit)->m_package; + mp::odr odr; + + p->request() = apdu_req; + p->copy_filter(package); + } + multi_move(m_backend_list); + for (bit = m_backend_list.begin(); bit != m_backend_list.end(); bit++) + { + PackagePtr p = (*bit)->m_package; + + if (p->session().is_closed()) // if any backend closes, close frontend + package.session().close(); + + package.response() = p->response(); + } +} + + void yf::Multi::Frontend::scan2(mp::Package &package, Z_APDU *apdu_req) { Z_ScanRequest *req = apdu_req->u.scanRequest; @@ -1164,6 +1284,10 @@ void yf::Multi::process(mp::Package &package) const { f->scan2(package, apdu); } + else if (apdu->which == Z_APDU_close) + { + f->relay_apdu(package, apdu); + } else { mp::odr odr; @@ -1178,7 +1302,8 @@ void yf::Multi::process(mp::Package &package) const m_p->release_frontend(package); } -void mp::filter::Multi::configure(const xmlNode * ptr, bool test_only) +void mp::filter::Multi::configure(const xmlNode * ptr, bool test_only, + const char *path) { for (ptr = ptr->children; ptr; ptr = ptr->next) { @@ -1186,14 +1311,21 @@ void mp::filter::Multi::configure(const xmlNode * ptr, bool test_only) continue; if (!strcmp((const char *) ptr->name, "target")) { - std::string route = mp::xml::get_route(ptr); + std::string auth; + std::string route = mp::xml::get_route(ptr, auth); std::string target = mp::xml::get_text(ptr); - m_p->m_route_patterns.push_back(Multi::Map(target, route)); + if (target.length() == 0) + target = route; + m_p->m_route_patterns.push_back(Multi::Map(target, route, auth)); } else if (!strcmp((const char *) ptr->name, "hideunavailable")) { m_p->m_hide_unavailable = true; } + else if (!strcmp((const char *) ptr->name, "hideerrors")) + { + m_p->m_hide_errors = true; + } else if (!strcmp((const char *) ptr->name, "mergetype")) { std::string mergetype = mp::xml::get_text(ptr);