metaproxy_1::filter::LoadBalance::Impl Class Reference

Collaboration diagram for metaproxy_1::filter::LoadBalance::Impl:

Classes
class	TargetStat

Public Member Functions
	Impl ()
	~Impl ()
void	process (metaproxy_1::Package &package)
void	configure (const xmlNode *ptr)

Private Member Functions
void	add_dead (unsigned long session_id)
void	add_package (unsigned long session_id)
void	remove_package (unsigned long session_id)
void	add_session (metaproxy_1::Package &pkg, std::string target)
void	remove_session (metaproxy_1::Package &pkg)
std::string	find_session_target (unsigned long session_id)
unsigned int	cost (std::string target)
unsigned int	dead (std::string target)

Private Attributes
boost::mutex	m_mutex
std::map< std::string, TargetStat >	m_target_stat
std::map< unsigned long, std::string >	m_session_target

Detailed Description

Definition at line 48 of file filter_load_balance.cpp.

Constructor & Destructor Documentation

Impl()

mp::filter::LoadBalance::Impl::Impl

(

)

Definition at line 111 of file filter_load_balance.cpp.

{
}

~Impl()

mp::filter::LoadBalance::Impl::~Impl

(

)

Definition at line 115 of file filter_load_balance.cpp.

{
}

Member Function Documentation

add_dead()

void mp::filter::LoadBalance::Impl::add_dead ( unsigned long  session_id )

private

Definition at line 287 of file filter_load_balance.cpp.

{
    std::string target = find_session_target(session_id);
 
    if (target.size() != 0)
    {
        std::map<std::string, TargetStat>::iterator itarg;
        itarg = m_target_stat.find(target);
        if (itarg != m_target_stat.end()
            && itarg->second.deads < std::numeric_limits<unsigned int>::max())
        {
            itarg->second.deads += 1;
            // std:.cout << "add_dead " << session_id << " " << target
            //          << " d:" << itarg->second.deads << "\n";
        }
    }
}

add_package()

void mp::filter::LoadBalance::Impl::add_package ( unsigned long  session_id )

private

Definition at line 305 of file filter_load_balance.cpp.

{
    std::string target = find_session_target(session_id);
 
    if (target.size() != 0)
    {
        std::map<std::string, TargetStat>::iterator itarg;
        itarg = m_target_stat.find(target);
        if (itarg != m_target_stat.end()
            && itarg->second.packages
               < std::numeric_limits<unsigned int>::max())
        {
            itarg->second.packages += 1;
        }
    }
}

add_session()

void mp::filter::LoadBalance::Impl::add_session ( metaproxy_1::Package &  pkg, std::string  target  )

private

Definition at line 338 of file filter_load_balance.cpp.

{
    // finding and adding session
    unsigned long session_id = package.session().id();
    std::map<unsigned long, std::string>::iterator isess;
    isess = m_session_target.find(session_id);
    if (isess == m_session_target.end())
    {
        m_session_target.insert(std::make_pair(session_id, target));
 
        std::ostringstream os;
        os  << "LB" << " "
            << package << " "
            << "0.000000 Add " << target << " size="
            << m_session_target.size();
        yaz_log(YLOG_LOG, "%s", os.str().c_str());
    }
 
    // finding and adding target statistics
    std::map<std::string, TargetStat>::iterator itarg;
    itarg = m_target_stat.find(target);
    if (itarg == m_target_stat.end())
    {
        TargetStat stat;
        stat.sessions = 1;
        stat.packages = 0;
        stat.deads = 0;
        m_target_stat.insert(std::make_pair(target, stat));
    }
    else if (itarg->second.sessions < std::numeric_limits<unsigned int>::max())
    {
        itarg->second.sessions += 1;
    }
}

References metaproxy_1::filter::LoadBalance::Impl::TargetStat::deads, metaproxy_1::filter::LoadBalance::Impl::TargetStat::packages, and metaproxy_1::filter::LoadBalance::Impl::TargetStat::sessions.

configure()

void mp::filter::LoadBalance::Impl::configure

(

const xmlNode *

ptr

)

Definition at line 119 of file filter_load_balance.cpp.

{
}

cost()

unsigned int mp::filter::LoadBalance::Impl::cost ( std::string  target )

