metaproxy_1::filter::VirtualDB Class Reference

#include <filter_virt_db.hpp>

Inheritance diagram for metaproxy_1::filter::VirtualDB:

Collaboration diagram for metaproxy_1::filter::VirtualDB:

Classes
struct	Backend
struct	Frontend
struct	Map
class	Rep
struct	Set

Public Member Functions
	~VirtualDB ()
	VirtualDB ()
void	process (metaproxy_1::Package &package) const
void	configure (const xmlNode *ptr, bool test_only, const char *path)
void	add_map_db2targets (std::string db, std::list< std::string > targets, std::string route)
void	add_map_db2target (std::string db, std::string target, std::string route)

Private Types
typedef boost::shared_ptr< Backend >	BackendPtr
typedef boost::shared_ptr< Frontend >	FrontendPtr

Private Attributes
boost::scoped_ptr< Rep >	m_p

Detailed Description

Definition at line 31 of file filter_virt_db.hpp.

Member Typedef Documentation

BackendPtr

typedef boost::shared_ptr<Backend> metaproxy_1::filter::VirtualDB::BackendPtr

private

Definition at line 37 of file filter_virt_db.hpp.

FrontendPtr

typedef boost::shared_ptr<Frontend> metaproxy_1::filter::VirtualDB::FrontendPtr

private

Definition at line 38 of file filter_virt_db.hpp.

Constructor & Destructor Documentation

~VirtualDB()

mp::filter::VirtualDB::~VirtualDB

(

)

Definition at line 497 of file filter_virt_db.cpp.

                        {
}

VirtualDB()

mp::filter::VirtualDB::VirtualDB

(

)

Definition at line 492 of file filter_virt_db.cpp.

                       : m_p(new VirtualDB::Rep)
{
    m_p->pass_vhosts = false;
}

References m_p.

Member Function Documentation

add_map_db2target()

void mp::filter::VirtualDB::add_map_db2target	(	std::string	db,
		std::string	target,
		std::string	route
	)

Definition at line 724 of file filter_virt_db.cpp.

{
    m_p->m_maps.push_back(
        VirtualDB::Map(mp::util::database_name_normalize(db), target, route));
}

add_map_db2targets()

void mp::filter::VirtualDB::add_map_db2targets	(	std::string	db,
		std::list< std::string >	targets,
		std::string	route
	)

Definition at line 715 of file filter_virt_db.cpp.

{
    m_p->m_maps.push_back(
        VirtualDB::Map(mp::util::database_name_normalize(db), targets, route));
}

configure()

void mp::filter::VirtualDB::configure	(	const xmlNode *	ptr,
		bool	test_only,
		const char *	path
	)

Definition at line 844 of file filter_virt_db.cpp.

{
    for (ptr = ptr->children; ptr; ptr = ptr->next)
    {
        if (ptr->type != XML_ELEMENT_NODE)
            continue;
        if (!strcmp((const char *) ptr->name, "pass-vhosts"))
        {
            m_p->pass_vhosts = mp::xml::get_bool(ptr, false);
        }
        else if (!strcmp((const char *) ptr->name, "virtual"))
        {
            std::string database;
            std::list<std::string> targets;
            xmlNode *v_node = ptr->children;
            for (; v_node; v_node = v_node->next)
            {
                if (v_node->type != XML_ELEMENT_NODE)
                    continue;
 
                if (mp::xml::is_element_mp(v_node, "database"))
                    database = mp::xml::get_text(v_node);
                else if (mp::xml::is_element_mp(v_node, "target"))
                    targets.push_back(mp::xml::get_text(v_node));
                else
                    throw mp::filter::FilterException
                        ("Bad element "
                         + std::string((const char *) v_node->name)
                         + " in virtual section"
                            );
            }
            std::string route = mp::xml::get_route(ptr);
 
            VirtualDB::Map vmap(mp::util::database_name_normalize(database),
                                targets, route);
            m_p->m_maps.push_back(vmap);
        }
        else
        {
            throw mp::filter::FilterException
                ("Bad element "
                 + std::string((const char *) ptr->name)
                 + " in virt_db filter");
        }
    }
}

process()

void mp::filter::VirtualDB::process

(

metaproxy_1::Package &

package

)

const

Definition at line 733 of file filter_virt_db.cpp.

{
    FrontendPtr f = m_p->get_frontend(package);
 
    Z_GDU *gdu = package.request().get();
 
    if (gdu && gdu->which == Z_GDU_Z3950 && gdu->u.z3950->which ==
        Z_APDU_initRequest && !f->m_is_virtual)
    {
        Z_InitRequest *req = gdu->u.z3950->u.initRequest;
 
        std::list<std::string> vhosts;
        mp::util::get_vhost_otherinfo(req->otherInfo, vhosts);
 
        if (vhosts.size() > 0 && m_p->pass_vhosts)
        {
            package.move();
        }
        else
        {
            f->m_init_gdu = gdu;
 
            mp::odr odr;
            Z_APDU *apdu = odr.create_initResponse(gdu->u.z3950, 0, 0);
            Z_InitResponse *resp = apdu->u.initResponse;
 
            int i;
            static const int masks[] = {
                Z_Options_search,
                Z_Options_present,
                Z_Options_namedResultSets,
                Z_Options_scan,
                -1
            };
            for (i = 0; masks[i] != -1; i++)
                if (ODR_MASK_GET(req->options, masks[i]))
                    ODR_MASK_SET(resp->options, masks[i]);
 
            static const int versions[] = {
                Z_ProtocolVersion_1,
                Z_ProtocolVersion_2,
                Z_ProtocolVersion_3,
                -1
            };
            for (i = 0; versions[i] != -1; i++)
                if (ODR_MASK_GET(req->protocolVersion, versions[i]))
                    ODR_MASK_SET(resp->protocolVersion, versions[i]);
                else
                    break;
 
            *resp->preferredMessageSize = *req->preferredMessageSize;
            *resp->maximumRecordSize = *req->maximumRecordSize;
 
            package.response() = apdu;
            f->m_is_virtual = true;
        }
    }
    else if (!f->m_is_virtual)
        package.move();
    else if (gdu && gdu->which == Z_GDU_Z3950)
    {
        Z_APDU *apdu = gdu->u.z3950;
        if (apdu->which == Z_APDU_initRequest)
        {
            mp::odr odr;
 
            package.response() = odr.create_close(
                apdu,
                Z_Close_protocolError,
                "double init");
 
            package.session().close();
        }
        else if (apdu->which == Z_APDU_searchRequest)
        {
            f->search(package, apdu);
        }
        else if (apdu->which == Z_APDU_presentRequest)
        {
            f->present(package, apdu);
        }
        else if (apdu->which == Z_APDU_scanRequest)
        {
            f->scan(package, apdu);
        }
        else if (apdu->which == Z_APDU_close)
        {
            if (f->relay_apdu(package, apdu) == 0)
            {
                mp::odr odr;
 
                package.response() = odr.create_close(
                    apdu, Z_Close_finished, "virt_db");
 
                package.session().close();
            }
        }
        else
        {
            mp::odr odr;
 
            package.response() = odr.create_close(
                apdu, Z_Close_protocolError,
                "unsupported APDU in filter_virt_db");
 
            package.session().close();
        }
    }
    m_p->release_frontend(package);
}

Member Data Documentation

m_p

boost::scoped_ptr<Rep> metaproxy_1::filter::VirtualDB::m_p

private

Definition at line 52 of file filter_virt_db.hpp.

Referenced by VirtualDB().

---

The documentation for this class was generated from the following files:

• filter_virt_db.hpp
• filter_virt_db.cpp