Inheritance diagram for metaproxy_1::filter::SessionShared::BackendClass:

Collaboration diagram for metaproxy_1::filter::SessionShared::BackendClass:

Public Member Functions
	BackendClass (const yazpp_1::GDU &init_request, int resultset_ttl, int resultset_max, int session_ttl, Odr_int preferredRecordSize, Odr_int maximumRecordSize)

	~BackendClass ()

Private Member Functions
BackendInstancePtr	create_backend (const Package &package, int &code, std::string &addinfo)

void	remove_backend (BackendInstancePtr b)

BackendInstancePtr	get_backend (const Package &package, int &code, std::string &addinfo)

void	use_backend (BackendInstancePtr b)

void	release_backend (BackendInstancePtr b)

bool	expire_instances ()

Private Attributes
bool	m_named_result_sets

BackendInstanceList	m_backend_list

yazpp_1::GDU	m_init_request

yazpp_1::GDU	m_init_response

boost::mutex	m_mutex_backend_class

boost::condition	m_cond_set_ready

int	m_sequence_top

time_t	m_backend_set_ttl

time_t	m_backend_expiry_ttl

size_t	m_backend_set_max

Odr_int	m_preferredMessageSize

Odr_int	m_maximumRecordSize

int	m_no_failed

int	m_no_succeeded

int	m_no_init

Friends
class	Rep

struct	Frontend

Detailed Description

Definition at line 118 of file filter_session_shared.cpp.

Constructor & Destructor Documentation

◆ BackendClass()

mp::filter::SessionShared::BackendClass::BackendClass	(	const yazpp_1::GDU &	init_request,
		int	resultset_ttl,
		int	resultset_max,
		int	session_ttl,
		Odr_int	preferredRecordSize,
		Odr_int	maximumRecordSize
	)

Definition at line 526 of file filter_session_shared.cpp.

     : m_named_result_sets(false), m_init_request(init_request),
       m_sequence_top(0), m_backend_set_ttl(resultset_ttl),
       m_backend_expiry_ttl(session_ttl), m_backend_set_max(resultset_max),
       m_preferredMessageSize(preferredMessageSize),
       m_maximumRecordSize(maximumRecordSize),
       m_no_failed(0), m_no_succeeded(0), m_no_init(0)
 {}

◆ ~BackendClass()

mp::filter::SessionShared::BackendClass::~BackendClass ( )

Definition at line 540 of file filter_session_shared.cpp.

541 {}

Member Function Documentation

◆ create_backend()

yf::SessionShared::BackendInstancePtr mp::filter::SessionShared::BackendClass::create_backend	(	const Package &	package,
		int &	code,
		std::string &	addinfo
	)

private

Definition at line 394 of file filter_session_shared.cpp.

 {
     BackendInstancePtr null;
     BackendInstancePtr bp(new BackendInstance);
     bp->m_close_package =
         new mp::Package(bp->m_session, frontend_package.origin());
     bp->m_close_package->copy_filter(frontend_package);
  
     Package init_package(bp->m_session, frontend_package.origin());
  
     init_package.copy_filter(frontend_package);
  
     yazpp_1::GDU actual_init_request = m_init_request;
     Z_GDU *init_pdu = actual_init_request.get();
  
     assert(init_pdu->which == Z_GDU_Z3950);
     assert(init_pdu->u.z3950->which == Z_APDU_initRequest);
  
     Z_InitRequest *req = init_pdu->u.z3950->u.initRequest;
     ODR_MASK_ZERO(req->options);
  
     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);
  
     if (m_preferredMessageSize)
         *req->preferredMessageSize = m_preferredMessageSize;
     if (m_maximumRecordSize)
         *req->maximumRecordSize = m_maximumRecordSize;
  
     init_package.request() = init_pdu;
  
     {
         boost::mutex::scoped_lock lock(m_mutex_backend_class);
         m_no_init++;
     }
  
     init_package.move();
  
     boost::mutex::scoped_lock lock(m_mutex_backend_class);
  
     addinfo.clear();
     code = 0;
     m_named_result_sets = false;
     Z_GDU *gdu = init_package.response().get();
  
     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))
         {
             m_named_result_sets = true;
         }
         // save init-response until we get one that succeeds
         if (m_no_succeeded == 0)
             m_init_response = gdu->u.z3950;
         if (*gdu->u.z3950->u.initResponse->result
             && !init_package.session().is_closed())
         {
             bp->m_in_use = true;
             time(&bp->m_time_last_use);
             bp->m_sequence_this = 0;
             bp->m_result_set_sequence = 0;
             m_backend_list.push_back(bp);
             m_no_succeeded++;
             return bp;
         }
         else
         {
             Z_External *uif =
                 gdu->u.z3950->u.initResponse->userInformationField;
             if (uif && uif->which == Z_External_userInfo1)
             {
                 Z_OtherInformation *ui = uif->u.userInfo1;
                 if (ui && ui->num_elements >= 1)
                 {
                     Z_OtherInformationUnit *unit = ui->list[0];
                     if (unit->which == Z_OtherInfo_externallyDefinedInfo &&
                         unit->information.externallyDefinedInfo &&
                         unit->information.externallyDefinedInfo->which ==
                         Z_External_diag1)
                     {
                         Z_DiagnosticFormat *diag =
                             unit->information.externallyDefinedInfo->u.diag1;
                         if (diag->num >= 1)
                         {
                             Z_DiagnosticFormat_s *ds = diag->elements[0];
                             if (ds->which ==
                                 Z_DiagnosticFormat_s_defaultDiagRec)
                             {
                                 Z_DefaultDiagFormat *e =
                                     ds->u.defaultDiagRec;
                                 code = *e->condition;
                                 if (e->which == Z_DefaultDiagFormat_v2Addinfo
                                     && e->u.v2Addinfo)
                                 {
                                     addinfo = e->u.v2Addinfo;
                                 }
                                 else if (
                                     e->which == Z_DefaultDiagFormat_v3Addinfo
                                     && e->u.v3Addinfo)
                                 {
                                     addinfo = e->u.v3Addinfo;
                                 }
                             }
                         }
                     }
                 }
             }
         }
     }
     if (!init_package.session().is_closed())
     {
         init_package.copy_filter(frontend_package);
         init_package.session().close();
         init_package.move();
     }
     m_no_failed++;
     m_cond_set_ready.notify_all();
     return null;
 }

