metaproxy_1::filter::VirtualDB::Frontend Struct Reference

Collaboration diagram for metaproxy_1::filter::VirtualDB::Frontend:

Public Types
typedef std::map< std::string, VirtualDB::Set >::iterator	Sets_it

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	relay_apdu (Package &package, Z_APDU *apdu)
void	close (Package &package)
void	fixup_package (Package &p, BackendPtr b)
void	fixup_npr_record (ODR odr, Z_NamePlusRecord *npr, BackendPtr b)
void	fixup_npr_records (ODR odr, Z_Records *records, BackendPtr b)
BackendPtr	create_backend_from_databases (std::list< std::string > databases, int &error_code, std::string &failing_database)
BackendPtr	init_backend (std::list< std::string > database, Package &package, int &error_code, std::string &addinfo)

Public Attributes
mp::Session	m_session
bool	m_is_virtual
bool	m_in_use
yazpp_1::GDU	m_init_gdu
std::list< BackendPtr >	m_backend_list
std::map< std::string, VirtualDB::Set >	m_sets
Rep *	m_p

Detailed Description

Definition at line 70 of file filter_virt_db.cpp.

Member Typedef Documentation

Sets_it

typedef std::map<std::string,VirtualDB::Set>::iterator metaproxy_1::filter::VirtualDB::Frontend::Sets_it

Definition at line 86 of file filter_virt_db.cpp.

Constructor & Destructor Documentation

Frontend()

mp::filter::VirtualDB::Frontend::Frontend

(

Rep *

rep

)

Definition at line 380 of file filter_virt_db.cpp.

{
    m_p = rep;
    m_is_virtual = false;
}

~Frontend()

mp::filter::VirtualDB::Frontend::~Frontend

(

)

Definition at line 400 of file filter_virt_db.cpp.

{
}

Member Function Documentation

close()

void mp::filter::VirtualDB::Frontend::close

(

Package &

package

)

Definition at line 386 of file filter_virt_db.cpp.

{
    std::list<BackendPtr>::const_iterator b_it;
 
    for (b_it = m_backend_list.begin(); b_it != m_backend_list.end(); b_it++)
    {
        (*b_it)->m_backend_session.close();
        Package close_package((*b_it)->m_backend_session, package.origin());
        close_package.copy_filter(package);
        close_package.move((*b_it)->m_route);
    }
    m_backend_list.clear();
}

create_backend_from_databases()

yf::VirtualDB::BackendPtr mp::filter::VirtualDB::Frontend::create_backend_from_databases	(	std::list< std::string >	databases,
		int &	error_code,
		std::string &	failing_database
	)

Definition at line 122 of file filter_virt_db.cpp.

{
    BackendPtr b(new Backend);
    std::list<std::string>::const_iterator db_it = databases.begin();
 
    b->m_frontend_databases = databases;
    b->m_named_result_sets = false;
 
    bool first_route = true;
 
    std::map<std::string,bool> targets_dedup;
    for (; db_it != databases.end(); db_it++)
    {
        std::list<VirtualDB::Map>::const_iterator map_it;
        map_it = m_p->m_maps.begin();
        while (map_it != m_p->m_maps.end())
        {
            if (map_it->match(*db_it))
                break;
            map_it++;
        }
 
        if (map_it == m_p->m_maps.end())  // database not found
        {
            error_code = YAZ_BIB1_DATABASE_DOES_NOT_EXIST;
            addinfo = *db_it;
            BackendPtr ptr;
            return ptr;
        }
        std::list<std::string>::const_iterator t_it =
            map_it->m_targets.begin();
        for (; t_it != map_it->m_targets.end(); t_it++) {
            if (!targets_dedup[*t_it])
            {
                targets_dedup[*t_it] = true;
                b->m_targets.push_back(*t_it);
            }
        }
 
        // see if we have a route conflict.
        if (!first_route && b->m_route != map_it->m_route)
        {
            // we have a conflict.. routing must be same for all
            error_code =  YAZ_BIB1_COMBI_OF_SPECIFIED_DATABASES_UNSUPP;
            BackendPtr ptr;
            return ptr;
        }
        b->m_route = map_it->m_route;
        first_route = false;
    }
    return b;
}

fixup_npr_record()

void mp::filter::VirtualDB::Frontend::fixup_npr_record	(	ODR	odr,
		Z_NamePlusRecord *	npr,
		BackendPtr	b
	)

Definition at line 500 of file filter_virt_db.cpp.

