metaproxy_1::filter::SessionShared::Frontend Struct Reference

Collaboration diagram for metaproxy_1::filter::SessionShared::Frontend:

Public Member Functions
	Frontend (Rep *rep)
	~Frontend ()
void	search (Package &package, Z_APDU *apdu)
void	present (Package &package, Z_APDU *apdu)
void	scan (Package &package, Z_APDU *apdu)
int	result_set_ref (ODR o, const Databases &databases, Z_RPNStructure *s, std::string &rset)
void	get_set (mp::Package &package, const Z_APDU *apdu_req, const Databases &databases, yazpp_1::Yaz_Z_Query &query, BackendInstancePtr &found_backend, BackendSetPtr &found_set)
void	override_set (BackendInstancePtr &found_backend, std::string &result_set_id, const Databases &databases, bool out_of_sessions)

Public Attributes
bool	m_is_virtual
bool	m_in_use
Z_Options	m_init_options
Rep *	m_p
BackendClassPtr	m_backend_class
FrontendSets	m_frontend_sets

Detailed Description

Definition at line 166 of file filter_session_shared.cpp.

Constructor & Destructor Documentation

Frontend()

mp::filter::SessionShared::Frontend::Frontend

(

Rep *

rep

)

Definition at line 1436 of file filter_session_shared.cpp.

                                          : m_is_virtual(false), m_p(rep)
{
}

~Frontend()

mp::filter::SessionShared::Frontend::~Frontend

(

)

Definition at line 1440 of file filter_session_shared.cpp.

{
}

Member Function Documentation

get_set()

void mp::filter::SessionShared::Frontend::get_set	(	mp::Package &	package,
		const Z_APDU *	apdu_req,
		const Databases &	databases,
		yazpp_1::Yaz_Z_Query &	query,
		BackendInstancePtr &	found_backend,
		BackendSetPtr &	found_set
	)

Definition at line 809 of file filter_session_shared.cpp.

