metaproxy_1::filter::SessionShared::Rep Class Reference

Collaboration diagram for metaproxy_1::filter::SessionShared::Rep:

Public Member Functions
	~Rep ()
void	expire ()

Private Member Functions
FrontendPtr	get_frontend (Package &package)
void	release_frontend (Package &package)
	Rep ()
void	expire_classes ()
void	stat ()
void	init (Package &package, const Z_GDU *gdu, FrontendPtr frontend)
void	start ()

Private Attributes
boost::mutex	m_mutex
boost::condition	m_cond_session_ready
boost::condition	m_cond_expire_ready
std::map< mp::Session, FrontendPtr >	m_clients
BackendClassMap	m_backend_map
boost::mutex	m_mutex_backend_map
boost::thread_group	m_thrds
int	m_resultset_ttl
int	m_resultset_max
int	m_session_ttl
bool	m_optimize_search
bool	m_restart
bool	m_ignore_auth
int	m_session_max
Odr_int	m_preferredMessageSize
Odr_int	m_maximumRecordSize
bool	close_down

Friends
class	SessionShared
struct	Frontend

Detailed Description

Definition at line 195 of file filter_session_shared.cpp.

Constructor & Destructor Documentation

Rep()

mp::filter::SessionShared::Rep::Rep ( )

private

Definition at line 1394 of file filter_session_shared.cpp.

{
    m_resultset_ttl = 30;
    m_resultset_max = 10;
    m_session_ttl = 90;
    m_optimize_search = true;
    m_ignore_auth = false;
    m_restart = false;
    m_session_max = 100;
    m_preferredMessageSize = 0;
    m_maximumRecordSize = 0;
    close_down = false;
}

~Rep()

mp::filter::SessionShared::Rep::~Rep

(

)

Definition at line 1408 of file filter_session_shared.cpp.

{
    {
        boost::mutex::scoped_lock lock(m_mutex);
        close_down = true;
        m_cond_expire_ready.notify_all();
    }
    m_thrds.join_all();
}

Member Function Documentation

expire()

void mp::filter::SessionShared::Rep::expire

(

)

Definition at line 1370 of file filter_session_shared.cpp.

{
    while (true)
    {
        boost::xtime xt;
        boost::xtime_get(&xt,
#if BOOST_VERSION >= 105000
                boost::TIME_UTC_
#else
                boost::TIME_UTC
#endif
                  );
        xt.sec += m_session_ttl;
        {
            boost::mutex::scoped_lock lock(m_mutex);
            m_cond_expire_ready.timed_wait(lock, xt);
            if (close_down)
                break;
        }
        stat();
        expire_classes();
    }
}

expire_classes()

void mp::filter::SessionShared::Rep::expire_classes ( )

private

Definition at line 1354 of file filter_session_shared.cpp.

{
    boost::mutex::scoped_lock lock(m_mutex_backend_map);
    BackendClassMap::iterator b_it = m_backend_map.begin();
    while (b_it != m_backend_map.end())
    {
        if (b_it->second->expire_instances())
        {
            m_backend_map.erase(b_it);
            b_it = m_backend_map.begin();
        }
        else
            b_it++;
    }
}

get_frontend()

yf::SessionShared::FrontendPtr mp::filter::SessionShared::Rep::get_frontend ( Package &  package )

private

Definition at line 1444 of file filter_session_shared.cpp.

{
    boost::mutex::scoped_lock lock(m_mutex);
 
    std::map<mp::Session,yf::SessionShared::FrontendPtr>::iterator it;
 
    while(true)
    {
        it = m_clients.find(package.session());
        if (it == m_clients.end())
            break;
 
        if (!it->second->m_in_use)
        {
            it->second->m_in_use = true;
            return it->second;
        }
        m_cond_session_ready.wait(lock);
    }
    FrontendPtr f(new Frontend(this));
    m_clients[package.session()] = f;
    f->m_in_use = true;
    return f;
}

init()

void mp::filter::SessionShared::Rep::init ( Package &  package, const Z_GDU *  gdu, FrontendPtr  frontend  )

