metaproxy  1.21.0
Classes | Public Member Functions | Private Attributes | List of all members
metaproxy_1::filter::BackendTest Class Reference

#include <filter_backend_test.hpp>

Inheritance diagram for metaproxy_1::filter::BackendTest:
Inheritance graph
Collaboration diagram for metaproxy_1::filter::BackendTest:
Collaboration graph

Classes

class  Rep
 

Public Member Functions

 ~BackendTest ()
 
 BackendTest ()
 
void process (metaproxy_1::Package &package) const
 
void configure (const xmlNode *ptr, bool test_only, const char *path)
 

Private Attributes

boost::scoped_ptr< Repm_p
 

Detailed Description

Definition at line 28 of file filter_backend_test.hpp.

Constructor & Destructor Documentation

◆ ~BackendTest()

mp::filter::BackendTest::~BackendTest ( )

Definition at line 100 of file filter_backend_test.cpp.

100  {
101 }

◆ BackendTest()

mp::filter::BackendTest::BackendTest ( )

Definition at line 96 of file filter_backend_test.cpp.

96  : m_p(new BackendTest::Rep) {
97  m_p->m_support_named_result_sets = false;
98 }

References m_p.

Member Function Documentation

◆ configure()

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

Definition at line 392 of file filter_backend_test.cpp.

394 {
395  mp::xml::check_empty(ptr);
396 }

◆ process()

void mp::filter::BackendTest::process ( metaproxy_1::Package &  package) const

Definition at line 211 of file filter_backend_test.cpp.