{
    bool session_restarted = false;
    Z_OtherInformation *additionalSearchInfo = 0;
 
    if (apdu_req->which == Z_APDU_searchRequest)
        additionalSearchInfo = apdu_req->u.searchRequest->additionalSearchInfo;
 
restart:
    std::string result_set_id;
    bool out_of_sessions = false;
    BackendClassPtr bc = m_backend_class;
    {
        boost::mutex::scoped_lock lock(bc->m_mutex_backend_class);
 
        if ((int) bc->m_backend_list.size() >= m_p->m_session_max)
            out_of_sessions = true;
 
        if (m_p->m_optimize_search)
        {
            // look at each backend and see if we have a similar search
            BackendInstanceList::const_iterator it = bc->m_backend_list.begin();
            while (it != bc->m_backend_list.end())
            {
                bool restart = false;
                BackendSetList::const_iterator set_it = (*it)->m_sets.begin();
                for (; set_it != (*it)->m_sets.end(); set_it++)
                {
                    // for real present request we don't care
                    // if additionalSearchInfo matches: same records
                    if (mp::util::match((*set_it)->m_databases, databases)
                        && query.match(&(*set_it)->m_query)
                        && (apdu_req->which != Z_APDU_searchRequest ||
                            yaz_compare_z_OtherInformation(
                                additionalSearchInfo,
                                (*set_it)->additionalSearchInfoRequest)))
                    {
                        if ((*it)->m_in_use)
                        {
                            bc->m_cond_set_ready.wait(lock);
                            restart = true;
                            break;
                        }
                        else
                        {
                            found_set = *set_it;
                            found_backend = *it;
                            bc->use_backend(found_backend);
                            // found matching set. No need to search again
                            return;
                        }
                    }
                }
                if (restart)
                    it = bc->m_backend_list.begin();
                else
                    it++;
            }
        }
        override_set(found_backend, result_set_id, databases, out_of_sessions);
        if (found_backend)
            bc->use_backend(found_backend);
    }
    if (!found_backend)
    {
        int code;
        std::string addinfo;
        // create a new backend set (and new set) if we're not out of sessions
        if (!out_of_sessions)
            found_backend = bc->create_backend(package, code, addinfo);
        if (!found_backend)
        {
            Z_APDU *f_apdu = 0;
            mp::odr odr;
 
            if (out_of_sessions)
            {
                code = YAZ_BIB1_TEMPORARY_SYSTEM_ERROR;
                addinfo = "session_shared: all sessions in use";
            }
            else
            {
                if (code == 0)
                    code = YAZ_BIB1_TEMPORARY_SYSTEM_ERROR;
                if (addinfo.length() == 0)
                    addinfo = "session_shared: could not create backend";
            }
            if (apdu_req->which == Z_APDU_searchRequest)
            {
                f_apdu = odr.create_searchResponse(
                    apdu_req, YAZ_BIB1_TEMPORARY_SYSTEM_ERROR, addinfo.c_str());
            }
            else if (apdu_req->which == Z_APDU_presentRequest)
            {
                f_apdu = odr.create_presentResponse(
                    apdu_req, YAZ_BIB1_TEMPORARY_SYSTEM_ERROR, addinfo.c_str());
            }
            else
            {
                f_apdu = odr.create_close(
                    apdu_req, YAZ_BIB1_TEMPORARY_SYSTEM_ERROR, addinfo.c_str());
            }
            package.response() = f_apdu;
            return;
        }
        if (bc->m_named_result_sets)
        {
            result_set_id = boost::io::str(
                boost::format("%1%") % found_backend->m_result_set_sequence);
            found_backend->m_result_set_sequence++;
        }
        else
            result_set_id = "default";
    }
    found_backend->timestamp();
 
    // we must search ...
    BackendSetPtr new_set(new BackendSet(result_set_id,
                                         databases, query,
                                         additionalSearchInfo));
 
    found_set = new_set;
    found_set->timestamp();
 
    Z_Records *z_records = 0;
 
    Package search_package(found_backend->m_session, package.origin());
    search_package.copy_filter(package);
 
    if (!new_set->search(package, search_package,
                         apdu_req, found_backend, &z_records))
    {
        bc->remove_backend(found_backend);
        found_set.reset();
        return; // search error
    }
 
    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);
            found_set.reset();
            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_backend->m_sets.push_back(found_set);
}

References get_diagnostic(), and metaproxy_1::filter::SessionShared::m_p.

Here is the call graph for this function:

override_set()

void mp::filter::SessionShared::Frontend::override_set	(	BackendInstancePtr &	found_backend,
		std::string &	result_set_id,
		const Databases &	databases,
		bool	out_of_sessions
	)

Definition at line 755 of file filter_session_shared.cpp.

{
    BackendClassPtr bc = m_backend_class;
    BackendInstanceList::const_iterator it = bc->m_backend_list.begin();
    time_t now;
    time(&now);
 
    size_t max_sets = bc->m_named_result_sets ? bc->m_backend_set_max : 1;
    for (; it != bc->m_backend_list.end(); it++)
    {
        if (!(*it)->m_in_use)
        {
            BackendSetList::iterator set_it = (*it)->m_sets.begin();
            for (; set_it != (*it)->m_sets.end(); set_it++)
            {
                bool same_databases = mp::util::match((*set_it)->m_databases,
                                                     databases);
                if ((max_sets > 1 || same_databases)
                    &&
                    (out_of_sessions ||
                     now < (*set_it)->m_time_last_use ||
                     now - (*set_it)->m_time_last_use >= bc->m_backend_set_ttl))
                {
                    found_backend = *it;
                    result_set_id = (*set_it)->m_result_set_id;
                    found_backend->m_sets.erase(set_it);
                    return;
                }
            }
        }
    }
    for (it = bc->m_backend_list.begin(); it != bc->m_backend_list.end(); it++)
    {
        if (!(*it)->m_in_use && (*it)->m_sets.size() < max_sets)
        {
            found_backend = *it;
            if (bc->m_named_result_sets)
            {
                result_set_id = boost::io::str(
                    boost::format("%1%") %
                    found_backend->m_result_set_sequence);
                found_backend->m_result_set_sequence++;
            }
            else
                result_set_id = "default";
            return;
        }
    }
}