private

Definition at line 561 of file filter_session_shared.cpp.

{
    Z_InitRequest *req = gdu->u.z3950->u.initRequest;
 
    frontend->m_is_virtual = true;
    frontend->m_init_options = *req->options;
    if (m_ignore_auth)
        req->idAuthentication = 0;
    InitKey k(req);
    {
        boost::mutex::scoped_lock lock(m_mutex_backend_map);
        BackendClassMap::const_iterator it;
        it = m_backend_map.find(k);
        if (it == m_backend_map.end())
        {
            BackendClassPtr b(new BackendClass(gdu->u.z3950,
                                               m_resultset_ttl,
                                               m_resultset_max,
                                               m_session_ttl,
                                               m_preferredMessageSize,
                                               m_maximumRecordSize));
            m_backend_map[k] = b;
            frontend->m_backend_class = b;
        }
        else
        {
            frontend->m_backend_class = it->second;
        }
    }
    BackendClassPtr bc = frontend->m_backend_class;
    mp::odr odr;
 
    // we only need to get init response from "first" target in
    // backend class - the assumption being that init response is
    // same for all
    bool create_first_one = false;
    {
        boost::mutex::scoped_lock lock(bc->m_mutex_backend_class);
        if (!bc->m_no_succeeded)
            create_first_one = true;
        else
        {
            // wait for first one to finish
            while (!bc->m_no_failed && !bc->m_no_succeeded && bc->m_no_init)
            {
                bc->m_cond_set_ready.wait(lock);
            }
        }
    }
    if (create_first_one)
    {
 
        int code;
        std::string addinfo;
        BackendInstancePtr backend = bc->create_backend(package, code, addinfo);
        if (backend)
            bc->release_backend(backend);
    }
    yazpp_1::GDU init_response;
    {
        boost::mutex::scoped_lock lock(bc->m_mutex_backend_class);
 
        init_response = bc->m_init_response;
    }
 
    if (init_response.get())
    {
        Z_GDU *response_gdu = init_response.get();
        mp::util::transfer_referenceId(odr, gdu->u.z3950,
                                       response_gdu->u.z3950);
        Z_InitResponse *init_res = response_gdu->u.z3950->u.initResponse;
        Z_Options *server_options = init_res->options;
        Z_Options *client_options = &frontend->m_init_options;
        int i;
        for (i = 0; i < 30; i++)
            if (!ODR_MASK_GET(client_options, i))
                ODR_MASK_CLEAR(server_options, i);
 
        if (!m_preferredMessageSize ||
            *init_res->preferredMessageSize > *req->preferredMessageSize)
            *init_res->preferredMessageSize = *req->preferredMessageSize;
 
        if (!m_maximumRecordSize ||
            *init_res->maximumRecordSize > *req->maximumRecordSize)
            *init_res->maximumRecordSize = *req->maximumRecordSize;
 
        package.response() = init_response;
        if (!*response_gdu->u.z3950->u.initResponse->result)
            package.session().close();
    }
    else
    {
        Z_APDU *apdu =
            odr.create_initResponse(
                gdu->u.z3950, YAZ_BIB1_TEMPORARY_SYSTEM_ERROR,
                "session_shared: target closed connection during init");
        *apdu->u.initResponse->result = 0;
        package.response() = apdu;
        package.session().close();
    }
}

release_frontend()

void mp::filter::SessionShared::Rep::release_frontend ( Package &  package )

private

Definition at line 1469 of file filter_session_shared.cpp.

{
    boost::mutex::scoped_lock lock(m_mutex);
    std::map<mp::Session,yf::SessionShared::FrontendPtr>::iterator it;
 
    it = m_clients.find(package.session());
    if (it != m_clients.end())
    {
        if (package.session().is_closed())
        {
            m_clients.erase(it);
        }
        else
        {
            it->second->m_in_use = false;
        }
        m_cond_session_ready.notify_all();
    }
}

start()