private

Definition at line 417 of file filter_load_balance.cpp.

{
    unsigned int cost = 0;
 
    if (target.size() != 0)
    {
        std::map<std::string, TargetStat>::iterator itarg;
        itarg = m_target_stat.find(target);
        if (itarg != m_target_stat.end())
            cost = itarg->second.cost();
    }
    return cost;
}

dead()

unsigned int mp::filter::LoadBalance::Impl::dead ( std::string  target )

private

Definition at line 431 of file filter_load_balance.cpp.

{
    unsigned int dead = 0;
 
    if (target.size() != 0)
    {
        std::map<std::string, TargetStat>::iterator itarg;
        itarg = m_target_stat.find(target);
        if (itarg != m_target_stat.end())
            dead = itarg->second.deads;
    }
    return dead;
}

find_session_target()

std::string mp::filter::LoadBalance::Impl::find_session_target ( unsigned long  session_id )

private

Definition at line 405 of file filter_load_balance.cpp.

{
    std::string target;
    std::map<unsigned long, std::string>::iterator isess;
    isess = m_session_target.find(session_id);
    if (isess != m_session_target.end())
        target = isess->second;
    return target;
}

process()

void mp::filter::LoadBalance::Impl::process

(

metaproxy_1::Package &

package

)

Definition at line 123 of file filter_load_balance.cpp.

{
    bool is_closed_front = false;
 
    // checking for closed front end packages
    if (package.session().is_closed())
    {
        is_closed_front = true;
    }
 
    Z_GDU *gdu_req = package.request().get();
 
    // passing anything but z3950 packages
    if (gdu_req && gdu_req->which == Z_GDU_Z3950)
    {
        // target selecting only on Z39.50 init request
        if (gdu_req->u.z3950->which == Z_APDU_initRequest)
        {
            yazpp_1::GDU base_req(gdu_req);
            Z_APDU *apdu = base_req.get()->u.z3950;
 
            Z_InitRequest *org_init = base_req.get()->u.z3950->u.initRequest;
            mp::odr odr_en(ODR_ENCODE);
 
            std::list<std::string> vhosts;
            mp::util::remove_vhost_otherinfo(&(org_init->otherInfo), vhosts);
            // get lowest of all vhosts.. Remove them if individually if
            // they turn out to be bad..
            while (1)
            {
                std::list<std::string>::iterator ivh = vhosts.begin();
                std::list<std::string>::iterator ivh_pick = vhosts.end();
 
                Package init_pkg(package.session(), package.origin());
                init_pkg.copy_filter(package);
 
                unsigned int cost_i = std::numeric_limits<unsigned int>::max();
                {
                    boost::mutex::scoped_lock scoped_lock(m_mutex);
 
                    for (; ivh != vhosts.end(); ivh++)
                    {
                        if ((*ivh).size() != 0)
                        {
                            unsigned int cost
                                = yf::LoadBalance::Impl::cost(*ivh);
 
                            std::ostringstream os;
                            os  << "LB" << " "
                                << package << " "
                                << "0.000000" << " "
                                << "Consider " << *ivh
                                << " cost=" << cost;
                            yaz_log(YLOG_LOG, "%s", os.str().c_str());
                            if (cost_i > cost)
                            {
                                ivh_pick = ivh;
                                cost_i = cost;
                            }
                        }
                    }
                }
                if (ivh_pick == vhosts.end())
                    break;
                std::string target = *ivh_pick;
                vhosts.erase(ivh_pick);
                // copying new target into init package
                yazpp_1::GDU init_gdu(base_req);
                Z_InitRequest *init_req = init_gdu.get()->u.z3950->u.initRequest;
 
                mp::util::set_vhost_otherinfo(&(init_req->otherInfo),
                                              odr_en, target, 1);
 
                init_pkg.request() = init_gdu;
 
                // moving all package types
                init_pkg.move();
 
                // checking for closed back end packages
                if (!init_pkg.session().is_closed())
                {
                    {
                        boost::mutex::scoped_lock scoped_lock(m_mutex);
                        add_session(package, target);
                    }
 
                    package.response() = init_pkg.response();
                    return;
                }
                std::ostringstream os;
                os  << "LB" << " "
                    << package << " "
                    << "0.000000" << " "
                    << "Failed " << target;
                yaz_log(YLOG_LOG, "%s", os.str().c_str());
            }
            mp::odr odr;
            package.response() = odr.create_initResponse(
                apdu, YAZ_BIB1_TEMPORARY_SYSTEM_ERROR,
                "load_balance: no available targets");
            package.session().close();
            return;
        }
        // frontend Z39.50 close request is added to statistics and marked
        else if (gdu_req->u.z3950->which == Z_APDU_close)
        {
            is_closed_front = true;
            boost::mutex::scoped_lock scoped_lock(m_mutex);
            add_package(package.session().id());
        }
        // any other Z39.50 package is added to statistics
        else
        {
            boost::mutex::scoped_lock scoped_lock(m_mutex);
            add_package(package.session().id());
        }
    }
 
    // moving all package types
    package.move();
 
    bool is_closed_back = false;
 
    // checking for closed back end packages
    if (package.session().is_closed())
        is_closed_back = true;
 
    Z_GDU *gdu_res = package.response().get();
 
    // passing anything but z3950 packages
    if (gdu_res && gdu_res->which == Z_GDU_Z3950)
    {
        // session closing only on Z39.50 close response
        if (gdu_res->u.z3950->which == Z_APDU_close)
        {
            is_closed_back = true;
            boost::mutex::scoped_lock scoped_lock(m_mutex);
            remove_package(package.session().id());
        }
        // any other Z39.50 package is removed from statistics
        else
        {
            boost::mutex::scoped_lock scoped_lock(m_mutex);
            remove_package(package.session().id());
        }
    }
 
    // finally removing sessions and marking deads
    if (is_closed_back || is_closed_front)
    {
        boost::mutex::scoped_lock scoped_lock(m_mutex);
 
        // marking backend dead if backend closed without fronted close
        if (is_closed_front == false)
            add_dead(package.session().id());
 
        remove_session(package);
 
        // making sure that package is closed
        package.session().close();
    }
}