{
    if (npr->databaseName)
    {
        std::string b_database = std::string(npr->databaseName);
 
        // consider each of the frontend databases..
        std::list<std::string>::const_iterator db_it;
        for (db_it = b->m_frontend_databases.begin();
             db_it != b->m_frontend_databases.end(); db_it++)
        {
            // see which target it corresponds to.. (if any)
            std::list<VirtualDB::Map>::const_iterator map_it =
                m_p->m_maps.begin();
            while (map_it != m_p->m_maps.end())
            {
                if (map_it->match(*db_it))
                    break;
                map_it++;
            }
            if (map_it != m_p->m_maps.end())
            {
                std::list<std::string>::const_iterator t
                    = map_it->m_targets.begin();
                while (t != map_it->m_targets.end())
                {
                    if (*t == b_database)
                    {
                        npr->databaseName = odr_strdup(odr, (*db_it).c_str());
                        return;
                    }
                    t++;
                }
            }
 
        }
        db_it = b->m_frontend_databases.begin();
        if (db_it != b->m_frontend_databases.end())
        {
            std::string database = *db_it;
            npr->databaseName = odr_strdup(odr, database.c_str());
        }
    }
}

fixup_npr_records()

void mp::filter::VirtualDB::Frontend::fixup_npr_records	(	ODR	odr,
		Z_Records *	records,
		BackendPtr	b
	)

Definition at line 546 of file filter_virt_db.cpp.

{
    if (records && records->which == Z_Records_DBOSD)
    {
        Z_NamePlusRecordList *nprlist = records->u.databaseOrSurDiagnostics;
        int i;
        for (i = 0; i < nprlist->num_records; i++)
        {
            fixup_npr_record(odr, nprlist->records[i], b);
        }
    }
}

fixup_package()

void mp::filter::VirtualDB::Frontend::fixup_package	(	Package &	p,
		BackendPtr	b
	)

Definition at line 560 of file filter_virt_db.cpp.

{
    Z_GDU *gdu = p.response().get();
    mp::odr odr;
 
    if (gdu && gdu->which == Z_GDU_Z3950)
    {
        Z_APDU *apdu = gdu->u.z3950;
        if (apdu->which == Z_APDU_presentResponse)
        {
            fixup_npr_records(odr, apdu->u.presentResponse->records, b);
            p.response() = gdu;
        }
        else if (apdu->which == Z_APDU_searchResponse)
        {
            fixup_npr_records(odr,  apdu->u.searchResponse->records, b);
            p.response() = gdu;
        }
    }
}

init_backend()

yf::VirtualDB::BackendPtr mp::filter::VirtualDB::Frontend::init_backend	(	std::list< std::string >	database,
		Package &	package,
		int &	error_code,
		std::string &	addinfo
	)

Definition at line 176 of file filter_virt_db.cpp.

{
    BackendPtr b = create_backend_from_databases(databases, error_code,
                                                 addinfo);
    if (!b)
        return b;
    Package init_package(b->m_backend_session, package.origin());
    init_package.copy_filter(package);
 
    mp::odr odr;
 
    Z_APDU *init_apdu = zget_APDU(odr, Z_APDU_initRequest);
 
    mp::util::set_vhost_otherinfo(&init_apdu->u.initRequest->otherInfo, odr,
                                   b->m_targets);
    Z_InitRequest *req = init_apdu->u.initRequest;
 
    // copy stuff from Frontend Init Request
    Z_GDU *org_gdu = m_init_gdu.get();
    Z_InitRequest *org_init = org_gdu->u.z3950->u.initRequest;
 
 
    const char *peer_name = yaz_oi_get_string_oid(
        &org_init->otherInfo, yaz_oid_userinfo_client_ip, 1, 0);
    if (peer_name)
        yaz_oi_set_string_oid(&init_apdu->u.initRequest->otherInfo, odr,
                              yaz_oid_userinfo_client_ip, 1, peer_name);
 
    req->idAuthentication = org_init->idAuthentication;
    req->implementationId = org_init->implementationId;
    req->implementationName = org_init->implementationName;
    req->implementationVersion = org_init->implementationVersion;
    *req->preferredMessageSize = *org_init->preferredMessageSize;
    *req->maximumRecordSize = *org_init->maximumRecordSize;
 
    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);
 
    ODR_MASK_SET(req->protocolVersion, Z_ProtocolVersion_1);
    ODR_MASK_SET(req->protocolVersion, Z_ProtocolVersion_2);
    ODR_MASK_SET(req->protocolVersion, Z_ProtocolVersion_3);
 
    init_package.request() = init_apdu;
 
    init_package.move(b->m_route);  // sending init
 
    Z_GDU *gdu = init_package.response().get();
    // we hope to get an init response
    error_code = 0;
    if (gdu && gdu->which == Z_GDU_Z3950
        && gdu->u.z3950->which == Z_APDU_initResponse)
    {
        Z_InitResponse *res = gdu->u.z3950->u.initResponse;
        if (ODR_MASK_GET(res->options, Z_Options_namedResultSets))
        {
            b->m_named_result_sets = true;
        }
        if (*res->result && !init_package.session().is_closed())
        {
            m_backend_list.push_back(b);
            return b;
        }
        mp::util::get_init_diagnostics(res, error_code, addinfo);
    }
    if (error_code == 0)
    {
        std::list<std::string>::const_iterator db_it = databases.begin();
        error_code = YAZ_BIB1_ACCESS_TO_SPECIFIED_DATABASE_DENIED;
        if (db_it != databases.end())
            addinfo = *db_it;
    }
    if (!init_package.session().is_closed())
    {
        Package close_package(b->m_backend_session, package.origin());
        close_package.copy_filter(package);
        close_package.session().close();
        close_package.move(b->m_route);  // closing it
    }
    BackendPtr null;
    return null;
}