void mp::filter::SessionShared::Rep::start ( )

private

Definition at line 1418 of file filter_session_shared.cpp.

{
    yf::SessionShared::Worker w(this);
    m_thrds.add_thread(new boost::thread(w));
}

stat()

void mp::filter::SessionShared::Rep::stat ( )

private

Definition at line 543 of file filter_session_shared.cpp.

{
    int no_classes = 0;
    int no_instances = 0;
    BackendClassMap::const_iterator it;
    {
        boost::mutex::scoped_lock lock(m_mutex_backend_map);
        for (it = m_backend_map.begin(); it != m_backend_map.end(); it++)
        {
            BackendClassPtr bc = it->second;
            no_classes++;
            BackendInstanceList::iterator bit = bc->m_backend_list.begin();
            for (; bit != bc->m_backend_list.end(); bit++)
                no_instances++;
        }
    }
}

Friends And Related Function Documentation

Frontend

friend struct Frontend

friend

Definition at line 197 of file filter_session_shared.cpp.

SessionShared

friend class SessionShared

friend

Definition at line 196 of file filter_session_shared.cpp.

Member Data Documentation

close_down

bool metaproxy_1::filter::SessionShared::Rep::close_down

private

Definition at line 228 of file filter_session_shared.cpp.

m_backend_map

BackendClassMap metaproxy_1::filter::SessionShared::Rep::m_backend_map

private

Definition at line 216 of file filter_session_shared.cpp.

m_clients

std::map<mp::Session, FrontendPtr> metaproxy_1::filter::SessionShared::Rep::m_clients

private

Definition at line 214 of file filter_session_shared.cpp.

m_cond_expire_ready

boost::condition metaproxy_1::filter::SessionShared::Rep::m_cond_expire_ready

private

Definition at line 213 of file filter_session_shared.cpp.

m_cond_session_ready

boost::condition metaproxy_1::filter::SessionShared::Rep::m_cond_session_ready

private

Definition at line 212 of file filter_session_shared.cpp.

m_ignore_auth

bool metaproxy_1::filter::SessionShared::Rep::m_ignore_auth

private

Definition at line 224 of file filter_session_shared.cpp.

m_maximumRecordSize

Odr_int metaproxy_1::filter::SessionShared::Rep::m_maximumRecordSize

private

Definition at line 227 of file filter_session_shared.cpp.

m_mutex

boost::mutex metaproxy_1::filter::SessionShared::Rep::m_mutex

private

Definition at line 211 of file filter_session_shared.cpp.

m_mutex_backend_map

boost::mutex metaproxy_1::filter::SessionShared::Rep::m_mutex_backend_map

private

Definition at line 217 of file filter_session_shared.cpp.

m_optimize_search

bool metaproxy_1::filter::SessionShared::Rep::m_optimize_search

private

Definition at line 222 of file filter_session_shared.cpp.

m_preferredMessageSize

Odr_int metaproxy_1::filter::SessionShared::Rep::m_preferredMessageSize

private

Definition at line 226 of file filter_session_shared.cpp.

m_restart

bool metaproxy_1::filter::SessionShared::Rep::m_restart

private

Definition at line 223 of file filter_session_shared.cpp.

m_resultset_max

int metaproxy_1::filter::SessionShared::Rep::m_resultset_max

private

Definition at line 220 of file filter_session_shared.cpp.

m_resultset_ttl

int metaproxy_1::filter::SessionShared::Rep::m_resultset_ttl

private

Definition at line 219 of file filter_session_shared.cpp.

m_session_max

int metaproxy_1::filter::SessionShared::Rep::m_session_max

private

Definition at line 225 of file filter_session_shared.cpp.

m_session_ttl

int metaproxy_1::filter::SessionShared::Rep::m_session_ttl

private

Definition at line 221 of file filter_session_shared.cpp.

m_thrds

boost::thread_group metaproxy_1::filter::SessionShared::Rep::m_thrds

private

Definition at line 218 of file filter_session_shared.cpp.

---

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

• filter_session_shared.cpp