212 {
213  Z_GDU *gdu = package.request().get();
214 
215  if (!gdu || gdu->which != Z_GDU_Z3950)
216  package.move();
217  else
218  {
219  Z_APDU *apdu_req = gdu->u.z3950;
220  Z_APDU *apdu_res = 0;
221  mp::odr odr;
222 
223  if (apdu_req->which != Z_APDU_initRequest &&
224  !m_p->m_sessions.exist(package.session()))
225  {
226  apdu_res = odr.create_close(apdu_req,
227  Z_Close_protocolError,
228  "no init for filter_backend_test");
229  package.session().close();
230  }
231  else if (apdu_req->which == Z_APDU_initRequest)
232  {
233  apdu_res = odr.create_initResponse(apdu_req, 0, 0);
234  Z_InitRequest *req = apdu_req->u.initRequest;
235  Z_InitResponse *resp = apdu_res->u.initResponse;
236 
237  resp->implementationName = odr_strdup(odr, "backend_test");
238  if (ODR_MASK_GET(req->options, Z_Options_namedResultSets))
239  m_p->m_support_named_result_sets = true;
240 
241  int i;
242  static const int masks[] = {
243  Z_Options_search, Z_Options_present,
244  Z_Options_namedResultSets, -1
245  };
246  for (i = 0; masks[i] != -1; i++)
247  if (ODR_MASK_GET(req->options, masks[i]))
248  ODR_MASK_SET(resp->options, masks[i]);
249  static const int versions[] = {
250  Z_ProtocolVersion_1,
251  Z_ProtocolVersion_2,
252  Z_ProtocolVersion_3,
253  -1
254  };
255  for (i = 0; versions[i] != -1; i++)
256  if (ODR_MASK_GET(req->protocolVersion, versions[i]))
257  ODR_MASK_SET(resp->protocolVersion, versions[i]);
258  else
259  break;
260 
261  *resp->preferredMessageSize = *req->preferredMessageSize;
262  *resp->maximumRecordSize = *req->maximumRecordSize;
263 
264  Session_info info;
265  m_p->m_sessions.create(info, package.session());
266  }
267  else if (apdu_req->which == Z_APDU_searchRequest)
268  {
269  Z_SearchRequest *req = apdu_req->u.searchRequest;
270 
271  if (!m_p->m_support_named_result_sets &&
272  strcmp(req->resultSetName, "default"))
273  {
274  apdu_res =
275  odr.create_searchResponse(
276  apdu_req, YAZ_BIB1_RESULT_SET_NAMING_UNSUPP, 0);
277  }
278  else
279  {
280  Z_Records *records = 0;
281  int number_returned = 0;
282  int next_position = 0;
283  int error_code = 0;
284  std::string addinfo;
285  const char *element_set_name = 0;
286 
287  Odr_int number = 0;
288  mp::util::piggyback_sr(req, result_set_size,
289  number, &element_set_name);
290 
291  if (number)
292  { // not a large set for sure
293  Z_ElementSetNames *esn;
294  if (number > *req->smallSetUpperBound)
295  esn = req->mediumSetElementSetNames;
296  else
297  esn = req->smallSetElementSetNames;
298  records = m_p->fetch(
299  odr, req->preferredRecordSyntax, esn,
300  1, number,
301  error_code, addinfo,
302  &number_returned,
303  &next_position);
304  }
305  if (error_code)
306  {
307  apdu_res =
308  odr.create_searchResponse(
309  apdu_req, error_code, addinfo.c_str());
310  Z_SearchResponse *resp = apdu_res->u.searchResponse;
311  *resp->resultCount = result_set_size;
312  }
313  else
314  {
315  apdu_res =
316  odr.create_searchResponse(apdu_req, 0, 0);
317  Z_SearchResponse *resp = apdu_res->u.searchResponse;
318  *resp->resultCount = result_set_size;
319  *resp->numberOfRecordsReturned = number_returned;
320  *resp->nextResultSetPosition = next_position;
321  resp->records = records;
322  }
323  }
324  }
325  else if (apdu_req->which == Z_APDU_presentRequest)
326  {
327  Z_PresentRequest *req = apdu_req->u.presentRequest;
328  int number_returned = 0;
329  int next_position = 0;
330  int error_code = 0;
331  std::string addinfo;
332  Z_ElementSetNames *esn = 0;
333 
334  if (req->recordComposition)
335  {
336  if (req->recordComposition->which == Z_RecordComp_simple)
337  esn = req->recordComposition->u.simple;
338  else
339  {
340  apdu_res =
341  odr.create_presentResponse(
342  apdu_req,
343  YAZ_BIB1_ONLY_A_SINGLE_ELEMENT_SET_NAME_SUPPORTED,
344  0);
345  package.response() = apdu_res;
346  return;
347  }
348  }
349  Z_Records *records = m_p->fetch(
350  odr, req->preferredRecordSyntax, esn,
351  *req->resultSetStartPoint, *req->numberOfRecordsRequested,
352  error_code, addinfo,
353  &number_returned,
354  &next_position);
355 
356  if (error_code)
357  {
358  apdu_res =
359  odr.create_presentResponse(apdu_req, error_code,
360  addinfo.c_str());
361  }
362  else
363  {
364  apdu_res =
365  odr.create_presentResponse(apdu_req, 0, 0);
366  Z_PresentResponse *resp = apdu_res->u.presentResponse;
367  resp->records = records;
368  *resp->numberOfRecordsReturned = number_returned;
369  *resp->nextResultSetPosition = next_position;
370  }
371  }
372  else if (apdu_req->which == Z_APDU_close)
373  {
374  apdu_res = odr.create_close(apdu_req,
375  Z_Close_finished, 0);
376  package.session().close();
377  }
378  else
379  {
380  apdu_res = odr.create_close(apdu_req,
381  Z_Close_protocolError,
382  "backend_test: unhandled APDU");
383  package.session().close();
384  }
385  if (apdu_res)
386  package.response() = apdu_res;
387  }
388  if (package.session().is_closed())
389  m_p->m_sessions.release(package.session());
390 }
static const int result_set_size

References result_set_size.

Member Data Documentation

◆ m_p

boost::scoped_ptr<Rep> metaproxy_1::filter::BackendTest::m_p
private

Definition at line 37 of file filter_backend_test.hpp.

Referenced by BackendTest().


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