present()

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

Definition at line 581 of file filter_virt_db.cpp.

{
    yazpp_1::GDU ngdu(apdu_req);
    Z_PresentRequest *req = ngdu.get()->u.z3950->u.presentRequest;
    std::string resultSetId = req->resultSetId;
    mp::odr odr;
 
    Sets_it sets_it = m_sets.find(resultSetId);
    if (sets_it == m_sets.end())
    {
        Z_APDU *apdu =
            odr.create_presentResponse(
                apdu_req,
                YAZ_BIB1_SPECIFIED_RESULT_SET_DOES_NOT_EXIST,
                resultSetId.c_str());
        package.response() = apdu;
        return;
    }
    Session *id =
        new mp::Session(sets_it->second.m_backend->m_backend_session);
 
    // sending present to backend
    Package present_package(*id, package.origin());
    present_package.copy_filter(package);
 
    req->resultSetId = odr_strdup(odr, sets_it->second.m_setname.c_str());
 
    present_package.request() = ngdu;
 
    present_package.move(sets_it->second.m_backend->m_route);
 
    fixup_package(present_package, sets_it->second.m_backend);
 
    if (present_package.session().is_closed())
    {
        package.response() = present_package.response();
        package.session().close();
    }
    else
    {
        package.response() = present_package.response();
    }
    delete id;
}

relay_apdu()

int mp::filter::VirtualDB::Frontend::relay_apdu	(	Package &	package,
		Z_APDU *	apdu
	)

Definition at line 626 of file filter_virt_db.cpp.

{
    int no = 0;
    std::list<BackendPtr>::const_iterator map_it;
    map_it = m_backend_list.begin();
    for (; map_it != m_backend_list.end(); map_it++)
    {
        BackendPtr b = *map_it;
 
        Package relay_package(b->m_backend_session, package.origin());
        relay_package.copy_filter(package);
 
        relay_package.request() = yazpp_1::GDU(apdu_req);
 
        relay_package.move(b->m_route);
        package.response() = relay_package.response();
        no++;
    }
    return no;
}

scan()

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

Definition at line 647 of file filter_virt_db.cpp.

{
    yazpp_1::GDU ngdu(apdu_req);
    Z_ScanRequest *req = ngdu.get()->u.z3950->u.scanRequest;
    std::string vhost;
    mp::odr odr;
 
    std::list<std::string> databases;
    int i;
    for (i = 0; i<req->num_databaseNames; i++)
        databases.push_back(req->databaseNames[i]);
 
    BackendPtr b;
    // pick up any existing backend with a database match
    std::list<BackendPtr>::const_iterator map_it;
    map_it = m_backend_list.begin();
    for (; map_it != m_backend_list.end(); map_it++)
    {
        BackendPtr tmp = *map_it;
        if (mp::util::match(tmp->m_frontend_databases, databases))
            break;
    }
    if (map_it != m_backend_list.end())
        b = *map_it;
    if (!b)  // no backend yet. Must create a new one
    {
        int error_code;
        std::string addinfo;
        b = init_backend(databases, package, error_code, addinfo);
        if (!b)
        {
            // did not get a backend (unavailable somehow?)
            Z_APDU *apdu =
                odr.create_scanResponse(
                    apdu_req, error_code, addinfo.c_str());
            package.response() = apdu;
 
            return;
        }
    }
    // sending scan to backend
    Package scan_package(b->m_backend_session, package.origin());
 
    scan_package.copy_filter(package);
 
    // pick first targets spec and move the databases from it ..
    std::list<std::string>::const_iterator t_it = b->m_targets.begin();
    if (t_it != b->m_targets.end())
    {
        mp::util::set_databases_from_zurl(odr, *t_it,
                                                &req->num_databaseNames,
                                                &req->databaseNames);
    }
 
    scan_package.request() = ngdu;
 
    scan_package.move(b->m_route);
 
    if (scan_package.session().is_closed())
    {
        package.response() = scan_package.response();
        package.session().close();
        return;
    }
    package.response() = scan_package.response();
}