remove_package()

void mp::filter::LoadBalance::Impl::remove_package ( unsigned long  session_id )

private

Definition at line 322 of file filter_load_balance.cpp.

{
    std::string target = find_session_target(session_id);
 
    if (target.size() != 0)
    {
        std::map<std::string, TargetStat>::iterator itarg;
        itarg = m_target_stat.find(target);
        if (itarg != m_target_stat.end()
            && itarg->second.packages > 0)
        {
            itarg->second.packages -= 1;
        }
    }
}

remove_session()

void mp::filter::LoadBalance::Impl::remove_session ( metaproxy_1::Package &  pkg )

private

Definition at line 374 of file filter_load_balance.cpp.

{
    unsigned long session_id = package.session().id();
    std::map<unsigned long, std::string>::iterator isess;
    isess = m_session_target.find(session_id);
    if (isess == m_session_target.end())
        return;
 
    std::string target = isess->second;
    m_session_target.erase(isess);
 
    std::ostringstream os;
    os  << "LB" << " "
        << package << " "
        << "0.000000 Remove " << target << " size="
        << m_session_target.size();
    yaz_log(YLOG_LOG, "%s", os.str().c_str());
 
    // finding target statistics
    std::map<std::string, TargetStat>::iterator itarg;
    itarg = m_target_stat.find(target);
    if (itarg == m_target_stat.end())
        return;
 
    if (itarg->second.sessions > 0)
        itarg->second.sessions -= 1;
 
    if (itarg->second.sessions == 0 || itarg->second.deads == 0)
        m_target_stat.erase(itarg);
}

Member Data Documentation

m_mutex

boost::mutex metaproxy_1::filter::LoadBalance::Impl::m_mutex

private

Definition at line 82 of file filter_load_balance.cpp.

m_session_target

std::map<unsigned long, std::string> metaproxy_1::filter::LoadBalance::Impl::m_session_target

private

Definition at line 84 of file filter_load_balance.cpp.

m_target_stat

std::map<std::string, TargetStat> metaproxy_1::filter::LoadBalance::Impl::m_target_stat

private

Definition at line 83 of file filter_load_balance.cpp.

---

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

• filter_load_balance.cpp