present()

void mp::filter::SessionShared::Frontend::present	(	Package &	package,
		Z_APDU *	apdu
	)

Definition at line 1142 of file filter_session_shared.cpp.

{
    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;
    // record_cache.lookup types are int's. Avoid non-fitting values
    if (*req->resultSetStartPoint > 0
        && *req->resultSetStartPoint < INT_MAX
        && *req->numberOfRecordsRequested > 0
        && *req->numberOfRecordsRequested < INT_MAX
        && 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)
        {
            Z_NamePlusRecordList *npr =
                b_resp->records->u.databaseOrSurDiagnostics;
            // record_cache.add types are int's. Avoid non-fitting values
            if (*req->resultSetStartPoint > 0
                && npr->num_records + *req->resultSetStartPoint < INT_MAX)
            {
#if 0
                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);
#endif
                found_set->m_record_cache.add(
                    odr, npr, *req->resultSetStartPoint,
                    p_req->recordComposition);
            }
        }
        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;
    }
}

result_set_ref()

int mp::filter::SessionShared::Frontend::result_set_ref	(	ODR	o,
		const Databases &	databases,
		Z_RPNStructure *	s,
		std::string &	rset
	)

Definition at line 1019 of file filter_session_shared.cpp.

{
    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 (!mp::util::match(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;
}

scan()

void mp::filter::SessionShared::Frontend::scan	(	Package &	package,
		Z_APDU *	apdu
	)

Definition at line 1274 of file filter_session_shared.cpp.

{
    BackendClassPtr bc = m_backend_class;
    int code;
    std::string addinfo;
    BackendInstancePtr backend = bc->get_backend(frontend_package,
                                                 code, addinfo);
    if (!backend)
    {
        mp::odr odr;
        if (code == 0)
            code = YAZ_BIB1_TEMPORARY_SYSTEM_ERROR;
        if (addinfo.length() == 0)
            addinfo = "session_shared: could not create backend";
        Z_APDU *apdu = odr.create_scanResponse(
            apdu_req, code, addinfo.c_str());
        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);
    }
}

search()

void mp::filter::SessionShared::Frontend::search	(	Package &	package,
		Z_APDU *	apdu
	)

Definition at line 1068 of file filter_session_shared.cpp.

{
    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;
    f_resp->additionalSearchInfo = found_set->additionalSearchInfoResponse;
    package.response() = f_apdu;
 
    FrontendSetPtr fset(new FrontendSet(databases, query));
    m_frontend_sets[req->resultSetName] = fset;
 
    m_backend_class->release_backend(found_backend);
}

Member Data Documentation

m_backend_class

BackendClassPtr metaproxy_1::filter::SessionShared::Frontend::m_backend_class

Definition at line 191 of file filter_session_shared.cpp.

m_frontend_sets

FrontendSets metaproxy_1::filter::SessionShared::Frontend::m_frontend_sets

Definition at line 192 of file filter_session_shared.cpp.

m_in_use

bool metaproxy_1::filter::SessionShared::Frontend::m_in_use

Definition at line 170 of file filter_session_shared.cpp.

m_init_options

Z_Options metaproxy_1::filter::SessionShared::Frontend::m_init_options

Definition at line 171 of file filter_session_shared.cpp.

m_is_virtual

bool metaproxy_1::filter::SessionShared::Frontend::m_is_virtual

Definition at line 169 of file filter_session_shared.cpp.

m_p

Rep* metaproxy_1::filter::SessionShared::Frontend::m_p

Definition at line 190 of file filter_session_shared.cpp.

---

The documentation for this struct was generated from the following file:

• filter_session_shared.cpp