src/filter_session_shared.cpp

   1 /* This file is part of Metaproxy.
   2    Copyright (C) 2005-2013 Index Data
   3
   4 Metaproxy is free software; you can redistribute it and/or modify it under
   5 the terms of the GNU General Public License as published by the Free
   6 Software Foundation; either version 2, or (at your option) any later
   7 version.
   8
   9 Metaproxy is distributed in the hope that it will be useful, but WITHOUT ANY
  10 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12 for more details.
  13
  14 You should have received a copy of the GNU General Public License
  15 along with this program; if not, write to the Free Software
  16 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  17 */
  18
  19 #include "config.hpp"
  20
  21 #include <metaproxy/filter.hpp>
  22 #include <metaproxy/package.hpp>
  23
  24 #include <boost/thread/mutex.hpp>
  25 #include <boost/thread/condition.hpp>
  26 #include <boost/thread/thread.hpp>
  27 #include <boost/thread/xtime.hpp>
  28 #include <boost/shared_ptr.hpp>
  29 #include <boost/format.hpp>
  30
  31 #include <metaproxy/util.hpp>
  32 #include "filter_session_shared.hpp"
  33
  34 #include <yaz/copy_types.h>
  35 #include <yaz/log.h>
  36 #include <yaz/zgdu.h>
  37 #include <yaz/otherinfo.h>
  38 #include <yaz/diagbib1.h>
  39 #include <yazpp/z-query.h>
  40 #include <yazpp/record-cache.h>
  41 #include <map>
  42 #include <iostream>
  43 #include <time.h>
  44
  45 namespace mp = metaproxy_1;
  46 namespace yf = metaproxy_1::filter;
  47
  48 namespace metaproxy_1 {
  49
  50     namespace filter {
  51         // key for session.. We'll only share sessions with same InitKey
  52         class SessionShared::InitKey {
  53         public:
  54             bool operator < (const SessionShared::InitKey &k) const;
  55             InitKey(Z_InitRequest *req);
  56             InitKey(const InitKey &);
  57             ~InitKey();
  58         private:
  59             char *m_idAuthentication_buf;
  60             int m_idAuthentication_size;
  61             char *m_otherInfo_buf;
  62             int m_otherInfo_size;
  63             ODR m_odr;
  64         };
  65         // worker thread .. for expiry of sessions
  66         class SessionShared::Worker {
  67         public:
  68             Worker(SessionShared::Rep *rep);
  69             void operator() (void);
  70         private:
  71             SessionShared::Rep *m_p;
  72         };
  73         // backend result set
  74         class SessionShared::BackendSet {
  75         public:
  76             std::string m_result_set_id;
  77             Databases m_databases;
  78             Odr_int m_result_set_size;
  79             yazpp_1::Yaz_Z_Query m_query;
  80             time_t m_time_last_use;
  81             void timestamp();
  82             yazpp_1::RecordCache m_record_cache;
  83             BackendSet(
  84                 const std::string &result_set_id,
  85                 const Databases &databases,
  86                 const yazpp_1::Yaz_Z_Query &query);
  87             bool search(
  88                 Package &frontend_package,
  89                 Package &search_package,
  90                 const Z_APDU *apdu_req,
  91                 const BackendInstancePtr bp,
  92                 Z_Records **z_records);
  93         };
  94         // backend connection instance
  95         class SessionShared::BackendInstance {
  96             friend class Rep;
  97             friend class BackendClass;
  98             friend class BackendSet;
  99         public:
 100             mp::Session m_session;
 101             BackendSetList m_sets;
 102             bool m_in_use;
 103             int m_sequence_this;
 104             int m_result_set_sequence;
 105             time_t m_time_last_use;
 106             mp::Package * m_close_package;
 107             ~BackendInstance();
 108             void timestamp();
 109         };
 110         // backends of some class (all with same InitKey)
 111         class SessionShared::BackendClass : boost::noncopyable {
 112             friend class Rep;
 113             friend struct Frontend;
 114             bool m_named_result_sets;
 115             BackendInstanceList m_backend_list;
 116             BackendInstancePtr create_backend(const Package &package);
 117             void remove_backend(BackendInstancePtr b);
 118             BackendInstancePtr get_backend(const Package &package);
 119             void use_backend(BackendInstancePtr b);
 120             void release_backend(BackendInstancePtr b);
 121             bool expire_instances();
 122             yazpp_1::GDU m_init_request;
 123             yazpp_1::GDU m_init_response;
 124             boost::mutex m_mutex_backend_class;
 125             int m_sequence_top;
 126             time_t m_backend_set_ttl;
 127             time_t m_backend_expiry_ttl;
 128             size_t m_backend_set_max;
 129             Odr_int m_preferredMessageSize;
 130             Odr_int m_maximumRecordSize;
 131         public:
 132             BackendClass(const yazpp_1::GDU &init_request,
 133                          int resultset_ttl,
 134                          int resultset_max,
 135                          int session_ttl,
 136                          Odr_int preferredRecordSize,
 137                          Odr_int maximumRecordSize);
 138             ~BackendClass();
 139         };
 140         // frontend result set
 141         class SessionShared::FrontendSet {
 142             Databases m_databases;
 143             yazpp_1::Yaz_Z_Query m_query;
 144         public:
 145             const Databases &get_databases();
 146             const yazpp_1::Yaz_Z_Query &get_query();
 147             FrontendSet(
 148                 const Databases &databases,
 149                 const yazpp_1::Yaz_Z_Query &query);
 150             FrontendSet();
 151         };
 152         // frontend session
 153         struct SessionShared::Frontend {
 154             Frontend(Rep *rep);
 155             ~Frontend();
 156             bool m_is_virtual;
 157             bool m_in_use;
 158             Z_Options m_init_options;
 159             void search(Package &package, Z_APDU *apdu);
 160             void present(Package &package, Z_APDU *apdu);
 161             void scan(Package &package, Z_APDU *apdu);
 162
 163             int result_set_ref(ODR o,
 164                                const Databases &databases,
 165                                Z_RPNStructure *s, std::string &rset);
 166             void get_set(mp::Package &package,
 167                          const Z_APDU *apdu_req,
 168                          const Databases &databases,
 169                          yazpp_1::Yaz_Z_Query &query,
 170                          BackendInstancePtr &found_backend,
 171                          BackendSetPtr &found_set);
 172             void override_set(BackendInstancePtr &found_backend,
 173                               std::string &result_set_id,
 174                               const Databases &databases,
 175                               bool out_of_sessions);
 176
 177             Rep *m_p;
 178             BackendClassPtr m_backend_class;
 179             FrontendSets m_frontend_sets;
 180         };
 181         // representation
 182         class SessionShared::Rep {
 183             friend class SessionShared;
 184             friend struct Frontend;
 185
 186             FrontendPtr get_frontend(Package &package);
 187             void release_frontend(Package &package);
 188             Rep();
 189         public:
 190             void expire();
 191         private:
 192             void expire_classes();
 193             void stat();
 194             void init(Package &package, const Z_GDU *gdu,
 195                       FrontendPtr frontend);
 196             void start();
 197             boost::mutex m_mutex;
 198             boost::condition m_cond_session_ready;
 199             std::map<mp::Session, FrontendPtr> m_clients;
 200
 201             BackendClassMap m_backend_map;
 202             boost::mutex m_mutex_backend_map;
 203             boost::thread_group m_thrds;
 204             int m_resultset_ttl;
 205             int m_resultset_max;
 206             int m_session_ttl;
 207             bool m_optimize_search;
 208             bool m_restart;
 209             int m_session_max;
 210             Odr_int m_preferredMessageSize;
 211             Odr_int m_maximumRecordSize;
 212         };
 213     }
 214 }
 215
 216 yf::SessionShared::FrontendSet::FrontendSet(
 217     const Databases &databases,
 218     const yazpp_1::Yaz_Z_Query &query)
 219     : m_databases(databases), m_query(query)
 220 {
 221 }
 222
 223 const yf::SessionShared::Databases &
 224 yf::SessionShared::FrontendSet::get_databases()
 225 {
 226     return m_databases;
 227 }
 228
 229 const yazpp_1::Yaz_Z_Query& yf::SessionShared::FrontendSet::get_query()
 230 {
 231     return m_query;
 232 }
 233
 234 yf::SessionShared::InitKey::InitKey(const InitKey &k)
 235 {
 236     m_odr = odr_createmem(ODR_ENCODE);
 237
 238     m_idAuthentication_size =  k.m_idAuthentication_size;
 239     m_idAuthentication_buf = (char*)odr_malloc(m_odr, m_idAuthentication_size);
 240     memcpy(m_idAuthentication_buf, k.m_idAuthentication_buf,
 241            m_idAuthentication_size);
 242
 243     m_otherInfo_size =  k.m_otherInfo_size;
 244     m_otherInfo_buf = (char*)odr_malloc(m_odr, m_otherInfo_size);
 245     memcpy(m_otherInfo_buf, k.m_otherInfo_buf,
 246            m_otherInfo_size);
 247 }
 248
 249 yf::SessionShared::InitKey::InitKey(Z_InitRequest *req)
 250 {
 251     m_odr = odr_createmem(ODR_ENCODE);
 252
 253     Z_IdAuthentication *t = req->idAuthentication;
 254     z_IdAuthentication(m_odr, &t, 1, 0);
 255     m_idAuthentication_buf =
 256         odr_getbuf(m_odr, &m_idAuthentication_size, 0);
 257
 258     Z_OtherInformation *o = req->otherInfo;
 259     z_OtherInformation(m_odr, &o, 1, 0);
 260     m_otherInfo_buf = odr_getbuf(m_odr, &m_otherInfo_size, 0);
 261 }
 262
 263 yf::SessionShared::InitKey::~InitKey()
 264 {
 265     odr_destroy(m_odr);
 266 }
 267
 268 bool yf::SessionShared::InitKey::operator < (const SessionShared::InitKey &k)
 269     const
 270 {
 271     int c;
 272     c = mp::util::memcmp2(
 273         (void*) m_idAuthentication_buf, m_idAuthentication_size,
 274         (void*) k.m_idAuthentication_buf, k.m_idAuthentication_size);
 275     if (c < 0)
 276         return true;
 277     else if (c > 0)
 278         return false;
 279
 280     c = mp::util::memcmp2((void*) m_otherInfo_buf, m_otherInfo_size,
 281                           (void*) k.m_otherInfo_buf, k.m_otherInfo_size);
 282     if (c < 0)
 283         return true;
 284     else if (c > 0)
 285         return false;
 286     return false;
 287 }
 288
 289 void yf::SessionShared::BackendClass::release_backend(BackendInstancePtr b)
 290 {
 291     boost::mutex::scoped_lock lock(m_mutex_backend_class);
 292     b->m_in_use = false;
 293 }
 294
 295
 296 void yf::SessionShared::BackendClass::remove_backend(BackendInstancePtr b)
 297 {
 298     BackendInstanceList::iterator it = m_backend_list.begin();
 299
 300     while (it != m_backend_list.end())
 301     {
 302         if (*it == b)
 303         {
 304              mp::odr odr;
 305             (*it)->m_close_package->response() = odr.create_close(
 306                 0, Z_Close_lackOfActivity, 0);
 307             (*it)->m_close_package->session().close();
 308             (*it)->m_close_package->move();
 309
 310             it = m_backend_list.erase(it);
 311         }
 312         else
 313             it++;
 314     }
 315 }
 316
 317
 318
 319 yf::SessionShared::BackendInstancePtr
 320 yf::SessionShared::BackendClass::get_backend(
 321     const mp::Package &frontend_package)
 322 {
 323     {
 324         boost::mutex::scoped_lock lock(m_mutex_backend_class);
 325
 326         BackendInstanceList::const_iterator it = m_backend_list.begin();
 327
 328         BackendInstancePtr backend1; // null
 329
 330         for (; it != m_backend_list.end(); it++)
 331         {
 332             if (!(*it)->m_in_use)
 333             {
 334                 if (!backend1
 335                     || (*it)->m_sequence_this < backend1->m_sequence_this)
 336                     backend1 = *it;
 337             }
 338         }
 339         if (backend1)
 340         {
 341             use_backend(backend1);
 342             return backend1;
 343         }
 344     }
 345     return create_backend(frontend_package);
 346 }
 347
 348 void yf::SessionShared::BackendClass::use_backend(BackendInstancePtr backend)
 349 {
 350     backend->m_in_use = true;
 351     backend->m_sequence_this = m_sequence_top++;
 352 }
 353
 354 void yf::SessionShared::BackendInstance::timestamp()
 355 {
 356     assert(m_in_use);
 357     time(&m_time_last_use);
 358 }
 359
 360 yf::SessionShared::BackendInstance::~BackendInstance()
 361 {
 362     delete m_close_package;
 363 }
 364
 365 yf::SessionShared::BackendInstancePtr yf::SessionShared::BackendClass::create_backend(
 366     const mp::Package &frontend_package)
 367 {
 368     BackendInstancePtr bp(new BackendInstance);
 369     BackendInstancePtr null;
 370
 371     bp->m_close_package =
 372         new mp::Package(bp->m_session, frontend_package.origin());
 373     bp->m_close_package->copy_filter(frontend_package);
 374
 375     Package init_package(bp->m_session, frontend_package.origin());
 376
 377     init_package.copy_filter(frontend_package);
 378
 379     yazpp_1::GDU actual_init_request = m_init_request;
 380     Z_GDU *init_pdu = actual_init_request.get();
 381
 382     assert(init_pdu->which == Z_GDU_Z3950);
 383     assert(init_pdu->u.z3950->which == Z_APDU_initRequest);
 384
 385     Z_InitRequest *req = init_pdu->u.z3950->u.initRequest;
 386     ODR_MASK_ZERO(req->options);
 387
 388     ODR_MASK_SET(req->options, Z_Options_search);
 389     ODR_MASK_SET(req->options, Z_Options_present);
 390     ODR_MASK_SET(req->options, Z_Options_namedResultSets);
 391     ODR_MASK_SET(req->options, Z_Options_scan);
 392
 393     ODR_MASK_SET(req->protocolVersion, Z_ProtocolVersion_1);
 394     ODR_MASK_SET(req->protocolVersion, Z_ProtocolVersion_2);
 395     ODR_MASK_SET(req->protocolVersion, Z_ProtocolVersion_3);
 396
 397     if (m_preferredMessageSize)
 398         *req->preferredMessageSize = m_preferredMessageSize;
 399     if (m_maximumRecordSize)
 400         *req->maximumRecordSize = m_maximumRecordSize;
 401
 402     init_package.request() = init_pdu;
 403
 404     init_package.move();
 405
 406     boost::mutex::scoped_lock lock(m_mutex_backend_class);
 407
 408     m_named_result_sets = false;
 409     Z_GDU *gdu = init_package.response().get();
 410
 411     if (gdu && gdu->which == Z_GDU_Z3950
 412         && gdu->u.z3950->which == Z_APDU_initResponse)
 413     {
 414         Z_InitResponse *res = gdu->u.z3950->u.initResponse;
 415         m_init_response = gdu->u.z3950;
 416         if (ODR_MASK_GET(res->options, Z_Options_namedResultSets))
 417         {
 418             m_named_result_sets = true;
 419         }
 420         if (*gdu->u.z3950->u.initResponse->result
 421             && !init_package.session().is_closed())
 422         {
 423             bp->m_in_use = true;
 424             time(&bp->m_time_last_use);
 425             bp->m_sequence_this = 0;
 426             bp->m_result_set_sequence = 0;
 427             m_backend_list.push_back(bp);
 428             return bp;
 429         }
 430     }
 431     else
 432     {
 433         yazpp_1::GDU empty_gdu;
 434         m_init_response = empty_gdu;
 435     }
 436
 437     if (!init_package.session().is_closed())
 438     {
 439         init_package.copy_filter(frontend_package);
 440         init_package.session().close();
 441         init_package.move();
 442     }
 443     return null;
 444 }
 445
 446
 447 yf::SessionShared::BackendClass::BackendClass(const yazpp_1::GDU &init_request,
 448                                               int resultset_ttl,
 449                                               int resultset_max,
 450                                               int session_ttl,
 451                                               Odr_int preferredMessageSize,
 452                                               Odr_int maximumRecordSize)
 453     : m_named_result_sets(false), m_init_request(init_request),
 454       m_sequence_top(0), m_backend_set_ttl(resultset_ttl),
 455       m_backend_expiry_ttl(session_ttl), m_backend_set_max(resultset_max),
 456       m_preferredMessageSize(preferredMessageSize),
 457       m_maximumRecordSize(maximumRecordSize)
 458 {}
 459
 460 yf::SessionShared::BackendClass::~BackendClass()
 461 {}
 462
 463 void yf::SessionShared::Rep::stat()
 464 {
 465     int no_classes = 0;
 466     int no_instances = 0;
 467     BackendClassMap::const_iterator it;
 468     {
 469         boost::mutex::scoped_lock lock(m_mutex_backend_map);
 470         for (it = m_backend_map.begin(); it != m_backend_map.end(); it++)
 471         {
 472             BackendClassPtr bc = it->second;
 473             no_classes++;
 474             BackendInstanceList::iterator bit = bc->m_backend_list.begin();
 475             for (; bit != bc->m_backend_list.end(); bit++)
 476                 no_instances++;
 477         }
 478     }
 479     yaz_log(YLOG_LOG, "backend classes=%d instances=%d", no_classes,
 480         no_instances);
 481 }
 482
 483 void yf::SessionShared::Rep::init(mp::Package &package, const Z_GDU *gdu,
 484                                   FrontendPtr frontend)
 485 {
 486     Z_InitRequest *req = gdu->u.z3950->u.initRequest;
 487
 488     frontend->m_is_virtual = true;
 489     frontend->m_init_options = *req->options;
 490     InitKey k(req);
 491     {
 492         boost::mutex::scoped_lock lock(m_mutex_backend_map);
 493         BackendClassMap::const_iterator it;
 494         it = m_backend_map.find(k);
 495         if (it == m_backend_map.end())
 496         {
 497             BackendClassPtr b(new BackendClass(gdu->u.z3950,
 498                                                m_resultset_ttl,
 499                                                m_resultset_max,
 500                                                m_session_ttl,
 501                                                m_preferredMessageSize,
 502                                                m_maximumRecordSize));
 503             m_backend_map[k] = b;
 504             frontend->m_backend_class = b;
 505         }
 506         else
 507         {
 508             frontend->m_backend_class = it->second;
 509         }
 510     }
 511     BackendClassPtr bc = frontend->m_backend_class;
 512     mp::odr odr;
 513
 514     // we only need to get init response from "first" target in
 515     // backend class - the assumption being that init response is
 516     // same for all
 517     if (bc->m_backend_list.size() == 0)
 518     {
 519         BackendInstancePtr backend = bc->create_backend(package);
 520         if (backend)
 521             bc->release_backend(backend);
 522     }
 523
 524     yazpp_1::GDU init_response;
 525     {
 526         boost::mutex::scoped_lock lock(bc->m_mutex_backend_class);
 527
 528         init_response = bc->m_init_response;
 529     }
 530
 531     if (init_response.get())
 532     {
 533         Z_GDU *response_gdu = init_response.get();
 534         mp::util::transfer_referenceId(odr, gdu->u.z3950,
 535                                        response_gdu->u.z3950);
 536         Z_InitResponse *init_res = response_gdu->u.z3950->u.initResponse;
 537         Z_Options *server_options = init_res->options;
 538         Z_Options *client_options = &frontend->m_init_options;
 539         int i;
 540         for (i = 0; i < 30; i++)
 541             if (!ODR_MASK_GET(client_options, i))
 542                 ODR_MASK_CLEAR(server_options, i);
 543
 544         if (!m_preferredMessageSize ||
 545             *init_res->preferredMessageSize > *req->preferredMessageSize)
 546             *init_res->preferredMessageSize = *req->preferredMessageSize;
 547
 548         if (!m_maximumRecordSize ||
 549             *init_res->maximumRecordSize > *req->maximumRecordSize)
 550             *init_res->maximumRecordSize = *req->maximumRecordSize;
 551
 552         package.response() = init_response;
 553         if (!*response_gdu->u.z3950->u.initResponse->result)
 554             package.session().close();
 555     }
 556     else
 557     {
 558         Z_APDU *apdu =
 559             odr.create_initResponse(
 560                 gdu->u.z3950, YAZ_BIB1_TEMPORARY_SYSTEM_ERROR,
 561                 "session_shared: target closed connection during init");
 562         *apdu->u.initResponse->result = 0;
 563         package.response() = apdu;
 564         package.session().close();
 565     }
 566 }
 567
 568 void yf::SessionShared::BackendSet::timestamp()
 569 {
 570     time(&m_time_last_use);
 571 }
 572
 573 yf::SessionShared::BackendSet::BackendSet(
 574     const std::string &result_set_id,
 575     const Databases &databases,
 576     const yazpp_1::Yaz_Z_Query &query) :
 577     m_result_set_id(result_set_id),
 578     m_databases(databases), m_result_set_size(0), m_query(query)
 579 {
 580     timestamp();
 581 }
 582
 583 static int get_diagnostic(Z_DefaultDiagFormat *r)
 584 {
 585     return *r->condition;
 586 }
 587
 588 bool yf::SessionShared::BackendSet::search(
 589     mp::Package &frontend_package,
 590     mp::Package &search_package,
 591     const Z_APDU *frontend_apdu,
 592     const BackendInstancePtr bp,
 593     Z_Records **z_records)
 594 {
 595     mp::odr odr;
 596     Z_APDU *apdu_req = zget_APDU(odr, Z_APDU_searchRequest);
 597     Z_SearchRequest *req = apdu_req->u.searchRequest;
 598
 599     req->resultSetName = odr_strdup(odr, m_result_set_id.c_str());
 600     req->query = m_query.get_Z_Query();
 601
 602     req->num_databaseNames = m_databases.size();
 603     req->databaseNames = (char**)
 604         odr_malloc(odr, req->num_databaseNames * sizeof(char *));
 605     Databases::const_iterator it = m_databases.begin();
 606     size_t i = 0;
 607     for (; it != m_databases.end(); it++)
 608         req->databaseNames[i++] = odr_strdup(odr, it->c_str());
 609
 610     if (frontend_apdu->which == Z_APDU_searchRequest)
 611         req->preferredRecordSyntax =
 612             frontend_apdu->u.searchRequest->preferredRecordSyntax;
 613
 614     search_package.request() = apdu_req;
 615
 616     search_package.move();
 617
 618     Z_GDU *gdu = search_package.response().get();
 619     if (!search_package.session().is_closed()
 620         && gdu && gdu->which == Z_GDU_Z3950
 621         && gdu->u.z3950->which == Z_APDU_searchResponse)
 622     {
 623         Z_SearchResponse *b_resp = gdu->u.z3950->u.searchResponse;
 624         *z_records = b_resp->records;
 625         m_result_set_size = *b_resp->resultCount;
 626         return true;
 627     }
 628     Z_APDU *f_apdu = 0;
 629     const char *addinfo = "session_shared: "
 630         "target closed connection during search";
 631     if (frontend_apdu->which == Z_APDU_searchRequest)
 632         f_apdu = odr.create_searchResponse(
 633             frontend_apdu, YAZ_BIB1_TEMPORARY_SYSTEM_ERROR, addinfo);
 634     else if (frontend_apdu->which == Z_APDU_presentRequest)
 635         f_apdu = odr.create_presentResponse(
 636             frontend_apdu, YAZ_BIB1_TEMPORARY_SYSTEM_ERROR, addinfo);
 637     else
 638         f_apdu = odr.create_close(
 639             frontend_apdu, YAZ_BIB1_TEMPORARY_SYSTEM_ERROR, addinfo);
 640     frontend_package.response() = f_apdu;
 641     return false;
 642 }
 643
 644 void yf::SessionShared::Frontend::override_set(
 645     BackendInstancePtr &found_backend,
 646     std::string &result_set_id,
 647     const Databases &databases,
 648     bool out_of_sessions)
 649 {
 650     BackendClassPtr bc = m_backend_class;
 651     BackendInstanceList::const_iterator it = bc->m_backend_list.begin();
 652     time_t now;
 653     time(&now);
 654
 655     size_t max_sets = bc->m_named_result_sets ? bc->m_backend_set_max : 1;
 656     for (; it != bc->m_backend_list.end(); it++)
 657     {
 658         if (!(*it)->m_in_use)
 659         {
 660             BackendSetList::iterator set_it = (*it)->m_sets.begin();
 661             for (; set_it != (*it)->m_sets.end(); set_it++)
 662             {
 663                 if ((max_sets > 1 || (*set_it)->m_databases == databases)
 664                     &&
 665                     (out_of_sessions ||
 666                      now < (*set_it)->m_time_last_use ||
 667                      now - (*set_it)->m_time_last_use >= bc->m_backend_set_ttl))
 668                 {
 669                     found_backend = *it;
 670                     result_set_id = (*set_it)->m_result_set_id;
 671                     found_backend->m_sets.erase(set_it);
 672                     return;
 673                 }
 674             }
 675         }
 676     }
 677     for (it = bc->m_backend_list.begin(); it != bc->m_backend_list.end(); it++)
 678     {
 679         if (!(*it)->m_in_use && (*it)->m_sets.size() < max_sets)
 680         {
 681             found_backend = *it;
 682             if (bc->m_named_result_sets)
 683             {
 684                 result_set_id = boost::io::str(
 685                     boost::format("%1%") %
 686                     found_backend->m_result_set_sequence);
 687                 found_backend->m_result_set_sequence++;
 688             }
 689             else
 690                 result_set_id = "default";
 691             return;
 692         }
 693     }
 694 }
 695
 696 void yf::SessionShared::Frontend::get_set(mp::Package &package,
 697                                           const Z_APDU *apdu_req,
 698                                           const Databases &databases,
 699                                           yazpp_1::Yaz_Z_Query &query,
 700                                           BackendInstancePtr &found_backend,
 701                                           BackendSetPtr &found_set)
 702 {
 703     bool session_restarted = false;
 704
 705 restart:
 706     std::string result_set_id;
 707     bool out_of_sessions = false;
 708     BackendClassPtr bc = m_backend_class;
 709     {
 710         boost::mutex::scoped_lock lock(bc->m_mutex_backend_class);
 711
 712         if ((int) bc->m_backend_list.size() >= m_p->m_session_max)
 713             out_of_sessions = true;
 714
 715         if (m_p->m_optimize_search)
 716         {
 717             // look at each backend and see if we have a similar search
 718             BackendInstanceList::const_iterator it = bc->m_backend_list.begin();
 719             for (; it != bc->m_backend_list.end(); it++)
 720             {
 721                 if (!(*it)->m_in_use)
 722                 {
 723                     BackendSetList::const_iterator set_it = (*it)->m_sets.begin();
 724                     for (; set_it != (*it)->m_sets.end(); set_it++)
 725                     {
 726                         if ((*set_it)->m_databases == databases
 727                             && query.match(&(*set_it)->m_query))
 728                         {
 729                             found_set = *set_it;
 730                             found_backend = *it;
 731                             bc->use_backend(found_backend);
 732                             // found matching set. No need to search again
 733                             return;
 734                         }
 735                     }
 736                 }
 737             }
 738         }
 739         override_set(found_backend, result_set_id, databases, out_of_sessions);
 740         if (found_backend)
 741             bc->use_backend(found_backend);
 742     }
 743     if (!found_backend)
 744     {
 745         // create a new backend set (and new set) if we're not out of sessions
 746         if (!out_of_sessions)
 747             found_backend = bc->create_backend(package);
 748
 749         if (!found_backend)
 750         {
 751             Z_APDU *f_apdu = 0;
 752             mp::odr odr;
 753             const char *addinfo = 0;
 754
 755             if (out_of_sessions)
 756                 addinfo = "session_shared: all sessions in use";
 757             else
 758                 addinfo = "session_shared: could not create backend";
 759             if (apdu_req->which == Z_APDU_searchRequest)
 760             {
 761                 f_apdu = odr.create_searchResponse(
 762                     apdu_req, YAZ_BIB1_TEMPORARY_SYSTEM_ERROR, addinfo);
 763             }
 764             else if (apdu_req->which == Z_APDU_presentRequest)
 765             {
 766                 f_apdu = odr.create_presentResponse(
 767                     apdu_req, YAZ_BIB1_TEMPORARY_SYSTEM_ERROR, addinfo);
 768             }
 769             else
 770             {
 771                 f_apdu = odr.create_close(
 772                     apdu_req, YAZ_BIB1_TEMPORARY_SYSTEM_ERROR, addinfo);
 773             }
 774             package.response() = f_apdu;
 775             return;
 776         }
 777         if (bc->m_named_result_sets)
 778         {
 779             result_set_id = boost::io::str(
 780                 boost::format("%1%") % found_backend->m_result_set_sequence);
 781             found_backend->m_result_set_sequence++;
 782         }
 783         else
 784             result_set_id = "default";
 785     }
 786     found_backend->timestamp();
 787
 788     // we must search ...
 789     BackendSetPtr new_set(new BackendSet(result_set_id,
 790                                          databases, query));
 791     Z_Records *z_records = 0;
 792
 793     Package search_package(found_backend->m_session, package.origin());
 794     search_package.copy_filter(package);
 795
 796     if (!new_set->search(package, search_package,
 797                          apdu_req, found_backend, &z_records))
 798     {
 799         bc->remove_backend(found_backend);
 800         return; // search error
 801     }
 802
 803     if (z_records)
 804     {
 805         int condition = 0;
 806         if (z_records->which == Z_Records_NSD)
 807         {
 808             condition =
 809                 get_diagnostic(z_records->u.nonSurrogateDiagnostic);
 810         }
 811         else if (z_records->which == Z_Records_multipleNSD)
 812         {
 813             if (z_records->u.multipleNonSurDiagnostics->num_diagRecs >= 1
 814                 &&
 815
 816                 z_records->u.multipleNonSurDiagnostics->diagRecs[0]->which ==
 817                 Z_DiagRec_defaultFormat)
 818             {
 819                 condition = get_diagnostic(
 820                     z_records->u.multipleNonSurDiagnostics->diagRecs[0]->u.defaultFormat);
 821
 822             }
 823         }
 824         if (m_p->m_restart && !session_restarted &&
 825             condition == YAZ_BIB1_TEMPORARY_SYSTEM_ERROR)
 826         {
 827             package.log("session_shared", YLOG_LOG, "restart");
 828             bc->remove_backend(found_backend);
 829             session_restarted = true;
 830             found_backend.reset();
 831             goto restart;
 832
 833         }
 834
 835         if (condition)
 836         {
 837             mp::odr odr;
 838             if (apdu_req->which == Z_APDU_searchRequest)
 839             {
 840                 Z_APDU *f_apdu = odr.create_searchResponse(apdu_req,
 841                                                            0, 0);
 842                 Z_SearchResponse *f_resp = f_apdu->u.searchResponse;
 843                 *f_resp->searchStatus = Z_SearchResponse_none;
 844                 f_resp->records = z_records;
 845                 package.response() = f_apdu;
 846             }
 847             if (apdu_req->which == Z_APDU_presentRequest)
 848             {
 849                 Z_APDU *f_apdu = odr.create_presentResponse(apdu_req,
 850                                                             0, 0);
 851                 Z_PresentResponse *f_resp = f_apdu->u.presentResponse;
 852                 f_resp->records = z_records;
 853                 package.response() = f_apdu;
 854             }
 855             bc->release_backend(found_backend);
 856             return; // search error
 857         }
 858     }
 859     if (m_p->m_restart && !session_restarted && new_set->m_result_set_size < 0)
 860     {
 861         package.log("session_shared", YLOG_LOG, "restart");
 862         bc->remove_backend(found_backend);
 863         session_restarted = true;
 864         found_backend.reset();
 865         goto restart;
 866     }
 867
 868     found_set = new_set;
 869     found_set->timestamp();
 870     found_backend->m_sets.push_back(found_set);
 871 }
 872
 873 int yf::SessionShared::Frontend::result_set_ref(ODR o,
 874                                                 const Databases &databases,
 875                                                 Z_RPNStructure *s,
 876                                                 std::string &rset)
 877 {
 878     int ret = 0;
 879     switch (s->which)
 880     {
 881     case Z_RPNStructure_simple:
 882         if (s->u.simple->which == Z_Operand_resultSetId)
 883         {
 884             const char *id = s->u.simple->u.resultSetId;
 885             rset = id;
 886
 887             FrontendSets::iterator fset_it = m_frontend_sets.find(id);
 888             if (fset_it == m_frontend_sets.end())
 889             {
 890                 ret = YAZ_BIB1_SPECIFIED_RESULT_SET_DOES_NOT_EXIST;
 891             }
 892             else if (fset_it->second->get_databases() != databases)
 893             {
 894                 ret = YAZ_BIB1_SPECIFIED_RESULT_SET_DOES_NOT_EXIST;
 895             }
 896             else
 897             {
 898                 yazpp_1::Yaz_Z_Query query = fset_it->second->get_query();
 899                 Z_Query *q = yaz_copy_Z_Query(query.get_Z_Query(), o);
 900                 if (q->which == Z_Query_type_1 || q->which == Z_Query_type_101)
 901                 {
 902                     s->which = q->u.type_1->RPNStructure->which;
 903                     s->u.simple = q->u.type_1->RPNStructure->u.simple;
 904                 }
 905                 else
 906                 {
 907                     ret = YAZ_BIB1_SPECIFIED_RESULT_SET_DOES_NOT_EXIST;
 908                 }
 909             }
 910         }
 911         break;
 912     case Z_RPNStructure_complex:
 913         ret = result_set_ref(o, databases, s->u.complex->s1, rset);
 914         if (!ret)
 915             ret = result_set_ref(o, databases, s->u.complex->s2, rset);
 916         break;
 917     }
 918     return ret;
 919 }
 920
 921 void yf::SessionShared::Frontend::search(mp::Package &package,
 922                                          Z_APDU *apdu_req)
 923 {
 924     Z_SearchRequest *req = apdu_req->u.searchRequest;
 925     FrontendSets::iterator fset_it =
 926         m_frontend_sets.find(req->resultSetName);
 927     if (fset_it != m_frontend_sets.end())
 928     {
 929         // result set already exist
 930         // if replace indicator is off: we return diagnostic if
 931         // result set already exist.
 932         if (*req->replaceIndicator == 0)
 933         {
 934             mp::odr odr;
 935             Z_APDU *apdu =
 936                 odr.create_searchResponse(
 937                     apdu_req,
 938                     YAZ_BIB1_RESULT_SET_EXISTS_AND_REPLACE_INDICATOR_OFF,
 939                     0);
 940             package.response() = apdu;
 941             return;
 942         }
 943         m_frontend_sets.erase(fset_it);
 944     }
 945
 946     Databases databases;
 947     int i;
 948     for (i = 0; i < req->num_databaseNames; i++)
 949         databases.push_back(req->databaseNames[i]);
 950
 951
 952     yazpp_1::Yaz_Z_Query query;
 953     query.set_Z_Query(req->query);
 954
 955     Z_Query *q = query.get_Z_Query();
 956     if (q->which == Z_Query_type_1 || q->which == Z_Query_type_101)
 957     {
 958         mp::odr odr;
 959         std::string rset;
 960         int diag = result_set_ref(odr, databases, q->u.type_1->RPNStructure,
 961                                   rset);
 962         if (diag)
 963         {
 964             Z_APDU *apdu =
 965                 odr.create_searchResponse(
 966                     apdu_req,
 967                     diag,
 968                     rset.c_str());
 969             package.response() = apdu;
 970             return;
 971         }
 972         query.set_Z_Query(q);
 973     }
 974
 975     BackendSetPtr found_set; // null
 976     BackendInstancePtr found_backend; // null
 977
 978     get_set(package, apdu_req, databases, query, found_backend, found_set);
 979     if (!found_set)
 980         return;
 981
 982     mp::odr odr;
 983     Z_APDU *f_apdu = odr.create_searchResponse(apdu_req, 0, 0);
 984     Z_SearchResponse *f_resp = f_apdu->u.searchResponse;
 985     *f_resp->resultCount = found_set->m_result_set_size;
 986     package.response() = f_apdu;
 987
 988     FrontendSetPtr fset(new FrontendSet(databases, query));
 989     m_frontend_sets[req->resultSetName] = fset;
 990
 991     m_backend_class->release_backend(found_backend);
 992 }
 993
 994 void yf::SessionShared::Frontend::present(mp::Package &package,
 995                                           Z_APDU *apdu_req)
 996 {
 997     mp::odr odr;
 998     Z_PresentRequest *req = apdu_req->u.presentRequest;
 999
1000     FrontendSets::iterator fset_it =
1001         m_frontend_sets.find(req->resultSetId);
1002
1003     if (fset_it == m_frontend_sets.end())
1004     {
1005         Z_APDU *apdu =
1006             odr.create_presentResponse(
1007                 apdu_req,
1008                 YAZ_BIB1_SPECIFIED_RESULT_SET_DOES_NOT_EXIST,
1009                 req->resultSetId);
1010         package.response() = apdu;
1011         return;
1012     }
1013     FrontendSetPtr fset = fset_it->second;
1014
1015     Databases databases = fset->get_databases();
1016     yazpp_1::Yaz_Z_Query query = fset->get_query();
1017
1018     BackendClassPtr bc = m_backend_class;
1019     BackendSetPtr found_set; // null
1020     BackendInstancePtr found_backend;
1021
1022     get_set(package, apdu_req, databases, query, found_backend, found_set);
1023     if (!found_set)
1024         return;
1025
1026     Z_NamePlusRecordList *npr_res = 0;
1027     if (found_set->m_record_cache.lookup(odr, &npr_res,
1028                                          *req->resultSetStartPoint,
1029                                          *req->numberOfRecordsRequested,
1030                                          req->preferredRecordSyntax,
1031                                          req->recordComposition))
1032     {
1033         Z_APDU *f_apdu_res = odr.create_presentResponse(apdu_req, 0, 0);
1034         Z_PresentResponse *f_resp = f_apdu_res->u.presentResponse;
1035
1036         yaz_log(YLOG_LOG, "Found " ODR_INT_PRINTF "+" ODR_INT_PRINTF
1037                 " records in cache %p",
1038                 *req->resultSetStartPoint,
1039                 *req->numberOfRecordsRequested,
1040                 &found_set->m_record_cache);
1041
1042         *f_resp->numberOfRecordsReturned = *req->numberOfRecordsRequested;
1043         *f_resp->nextResultSetPosition =
1044             *req->resultSetStartPoint + *req->numberOfRecordsRequested;
1045         // f_resp->presentStatus assumed OK.
1046         f_resp->records = (Z_Records *) odr_malloc(odr, sizeof(Z_Records));
1047         f_resp->records->which = Z_Records_DBOSD;
1048         f_resp->records->u.databaseOrSurDiagnostics = npr_res;
1049         package.response() = f_apdu_res;
1050         bc->release_backend(found_backend);
1051         return;
1052     }
1053
1054     found_backend->timestamp();
1055
1056     Z_APDU *p_apdu = zget_APDU(odr, Z_APDU_presentRequest);
1057     Z_PresentRequest *p_req = p_apdu->u.presentRequest;
1058     p_req->preferredRecordSyntax = req->preferredRecordSyntax;
1059     p_req->resultSetId = odr_strdup(odr, found_set->m_result_set_id.c_str());
1060     *p_req->resultSetStartPoint = *req->resultSetStartPoint;
1061     *p_req->numberOfRecordsRequested = *req->numberOfRecordsRequested;
1062     p_req->preferredRecordSyntax = req->preferredRecordSyntax;
1063     p_req->recordComposition = req->recordComposition;
1064
1065     Package present_package(found_backend->m_session, package.origin());
1066     present_package.copy_filter(package);
1067
1068     present_package.request() = p_apdu;
1069
1070     present_package.move();
1071
1072     Z_GDU *gdu = present_package.response().get();
1073     if (!present_package.session().is_closed()
1074         && gdu && gdu->which == Z_GDU_Z3950
1075         && gdu->u.z3950->which == Z_APDU_presentResponse)
1076     {
1077         Z_PresentResponse *b_resp = gdu->u.z3950->u.presentResponse;
1078         Z_APDU *f_apdu_res = odr.create_presentResponse(apdu_req, 0, 0);
1079         Z_PresentResponse *f_resp = f_apdu_res->u.presentResponse;
1080
1081         f_resp->numberOfRecordsReturned = b_resp->numberOfRecordsReturned;
1082         f_resp->nextResultSetPosition = b_resp->nextResultSetPosition;
1083         f_resp->presentStatus= b_resp->presentStatus;
1084         f_resp->records = b_resp->records;
1085         f_resp->otherInfo = b_resp->otherInfo;
1086         package.response() = f_apdu_res;
1087
1088         if (b_resp->records && b_resp->records->which ==  Z_Records_DBOSD)
1089         {
1090 #if 0
1091             yaz_log(YLOG_LOG, "Adding " ODR_INT_PRINTF "+" ODR_INT_PRINTF
1092                     " records to cache %p",
1093                     *req->resultSetStartPoint,
1094                     *f_resp->numberOfRecordsReturned,
1095                     &found_set->m_record_cache);
1096 #endif
1097             found_set->m_record_cache.add(
1098                 odr,
1099                 b_resp->records->u.databaseOrSurDiagnostics,
1100                 *req->resultSetStartPoint,
1101                 *f_resp->numberOfRecordsReturned);
1102         }
1103         bc->release_backend(found_backend);
1104     }
1105     else
1106     {
1107         bc->remove_backend(found_backend);
1108         Z_APDU *f_apdu_res =
1109             odr.create_presentResponse(
1110                 apdu_req, YAZ_BIB1_TEMPORARY_SYSTEM_ERROR,
1111                 "session_shared: target closed connection during present");
1112         package.response() = f_apdu_res;
1113     }
1114 }
1115
1116 void yf::SessionShared::Frontend::scan(mp::Package &frontend_package,
1117                                        Z_APDU *apdu_req)
1118 {
1119     BackendClassPtr bc = m_backend_class;
1120     BackendInstancePtr backend = bc->get_backend(frontend_package);
1121     if (!backend)
1122     {
1123         mp::odr odr;
1124         Z_APDU *apdu = odr.create_scanResponse(
1125             apdu_req, YAZ_BIB1_TEMPORARY_SYSTEM_ERROR,
1126             "session_shared: could not create backend");
1127         frontend_package.response() = apdu;
1128     }
1129     else
1130     {
1131         Package scan_package(backend->m_session, frontend_package.origin());
1132         backend->timestamp();
1133         scan_package.copy_filter(frontend_package);
1134         scan_package.request() = apdu_req;
1135         scan_package.move();
1136         frontend_package.response() = scan_package.response();
1137         if (scan_package.session().is_closed())
1138         {
1139             frontend_package.session().close();
1140             bc->remove_backend(backend);
1141         }
1142         else
1143             bc->release_backend(backend);
1144     }
1145 }
1146
1147 yf::SessionShared::Worker::Worker(SessionShared::Rep *rep) : m_p(rep)
1148 {
1149 }
1150
1151 void yf::SessionShared::Worker::operator() (void)
1152 {
1153     m_p->expire();
1154 }
1155
1156 bool yf::SessionShared::BackendClass::expire_instances()
1157 {
1158     time_t now;
1159     time(&now);
1160     boost::mutex::scoped_lock lock(m_mutex_backend_class);
1161     BackendInstanceList::iterator bit = m_backend_list.begin();
1162     while (bit != m_backend_list.end())
1163     {
1164         time_t last_use = (*bit)->m_time_last_use;
1165
1166         if ((*bit)->m_in_use)
1167         {
1168             bit++;
1169         }
1170         else if (now < last_use || now - last_use > m_backend_expiry_ttl)
1171         {
1172             mp::odr odr;
1173             (*bit)->m_close_package->response() = odr.create_close(
1174                 0, Z_Close_lackOfActivity, 0);
1175             (*bit)->m_close_package->session().close();
1176             (*bit)->m_close_package->move();
1177
1178             bit = m_backend_list.erase(bit);
1179         }
1180         else
1181         {
1182             bit++;
1183         }
1184     }
1185     if (m_backend_list.empty())
1186         return true;
1187     return false;
1188 }
1189
1190 void yf::SessionShared::Rep::expire_classes()
1191 {
1192     boost::mutex::scoped_lock lock(m_mutex_backend_map);
1193     BackendClassMap::iterator b_it = m_backend_map.begin();
1194     while (b_it != m_backend_map.end())
1195     {
1196         if (b_it->second->expire_instances())
1197         {
1198             m_backend_map.erase(b_it);
1199             b_it = m_backend_map.begin();
1200         }
1201         else
1202             b_it++;
1203     }
1204 }
1205
1206 void yf::SessionShared::Rep::expire()
1207 {
1208     while (true)
1209     {
1210         boost::xtime xt;
1211         boost::xtime_get(&xt,
1212 #if BOOST_VERSION >= 105000
1213                 boost::TIME_UTC_
1214 #else
1215                 boost::TIME_UTC
1216 #endif
1217                   );
1218         xt.sec += m_session_ttl / 3;
1219         boost::thread::sleep(xt);
1220
1221         stat();
1222         expire_classes();
1223     }
1224 }
1225
1226 yf::SessionShared::Rep::Rep()
1227 {
1228     m_resultset_ttl = 30;
1229     m_resultset_max = 10;
1230     m_session_ttl = 90;
1231     m_optimize_search = true;
1232     m_restart = false;
1233     m_session_max = 100;
1234     m_preferredMessageSize = 0;
1235     m_maximumRecordSize = 0;
1236 }
1237
1238 void yf::SessionShared::Rep::start()
1239 {
1240     yf::SessionShared::Worker w(this);
1241     m_thrds.add_thread(new boost::thread(w));
1242 }
1243
1244 yf::SessionShared::SessionShared() : m_p(new SessionShared::Rep)
1245 {
1246 }
1247
1248 yf::SessionShared::~SessionShared() {
1249 }
1250
1251 void yf::SessionShared::start() const
1252 {
1253     m_p->start();
1254 }
1255
1256 yf::SessionShared::Frontend::Frontend(Rep *rep) : m_is_virtual(false), m_p(rep)
1257 {
1258 }
1259
1260 yf::SessionShared::Frontend::~Frontend()
1261 {
1262 }
1263
1264 yf::SessionShared::FrontendPtr yf::SessionShared::Rep::get_frontend(mp::Package &package)
1265 {
1266     boost::mutex::scoped_lock lock(m_mutex);
1267
1268     std::map<mp::Session,yf::SessionShared::FrontendPtr>::iterator it;
1269
1270     while(true)
1271     {
1272         it = m_clients.find(package.session());
1273         if (it == m_clients.end())
1274             break;
1275
1276         if (!it->second->m_in_use)
1277         {
1278             it->second->m_in_use = true;
1279             return it->second;
1280         }
1281         m_cond_session_ready.wait(lock);
1282     }
1283     FrontendPtr f(new Frontend(this));
1284     m_clients[package.session()] = f;
1285     f->m_in_use = true;
1286     return f;
1287 }
1288
1289 void yf::SessionShared::Rep::release_frontend(mp::Package &package)
1290 {
1291     boost::mutex::scoped_lock lock(m_mutex);
1292     std::map<mp::Session,yf::SessionShared::FrontendPtr>::iterator it;
1293
1294     it = m_clients.find(package.session());
1295     if (it != m_clients.end())
1296     {
1297         if (package.session().is_closed())
1298         {
1299             m_clients.erase(it);
1300         }
1301         else
1302         {
1303             it->second->m_in_use = false;
1304         }
1305         m_cond_session_ready.notify_all();
1306     }
1307 }
1308
1309
1310 void yf::SessionShared::process(mp::Package &package) const
1311 {
1312     FrontendPtr f = m_p->get_frontend(package);
1313
1314     Z_GDU *gdu = package.request().get();
1315
1316     if (gdu && gdu->which == Z_GDU_Z3950 && gdu->u.z3950->which ==
1317         Z_APDU_initRequest && !f->m_is_virtual)
1318     {
1319         m_p->init(package, gdu, f);
1320     }
1321     else if (!f->m_is_virtual)
1322         package.move();
1323     else if (gdu && gdu->which == Z_GDU_Z3950)
1324     {
1325         Z_APDU *apdu = gdu->u.z3950;
1326         if (apdu->which == Z_APDU_initRequest)
1327         {
1328             mp::odr odr;
1329
1330             package.response() = odr.create_close(
1331                 apdu,
1332                 Z_Close_protocolError,
1333                 "double init");
1334
1335             package.session().close();
1336         }
1337         else if (apdu->which == Z_APDU_close)
1338         {
1339             mp::odr odr;
1340
1341             package.response() = odr.create_close(
1342                 apdu,
1343                 Z_Close_peerAbort, "received close from client");
1344             package.session().close();
1345         }
1346         else if (apdu->which == Z_APDU_searchRequest)
1347         {
1348             f->search(package, apdu);
1349         }
1350         else if (apdu->which == Z_APDU_presentRequest)
1351         {
1352             f->present(package, apdu);
1353         }
1354         else if (apdu->which == Z_APDU_scanRequest)
1355         {
1356             f->scan(package, apdu);
1357         }
1358         else
1359         {
1360             mp::odr odr;
1361
1362             package.response() = odr.create_close(
1363                 apdu, Z_Close_protocolError,
1364                 "unsupported APDU in filter_session_shared");
1365
1366             package.session().close();
1367         }
1368     }
1369     m_p->release_frontend(package);
1370 }
1371
1372 void yf::SessionShared::configure(const xmlNode *ptr, bool test_only,
1373                                   const char *path)
1374 {
1375     for (ptr = ptr->children; ptr; ptr = ptr->next)
1376     {
1377         if (ptr->type != XML_ELEMENT_NODE)
1378             continue;
1379         if (!strcmp((const char *) ptr->name, "resultset"))
1380         {
1381             const struct _xmlAttr *attr;
1382             for (attr = ptr->properties; attr; attr = attr->next)
1383             {
1384                 if (!strcmp((const char *) attr->name, "ttl"))
1385                     m_p->m_resultset_ttl =
1386                         mp::xml::get_int(attr->children, 30);
1387                 else if (!strcmp((const char *) attr->name, "max"))
1388                 {
1389                     m_p->m_resultset_max =
1390                         mp::xml::get_int(attr->children, 10);
1391                 }
1392                 else if (!strcmp((const char *) attr->name, "optimizesearch"))
1393                 {
1394                     m_p->m_optimize_search =
1395                         mp::xml::get_bool(attr->children, true);
1396                 }
1397                 else if (!strcmp((const char *) attr->name, "restart"))
1398                 {
1399                     m_p->m_restart = mp::xml::get_bool(attr->children, true);
1400                 }
1401                 else
1402                     throw mp::filter::FilterException(
1403                         "Bad attribute " + std::string((const char *)
1404                                                        attr->name));
1405             }
1406         }
1407         else if (!strcmp((const char *) ptr->name, "session"))
1408         {
1409             const struct _xmlAttr *attr;
1410             for (attr = ptr->properties; attr; attr = attr->next)
1411             {
1412                 if (!strcmp((const char *) attr->name, "ttl"))
1413                     m_p->m_session_ttl =
1414                         mp::xml::get_int(attr->children, 90);
1415                 else if (!strcmp((const char *) attr->name, "max"))
1416                     m_p->m_session_max =
1417                         mp::xml::get_int(attr->children, 100);
1418                 else
1419                     throw mp::filter::FilterException(
1420                         "Bad attribute " + std::string((const char *)
1421                                                        attr->name));
1422             }
1423         }
1424         else if (!strcmp((const char *) ptr->name, "init"))
1425         {
1426             const struct _xmlAttr *attr;
1427             for (attr = ptr->properties; attr; attr = attr->next)
1428             {
1429                 if (!strcmp((const char *) attr->name, "maximum-record-size"))
1430                     m_p->m_maximumRecordSize =
1431                         mp::xml::get_int(attr->children, 0);
1432                 else if (!strcmp((const char *) attr->name,
1433                                  "preferred-message-size"))
1434                     m_p->m_preferredMessageSize =
1435                         mp::xml::get_int(attr->children, 0);
1436                 else
1437                     throw mp::filter::FilterException(
1438                         "Bad attribute " + std::string((const char *)
1439                                                        attr->name));
1440             }
1441         }
1442         else
1443         {
1444             throw mp::filter::FilterException("Bad element "
1445                                                + std::string((const char *)
1446                                                              ptr->name));
1447         }
1448     }
1449 }
1450
1451 static mp::filter::Base* filter_creator()
1452 {
1453     return new mp::filter::SessionShared;
1454 }
1455
1456 extern "C" {
1457     struct metaproxy_1_filter_struct metaproxy_1_filter_session_shared = {
1458         0,
1459         "session_shared",
1460         filter_creator
1461     };
1462 }
1463
1464 /*
1465  * Local variables:
1466  * c-basic-offset: 4
1467  * c-file-style: "Stroustrup"
1468  * indent-tabs-mode: nil
1469  * End:
1470  * vim: shiftwidth=4 tabstop=8 expandtab
1471  */
1472