+ yazpp_1::Yaz_Z_Query query;
+ query.set_Z_Query(req->query);
+ Databases databases;
+ int i;
+ for (i = 0; i<req->num_databaseNames; i++)
+ databases.push_back(req->databaseNames[i]);
+
+ 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 %d+%d 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;
+ }
+
+ 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 %d+%d 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, 0);
+ 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, 0);
+ frontend_package.response() = apdu;
+ }
+ else
+ {
+ Package scan_package(backend->m_session, frontend_package.origin());
+ 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)
+ || (now < last_use))
+ {
+ 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)