search()

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

Definition at line 262 of file filter_virt_db.cpp.

{
    yazpp_1::GDU ngdu(apdu_req);
    Z_SearchRequest *req = ngdu.get()->u.z3950->u.searchRequest;
    std::string vhost;
    std::string resultSetId = req->resultSetName;
    mp::odr odr;
 
    std::list<std::string> databases;
    int i;
    for (i = 0; i<req->num_databaseNames; i++)
        databases.push_back(req->databaseNames[i]);
 
    Sets_it sets_it = m_sets.find(req->resultSetName);
    bool override_set = false;
    if (sets_it != m_sets.end())
    {
        // result set already exist
        // if replace indicator is off: we return diagnostic if
        // result set already exist.
        if (*req->replaceIndicator == 0)
        {
            Z_APDU *apdu =
                odr.create_searchResponse(
                    apdu_req,
                    YAZ_BIB1_RESULT_SET_EXISTS_AND_REPLACE_INDICATOR_OFF,
                    0);
            package.response() = apdu;
 
            return;
        }
        override_set = true;
    }
    // pick up any existing database with named result sets ..
    // or one if we are overriding it
    BackendPtr b; // null for now
    std::list<BackendPtr>::const_iterator map_it;
    map_it = m_backend_list.begin();
    for (; map_it != m_backend_list.end(); map_it++)
    {
        BackendPtr tmp = *map_it;
        if (mp::util::match(tmp->m_frontend_databases, databases) &&
            (tmp->m_named_result_sets || override_set))
        {
            b = *map_it;
            break;
        }
    }
    if (!b)  // no backend yet. Must create a new one
    {
        int error_code;
        std::string addinfo;
        b = init_backend(databases, package, error_code, addinfo);
        if (!b)
        {
            // did not get a backend (unavailable somehow?)
 
            Z_APDU *apdu =
                odr.create_searchResponse(
                    apdu_req, error_code, addinfo.c_str());
            package.response() = apdu;
            return;
        }
    }
    m_sets.erase(req->resultSetName);
    // sending search to backend
    Package search_package(b->m_backend_session, package.origin());
 
    search_package.copy_filter(package);
 
    std::string backend_setname;
    if (b->m_named_result_sets)
    {
        backend_setname = std::string(req->resultSetName);
    }
    else
    {
        backend_setname = "default";
        req->resultSetName = odr_strdup(odr, backend_setname.c_str());
    }
 
    // pick first targets spec and move the databases from it ..
    std::list<std::string>::const_iterator t_it = b->m_targets.begin();
    if (t_it != b->m_targets.end())
    {
        mp::util::set_databases_from_zurl(odr, *t_it,
                                                &req->num_databaseNames,
                                                &req->databaseNames);
    }
 
    *req->replaceIndicator = 1;
 
    search_package.request() = ngdu;
 
    search_package.move(b->m_route);
 
    if (search_package.session().is_closed())
    {
        package.response() = search_package.response();
        package.session().close();
        return;
    }
 
    Z_GDU *gdu = search_package.response().get();
    if (gdu && gdu->which == Z_GDU_Z3950
        && gdu->u.z3950->which == Z_APDU_searchResponse)
    {
        Z_SearchResponse *b_resp = gdu->u.z3950->u.searchResponse;
        Z_Records *z_records = b_resp->records;
        if (!z_records || (z_records && z_records->which == Z_Records_DBOSD))
        {
            m_sets[resultSetId] = VirtualDB::Set(b, backend_setname);
            fixup_package(search_package, b);
        }
    }
    package.response() = search_package.response();
}

Member Data Documentation

m_backend_list

std::list<BackendPtr> metaproxy_1::filter::VirtualDB::Frontend::m_backend_list

Definition at line 77 of file filter_virt_db.cpp.

m_in_use

bool metaproxy_1::filter::VirtualDB::Frontend::m_in_use

Definition at line 75 of file filter_virt_db.cpp.

m_init_gdu

yazpp_1::GDU metaproxy_1::filter::VirtualDB::Frontend::m_init_gdu

Definition at line 76 of file filter_virt_db.cpp.

m_is_virtual

bool metaproxy_1::filter::VirtualDB::Frontend::m_is_virtual

Definition at line 74 of file filter_virt_db.cpp.

m_p

Rep* metaproxy_1::filter::VirtualDB::Frontend::m_p

Definition at line 102 of file filter_virt_db.cpp.

m_session

mp::Session metaproxy_1::filter::VirtualDB::Frontend::m_session

Definition at line 73 of file filter_virt_db.cpp.

m_sets

std::map<std::string,VirtualDB::Set> metaproxy_1::filter::VirtualDB::Frontend::m_sets

Definition at line 78 of file filter_virt_db.cpp.

---

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

• filter_virt_db.cpp