◆ expire_instances()

bool mp::filter::SessionShared::BackendClass::expire_instances ( )

private

Definition at line 1320 of file filter_session_shared.cpp.

 {
     time_t now;
     time(&now);
     boost::mutex::scoped_lock lock(m_mutex_backend_class);
     BackendInstanceList::iterator bit = m_backend_list.begin();
     while (bit != m_backend_list.end())
     {
         time_t last_use = (*bit)->m_time_last_use;
  
         if ((*bit)->m_in_use)
         {
             yaz_log(YLOG_LOG, "session_shared id=%ld in_use",
                     (*bit)->m_session.id());
             bit++;
         }
         else if (now < last_use || now - last_use > m_backend_expiry_ttl)
         {
             yaz_log(YLOG_LOG, "session_shared id=%ld erase",
                     (*bit)->m_session.id());
             bit = m_backend_list.erase(bit);
         }
         else
         {
             yaz_log(YLOG_LOG, "session_shared id=%ld skip now-last_use=%ld",
                     (*bit)->m_session.id(), (long) (now - last_use));
             bit++;
         }
     }
     if (m_backend_list.empty())
         return true;
     return false;
 }

◆ get_backend()

yf::SessionShared::BackendInstancePtr mp::filter::SessionShared::BackendClass::get_backend	(	const Package &	package,
		int &	code,
		std::string &	addinfo
	)

private

Definition at line 340 of file filter_session_shared.cpp.

 {
     {
         boost::mutex::scoped_lock lock(m_mutex_backend_class);
  
         BackendInstanceList::const_iterator it = m_backend_list.begin();
  
         BackendInstancePtr backend1; // null
  
         for (; it != m_backend_list.end(); it++)
         {
             if (!(*it)->m_in_use)
             {
                 if (!backend1
                     || (*it)->m_sequence_this < backend1->m_sequence_this)
                     backend1 = *it;
             }
         }
         if (backend1)
         {
             use_backend(backend1);
             return backend1;
         }
     }
     return create_backend(frontend_package, code, addinfo);
 }

◆ release_backend()

void mp::filter::SessionShared::BackendClass::release_backend ( BackendInstancePtr b )

private

Definition at line 306 of file filter_session_shared.cpp.

 {
     boost::mutex::scoped_lock lock(m_mutex_backend_class);
     m_cond_set_ready.notify_all();
     b->m_in_use = false;
 }

◆ remove_backend()

void mp::filter::SessionShared::BackendClass::remove_backend ( BackendInstancePtr b )

private

