+
+ if (z_records)
+ {
+ int condition = 0;
+ if (z_records->which == Z_Records_NSD)
+ {
+ condition =
+ get_diagnostic(z_records->u.nonSurrogateDiagnostic);
+ }
+ else if (z_records->which == Z_Records_multipleNSD)
+ {
+ if (z_records->u.multipleNonSurDiagnostics->num_diagRecs >= 1
+ &&
+
+ z_records->u.multipleNonSurDiagnostics->diagRecs[0]->which ==
+ Z_DiagRec_defaultFormat)
+ {
+ condition = get_diagnostic(
+ z_records->u.multipleNonSurDiagnostics->diagRecs[0]->u.defaultFormat);
+
+ }
+ }
+ if (m_p->m_restart && !session_restarted &&
+ condition == YAZ_BIB1_TEMPORARY_SYSTEM_ERROR)
+ {
+ package.log("session_shared", YLOG_LOG, "restart");
+ bc->remove_backend(found_backend);
+ session_restarted = true;
+ found_backend.reset();
+ goto restart;
+
+ }
+
+ if (condition)
+ {
+ mp::odr odr;
+ if (apdu_req->which == Z_APDU_searchRequest)
+ {
+ Z_APDU *f_apdu = odr.create_searchResponse(apdu_req,
+ 0, 0);
+ Z_SearchResponse *f_resp = f_apdu->u.searchResponse;
+ *f_resp->searchStatus = Z_SearchResponse_none;
+ f_resp->records = z_records;
+ package.response() = f_apdu;
+ }
+ if (apdu_req->which == Z_APDU_presentRequest)
+ {
+ Z_APDU *f_apdu = odr.create_presentResponse(apdu_req,
+ 0, 0);
+ Z_PresentResponse *f_resp = f_apdu->u.presentResponse;
+ f_resp->records = z_records;
+ package.response() = f_apdu;
+ }
+ bc->release_backend(found_backend);
+ return; // search error
+ }
+ }
+ if (m_p->m_restart && !session_restarted && new_set->m_result_set_size < 0)
+ {
+ package.log("session_shared", YLOG_LOG, "restart");
+ bc->remove_backend(found_backend);
+ session_restarted = true;
+ found_backend.reset();
+ goto restart;
+ }
+
+ found_set = new_set;
+ found_set->timestamp();
+ found_backend->m_sets.push_back(found_set);
+}
+
+int yf::SessionShared::Frontend::result_set_ref(ODR o,
+ const Databases &databases,
+ Z_RPNStructure *s,
+ std::string &rset)
+{
+ int ret = 0;
+ switch (s->which)
+ {
+ case Z_RPNStructure_simple:
+ if (s->u.simple->which == Z_Operand_resultSetId)
+ {
+ const char *id = s->u.simple->u.resultSetId;
+ rset = id;
+
+ FrontendSets::iterator fset_it = m_frontend_sets.find(id);
+ if (fset_it == m_frontend_sets.end())
+ {
+ ret = YAZ_BIB1_SPECIFIED_RESULT_SET_DOES_NOT_EXIST;
+ }
+ else if (fset_it->second->get_databases() != databases)
+ {
+ ret = YAZ_BIB1_SPECIFIED_RESULT_SET_DOES_NOT_EXIST;
+ }
+ else
+ {
+ yazpp_1::Yaz_Z_Query query = fset_it->second->get_query();
+ Z_Query *q = yaz_copy_Z_Query(query.get_Z_Query(), o);
+ if (q->which == Z_Query_type_1 || q->which == Z_Query_type_101)
+ {
+ s->which = q->u.type_1->RPNStructure->which;
+ s->u.simple = q->u.type_1->RPNStructure->u.simple;
+ }
+ else
+ {
+ ret = YAZ_BIB1_SPECIFIED_RESULT_SET_DOES_NOT_EXIST;
+ }
+ }
+ }
+ break;
+ case Z_RPNStructure_complex:
+ ret = result_set_ref(o, databases, s->u.complex->s1, rset);
+ if (!ret)
+ ret = result_set_ref(o, databases, s->u.complex->s2, rset);
+ break;
+ }
+ return ret;
+}
+
+void yf::SessionShared::Frontend::search(mp::Package &package,
+ Z_APDU *apdu_req)
+{
+ Z_SearchRequest *req = apdu_req->u.searchRequest;
+ FrontendSets::iterator fset_it =
+ m_frontend_sets.find(req->resultSetName);
+ if (fset_it != m_frontend_sets.end())
+ {
+ // result set already exist
+ // if replace indicator is off: we return diagnostic if
+ // result set already exist.
+ if (*req->replaceIndicator == 0)
+ {
+ mp::odr odr;
+ Z_APDU *apdu =
+ odr.create_searchResponse(
+ apdu_req,
+ YAZ_BIB1_RESULT_SET_EXISTS_AND_REPLACE_INDICATOR_OFF,
+ 0);
+ package.response() = apdu;
+ return;
+ }
+ m_frontend_sets.erase(fset_it);
+ }
+
+ Databases databases;
+ int i;
+ for (i = 0; i < req->num_databaseNames; i++)
+ databases.push_back(req->databaseNames[i]);
+
+
+ yazpp_1::Yaz_Z_Query query;
+ query.set_Z_Query(req->query);
+
+ Z_Query *q = query.get_Z_Query();
+ if (q->which == Z_Query_type_1 || q->which == Z_Query_type_101)
+ {
+ mp::odr odr;
+ std::string rset;
+ int diag = result_set_ref(odr, databases, q->u.type_1->RPNStructure,
+ rset);
+ if (diag)
+ {
+ Z_APDU *apdu =
+ odr.create_searchResponse(
+ apdu_req,
+ diag,
+ rset.c_str());
+ package.response() = apdu;
+ return;
+ }
+ query.set_Z_Query(q);
+ }
+
+ BackendSetPtr found_set; // null
+ BackendInstancePtr found_backend; // null
+
+ get_set(package, apdu_req, databases, query, found_backend, found_set);
+ if (!found_set)
+ return;
+
+ mp::odr odr;
+ Z_APDU *f_apdu = odr.create_searchResponse(apdu_req, 0, 0);
+ Z_SearchResponse *f_resp = f_apdu->u.searchResponse;
+ *f_resp->resultCount = found_set->m_result_set_size;
+ package.response() = f_apdu;
+
+ FrontendSetPtr fset(new FrontendSet(databases, query));
+ m_frontend_sets[req->resultSetName] = fset;
+
+ m_backend_class->release_backend(found_backend);
+}
+
+void yf::SessionShared::Frontend::present(mp::Package &package,
+ Z_APDU *apdu_req)
+{
+ mp::odr odr;
+ Z_PresentRequest *req = apdu_req->u.presentRequest;
+
+ FrontendSets::iterator fset_it =
+ m_frontend_sets.find(req->resultSetId);
+
+ if (fset_it == m_frontend_sets.end())
+ {
+ Z_APDU *apdu =
+ odr.create_presentResponse(
+ apdu_req,
+ YAZ_BIB1_SPECIFIED_RESULT_SET_DOES_NOT_EXIST,
+ req->resultSetId);
+ package.response() = apdu;
+ return;
+ }
+ FrontendSetPtr fset = fset_it->second;
+
+ Databases databases = fset->get_databases();
+ yazpp_1::Yaz_Z_Query query = fset->get_query();
+
+ BackendClassPtr bc = m_backend_class;
+ BackendSetPtr found_set; // null
+ BackendInstancePtr found_backend;
+
+ get_set(package, apdu_req, databases, query, found_backend, found_set);
+ if (!found_set)
+ return;
+
+ Z_NamePlusRecordList *npr_res = 0;
+ if (found_set->m_record_cache.lookup(odr, &npr_res,
+ *req->resultSetStartPoint,
+ *req->numberOfRecordsRequested,
+ req->preferredRecordSyntax,
+ req->recordComposition))
+ {
+ Z_APDU *f_apdu_res = odr.create_presentResponse(apdu_req, 0, 0);
+ Z_PresentResponse *f_resp = f_apdu_res->u.presentResponse;
+
+ yaz_log(YLOG_LOG, "Found " ODR_INT_PRINTF "+" ODR_INT_PRINTF
+ " records in cache %p",
+ *req->resultSetStartPoint,
+ *req->numberOfRecordsRequested,
+ &found_set->m_record_cache);
+
+ *f_resp->numberOfRecordsReturned = *req->numberOfRecordsRequested;
+ *f_resp->nextResultSetPosition =
+ *req->resultSetStartPoint + *req->numberOfRecordsRequested;
+ // f_resp->presentStatus assumed OK.
+ f_resp->records = (Z_Records *) odr_malloc(odr, sizeof(Z_Records));
+ f_resp->records->which = Z_Records_DBOSD;
+ f_resp->records->u.databaseOrSurDiagnostics = npr_res;
+ package.response() = f_apdu_res;
+ bc->release_backend(found_backend);
+ return;
+ }
+
+ found_backend->timestamp();
+
+ Z_APDU *p_apdu = zget_APDU(odr, Z_APDU_presentRequest);
+ Z_PresentRequest *p_req = p_apdu->u.presentRequest;
+ p_req->preferredRecordSyntax = req->preferredRecordSyntax;
+ p_req->resultSetId = odr_strdup(odr, found_set->m_result_set_id.c_str());
+ *p_req->resultSetStartPoint = *req->resultSetStartPoint;
+ *p_req->numberOfRecordsRequested = *req->numberOfRecordsRequested;
+ p_req->preferredRecordSyntax = req->preferredRecordSyntax;
+ p_req->recordComposition = req->recordComposition;
+
+ Package present_package(found_backend->m_session, package.origin());
+ present_package.copy_filter(package);
+
+ present_package.request() = p_apdu;
+
+ present_package.move();
+
+ Z_GDU *gdu = present_package.response().get();
+ if (!present_package.session().is_closed()
+ && gdu && gdu->which == Z_GDU_Z3950
+ && gdu->u.z3950->which == Z_APDU_presentResponse)
+ {
+ Z_PresentResponse *b_resp = gdu->u.z3950->u.presentResponse;
+ Z_APDU *f_apdu_res = odr.create_presentResponse(apdu_req, 0, 0);
+ Z_PresentResponse *f_resp = f_apdu_res->u.presentResponse;
+
+ f_resp->numberOfRecordsReturned = b_resp->numberOfRecordsReturned;
+ f_resp->nextResultSetPosition = b_resp->nextResultSetPosition;
+ f_resp->presentStatus= b_resp->presentStatus;
+ f_resp->records = b_resp->records;
+ f_resp->otherInfo = b_resp->otherInfo;
+ package.response() = f_apdu_res;
+
+ if (b_resp->records && b_resp->records->which == Z_Records_DBOSD)
+ {
+ yaz_log(YLOG_LOG, "Adding " ODR_INT_PRINTF "+" ODR_INT_PRINTF
+ " records to cache %p",
+ *req->resultSetStartPoint,
+ *f_resp->numberOfRecordsReturned,
+ &found_set->m_record_cache);
+ found_set->m_record_cache.add(
+ odr,
+ b_resp->records->u.databaseOrSurDiagnostics,
+ *req->resultSetStartPoint,
+ *f_resp->numberOfRecordsReturned);
+ }
+ bc->release_backend(found_backend);
+ }
+ else
+ {
+ bc->remove_backend(found_backend);
+ Z_APDU *f_apdu_res =
+ odr.create_presentResponse(
+ apdu_req, YAZ_BIB1_TEMPORARY_SYSTEM_ERROR,
+ "session_shared: target closed connection during present");
+ package.response() = f_apdu_res;
+ }
+}
+
+void yf::SessionShared::Frontend::scan(mp::Package &frontend_package,
+ Z_APDU *apdu_req)
+{
+ BackendClassPtr bc = m_backend_class;
+ BackendInstancePtr backend = bc->get_backend(frontend_package);
+ if (!backend)
+ {
+ mp::odr odr;
+ Z_APDU *apdu = odr.create_scanResponse(
+ apdu_req, YAZ_BIB1_TEMPORARY_SYSTEM_ERROR,
+ "session_shared: could not create backend");
+ frontend_package.response() = apdu;
+ }
+ else
+ {
+ Package scan_package(backend->m_session, frontend_package.origin());
+ backend->timestamp();
+ scan_package.copy_filter(frontend_package);
+ scan_package.request() = apdu_req;
+ scan_package.move();
+ frontend_package.response() = scan_package.response();
+ if (scan_package.session().is_closed())
+ {
+ frontend_package.session().close();
+ bc->remove_backend(backend);
+ }
+ else
+ bc->release_backend(backend);
+ }
+}
+
+yf::SessionShared::Worker::Worker(SessionShared::Rep *rep) : m_p(rep)
+{
+}
+
+void yf::SessionShared::Worker::operator() (void)
+{
+ m_p->expire();
+}
+
+void yf::SessionShared::BackendClass::expire_class()
+{
+ time_t now;
+ time(&now);
+ boost::mutex::scoped_lock lock(m_mutex_backend_class);
+ BackendInstanceList::iterator bit = m_backend_list.begin();
+ while (bit != m_backend_list.end())
+ {
+ time_t last_use = (*bit)->m_time_last_use;
+
+ if ((*bit)->m_in_use)
+ {
+ bit++;
+ }
+ else if (now < last_use || now - last_use > m_backend_expiry_ttl)
+ {
+ mp::odr odr;
+ (*bit)->m_close_package->response() = odr.create_close(
+ 0, Z_Close_lackOfActivity, 0);
+ (*bit)->m_close_package->session().close();
+ (*bit)->m_close_package->move();
+
+ bit = m_backend_list.erase(bit);
+ }
+ else
+ {
+ bit++;
+ }
+ }
+}
+
+void yf::SessionShared::Rep::expire()
+{
+ while (true)
+ {
+ boost::xtime xt;
+ boost::xtime_get(&xt,
+#if BOOST_VERSION >= 105000
+ boost::TIME_UTC_
+#else
+ boost::TIME_UTC