Definition at line 314 of file filter_session_shared.cpp.

 {
     {
         boost::mutex::scoped_lock lock(m_mutex_backend_class);
         BackendInstanceList::iterator it = m_backend_list.begin();
         for (;;)
         {
             if (it == m_backend_list.end())
                 return;
             if (*it == b)
             {
                 it = m_backend_list.erase(it);
                 break;
             }
             it++;
         }
     }
     mp::odr odr;
     b->m_close_package->response() = odr.create_close(
         0, Z_Close_lackOfActivity, 0);
     b->m_close_package->session().close();
     b->m_close_package->move();
 }

◆ use_backend()

void mp::filter::SessionShared::BackendClass::use_backend ( BackendInstancePtr b )

private

Definition at line 369 of file filter_session_shared.cpp.

 {
     backend->m_in_use = true;
     backend->m_sequence_this = m_sequence_top++;
 }

Friends And Related Function Documentation

◆ Frontend

friend struct Frontend

friend

Definition at line 120 of file filter_session_shared.cpp.

◆ Rep

friend class Rep

friend

Definition at line 119 of file filter_session_shared.cpp.

Member Data Documentation

◆ m_backend_expiry_ttl

time_t metaproxy_1::filter::SessionShared::BackendClass::m_backend_expiry_ttl

private

Definition at line 137 of file filter_session_shared.cpp.

◆ m_backend_list

BackendInstanceList metaproxy_1::filter::SessionShared::BackendClass::m_backend_list

private

Definition at line 122 of file filter_session_shared.cpp.

◆ m_backend_set_max

size_t metaproxy_1::filter::SessionShared::BackendClass::m_backend_set_max

private

Definition at line 138 of file filter_session_shared.cpp.

◆ m_backend_set_ttl

time_t metaproxy_1::filter::SessionShared::BackendClass::m_backend_set_ttl

private

Definition at line 136 of file filter_session_shared.cpp.

◆ m_cond_set_ready

boost::condition metaproxy_1::filter::SessionShared::BackendClass::m_cond_set_ready

private

Definition at line 134 of file filter_session_shared.cpp.

◆ m_init_request

yazpp_1::GDU metaproxy_1::filter::SessionShared::BackendClass::m_init_request

private

Definition at line 131 of file filter_session_shared.cpp.

◆ m_init_response

yazpp_1::GDU metaproxy_1::filter::SessionShared::BackendClass::m_init_response

private

Definition at line 132 of file filter_session_shared.cpp.

◆ m_maximumRecordSize

Odr_int metaproxy_1::filter::SessionShared::BackendClass::m_maximumRecordSize

private

Definition at line 140 of file filter_session_shared.cpp.

◆ m_mutex_backend_class

boost::mutex metaproxy_1::filter::SessionShared::BackendClass::m_mutex_backend_class

private

Definition at line 133 of file filter_session_shared.cpp.

◆ m_named_result_sets

bool metaproxy_1::filter::SessionShared::BackendClass::m_named_result_sets

private

Definition at line 121 of file filter_session_shared.cpp.

◆ m_no_failed

int metaproxy_1::filter::SessionShared::BackendClass::m_no_failed

private

Definition at line 141 of file filter_session_shared.cpp.

◆ m_no_init

int metaproxy_1::filter::SessionShared::BackendClass::m_no_init

private

Definition at line 143 of file filter_session_shared.cpp.

◆ m_no_succeeded

int metaproxy_1::filter::SessionShared::BackendClass::m_no_succeeded

private

Definition at line 142 of file filter_session_shared.cpp.

◆ m_preferredMessageSize

Odr_int metaproxy_1::filter::SessionShared::BackendClass::m_preferredMessageSize

private

Definition at line 139 of file filter_session_shared.cpp.

◆ m_sequence_top

int metaproxy_1::filter::SessionShared::BackendClass::m_sequence_top

private

Definition at line 135 of file filter_session_shared.cpp.

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

filter_session_shared.cpp

Public Member Functions

Private Member Functions

Private Attributes

Friends

Detailed Description

Constructor & Destructor Documentation

◆ BackendClass()

◆ ~BackendClass()

Member Function Documentation

◆ create_backend()

◆ expire_instances()

◆ get_backend()

◆ release_backend()

◆ remove_backend()

◆ use_backend()

Friends And Related Function Documentation

◆ Frontend

◆ Rep

Member Data Documentation

◆ m_backend_expiry_ttl

◆ m_backend_list

◆ m_backend_set_max

◆ m_backend_set_ttl

◆ m_cond_set_ready

◆ m_init_request

◆ m_init_response

◆ m_maximumRecordSize

◆ m_mutex_backend_class

◆ m_named_result_sets

◆ m_no_failed

◆ m_no_init

◆ m_no_succeeded

◆ m_preferredMessageSize

◆ m_sequence_top