src/filter_virt_db.cpp

   1 /* $Id: filter_virt_db.cpp,v 1.11 2005-10-30 17:13:36 adam Exp $
   2    Copyright (c) 2005, Index Data.
   3
   4 %LICENSE%
   5  */
   6
   7 #include "config.hpp"
   8
   9 #include "filter.hpp"
  10 #include "router.hpp"
  11 #include "package.hpp"
  12
  13 #include <boost/thread/mutex.hpp>
  14
  15 #include "util.hpp"
  16 #include "filter_virt_db.hpp"
  17
  18 #include <yaz/zgdu.h>
  19 #include <yaz/log.h>
  20 #include <yaz/otherinfo.h>
  21 #include <yaz/diagbib1.h>
  22
  23 #include <list>
  24 #include <map>
  25 #include <iostream>
  26
  27 namespace yf = yp2::filter;
  28
  29 namespace yp2 {
  30     namespace filter {
  31         struct Virt_db_set {
  32             Virt_db_set(yp2::Session &id, std::string setname,
  33                         std::string vhost, bool named_result_sets);
  34             Virt_db_set();
  35             ~Virt_db_set();
  36
  37             yp2::Session m_backend_session;
  38             std::string m_backend_setname;
  39             std::string m_vhost;
  40             bool m_named_result_sets;
  41         };
  42         struct Virt_db_session {
  43             Virt_db_session(yp2::Session &id, bool use_vhost);
  44             Virt_db_session();
  45             yp2::Session m_session;
  46             bool m_use_vhost;
  47             std::map<std::string,Virt_db_set> m_sets;
  48         };
  49         struct Virt_db_map {
  50             Virt_db_map(std::string vhost);
  51             Virt_db_map();
  52             std::string m_vhost;
  53         };
  54         class Virt_db::Rep {
  55             friend class Virt_db;
  56
  57             void release_session(Package &package);
  58             void init(Package &package, Z_APDU *apdu, bool &move_later);
  59             void search(Package &package, Z_APDU *apdu, bool &move_later);
  60             void present(Package &package, Z_APDU *apdu, bool &move_later);
  61         private:
  62             boost::mutex m_sessions_mutex;
  63             std::map<yp2::Session,Virt_db_session>m_sessions;
  64             std::map<std::string, Virt_db_map>m_maps;
  65
  66             typedef std::map<yp2::Session,Virt_db_session>::iterator Ses_it;
  67             typedef std::map<std::string,Virt_db_set>::iterator Sets_it;
  68         };
  69     }
  70 }
  71
  72 yf::Virt_db_set::Virt_db_set(yp2::Session &id, std::string setname,
  73                              std::string vhost, bool named_result_sets)
  74     :   m_backend_session(id), m_backend_setname(setname), m_vhost(vhost),
  75         m_named_result_sets(named_result_sets)
  76 {
  77 }
  78
  79
  80 yf::Virt_db_set::Virt_db_set()
  81 {
  82 }
  83
  84
  85 yf::Virt_db_set::~Virt_db_set()
  86 {
  87 }
  88
  89 yf::Virt_db_map::Virt_db_map(std::string vhost)
  90     : m_vhost(vhost)
  91 {
  92 }
  93
  94 yf::Virt_db_map::Virt_db_map()
  95 {
  96 }
  97
  98 yf::Virt_db_session::Virt_db_session()
  99     : m_use_vhost(false)
 100 {
 101
 102 }
 103
 104 yf::Virt_db_session::Virt_db_session(yp2::Session &id,
 105                                      bool use_vhost) :
 106     m_session(id) , m_use_vhost(use_vhost)
 107 {
 108
 109 }
 110
 111 yf::Virt_db::Virt_db() : m_p(new Virt_db::Rep)
 112 {
 113 }
 114
 115 yf::Virt_db::~Virt_db() {
 116 }
 117
 118 void yf::Virt_db::Rep::release_session(Package &package)
 119 {
 120     boost::mutex::scoped_lock lock(m_sessions_mutex);
 121
 122     m_sessions.erase(package.session());
 123 }
 124
 125 void yf::Virt_db::Rep::present(Package &package, Z_APDU *apdu, bool &move_later){
 126     Session *id = 0;
 127     Z_PresentRequest *req = apdu->u.presentRequest;
 128     std::string resultSetId = req->resultSetId;
 129     yp2::odr odr;
 130     {
 131         boost::mutex::scoped_lock lock(m_sessions_mutex);
 132
 133         Ses_it it = m_sessions.find(package.session());
 134         if (it == m_sessions.end())
 135         {
 136             Z_APDU *apdu = zget_APDU(odr, Z_APDU_close);
 137
 138             *apdu->u.close->closeReason = Z_Close_protocolError;
 139             apdu->u.close->diagnosticInformation =
 140                 odr_strdup(odr, "no session for present request");
 141
 142             package.response() = apdu;
 143             package.session().close();
 144
 145             return;
 146         }
 147         if (it->second.m_use_vhost)
 148         {
 149             move_later = true;
 150             return;
 151         }
 152         Sets_it sets_it = it->second.m_sets.find(resultSetId);
 153         if (sets_it == it->second.m_sets.end())
 154         {
 155             Z_APDU *apdu = zget_APDU(odr, Z_APDU_presentResponse);
 156
 157             Z_Records *rec = (Z_Records *) odr_malloc(odr, sizeof(Z_Records));
 158             apdu->u.presentResponse->records = rec;
 159             rec->which = Z_Records_NSD;
 160             rec->u.nonSurrogateDiagnostic =
 161                 zget_DefaultDiagFormat(
 162                     odr,
 163                     YAZ_BIB1_SPECIFIED_RESULT_SET_DOES_NOT_EXIST,
 164                     resultSetId.c_str());
 165             package.response() = apdu;
 166
 167             return;
 168         }
 169         id = new yp2::Session(sets_it->second.m_backend_session);
 170     }
 171
 172     // sending present to backend
 173     Package present_package(*id, package.origin());
 174     present_package.copy_filter(package);
 175
 176     req->resultSetId = odr_strdup(odr, "default");
 177     present_package.request() = yazpp_1::GDU(apdu);
 178
 179     present_package.move();
 180
 181     if (present_package.session().is_closed())
 182     {
 183         Z_APDU *apdu = zget_APDU(odr, Z_APDU_presentResponse);
 184
 185         Z_Records *rec = (Z_Records *) odr_malloc(odr, sizeof(Z_Records));
 186         apdu->u.presentResponse->records = rec;
 187         rec->which = Z_Records_NSD;
 188         rec->u.nonSurrogateDiagnostic =
 189             zget_DefaultDiagFormat(
 190                 odr,
 191                 YAZ_BIB1_RESULT_SET_NO_LONGER_EXISTS_UNILATERALLY_DELETED_BY_,
 192                 resultSetId.c_str());
 193         package.response() = apdu;
 194
 195         boost::mutex::scoped_lock lock(m_sessions_mutex);
 196         Ses_it it = m_sessions.find(package.session());
 197         if (it != m_sessions.end())
 198             it->second.m_sets.erase(resultSetId);
 199     }
 200     else
 201     {
 202         package.response() = present_package.response();
 203     }
 204     delete id;
 205 }
 206
 207 void yf::Virt_db::Rep::search(Package &package, Z_APDU *apdu, bool &move_later)
 208 {
 209     Z_SearchRequest *req = apdu->u.searchRequest;
 210     std::string vhost;
 211     std::string database;
 212     std::string resultSetId = req->resultSetName;
 213     bool support_named_result_sets = false;  // whether backend supports it
 214     yp2::odr odr;
 215     {
 216         boost::mutex::scoped_lock lock(m_sessions_mutex);
 217
 218         Ses_it it = m_sessions.find(package.session());
 219         if (it == m_sessions.end())
 220         {
 221             Z_APDU *apdu = zget_APDU(odr, Z_APDU_close);
 222
 223             *apdu->u.close->closeReason = Z_Close_protocolError;
 224             apdu->u.close->diagnosticInformation =
 225                 odr_strdup(odr, "no session for search request");
 226
 227             package.response() = apdu;
 228             package.session().close();
 229
 230             return;
 231         }
 232         if (it->second.m_use_vhost)
 233         {
 234             move_later = true;
 235             return;
 236         }
 237         if (req->num_databaseNames != 1)
 238         {   // exactly one database must be specified
 239             Z_APDU *apdu = zget_APDU(odr, Z_APDU_searchResponse);
 240
 241             Z_Records *rec = (Z_Records *) odr_malloc(odr, sizeof(Z_Records));
 242             apdu->u.searchResponse->records = rec;
 243             rec->which = Z_Records_NSD;
 244             rec->u.nonSurrogateDiagnostic =
 245                 zget_DefaultDiagFormat(
 246                     odr, YAZ_BIB1_TOO_MANY_DATABASES_SPECIFIED, 0);
 247             package.response() = apdu;
 248
 249             return;
 250         }
 251         database = req->databaseNames[0];
 252         std::map<std::string, Virt_db_map>::iterator map_it;
 253         map_it = m_maps.find(database);
 254         if (map_it == m_maps.end())
 255         {   // no map for database: return diagnostic
 256             Z_APDU *apdu = zget_APDU(odr, Z_APDU_searchResponse);
 257
 258             Z_Records *rec = (Z_Records *) odr_malloc(odr, sizeof(Z_Records));
 259             apdu->u.searchResponse->records = rec;
 260             rec->which = Z_Records_NSD;
 261             rec->u.nonSurrogateDiagnostic =
 262                 zget_DefaultDiagFormat(
 263                     odr, YAZ_BIB1_DATABASE_DOES_NOT_EXIST, database.c_str());
 264             package.response() = apdu;
 265
 266             return;
 267         }
 268         if (*req->replaceIndicator == 0)
 269         {
 270             Sets_it sets_it = it->second.m_sets.find(req->resultSetName);
 271             if (sets_it != it->second.m_sets.end())
 272             {
 273                 Z_APDU *apdu = zget_APDU(odr, Z_APDU_searchResponse);
 274
 275                 Z_Records *rec = (Z_Records *) odr_malloc(odr, sizeof(Z_Records));
 276                 apdu->u.searchResponse->records = rec;
 277                 rec->which = Z_Records_NSD;
 278                 rec->u.nonSurrogateDiagnostic =
 279                     zget_DefaultDiagFormat(
 280                         odr,
 281                         YAZ_BIB1_RESULT_SET_EXISTS_AND_REPLACE_INDICATOR_OFF,
 282                         0);
 283                 package.response() = apdu;
 284
 285                 return;
 286             }
 287         }
 288         it->second.m_sets.erase(req->resultSetName);
 289         vhost = map_it->second.m_vhost;
 290     }
 291     // we might look for an existing session with same vhost
 292     Session id;
 293     const char *vhost_cstr = vhost.c_str();
 294     if (true)
 295     {  // sending init to backend
 296         Package init_package(id, package.origin());
 297         init_package.copy_filter(package);
 298
 299         Z_APDU *init_apdu = zget_APDU(odr, Z_APDU_initRequest);
 300
 301         yaz_oi_set_string_oidval(&init_apdu->u.initRequest->otherInfo, odr,
 302                                  VAL_PROXY, 1, vhost_cstr);
 303
 304         init_package.request() = init_apdu;
 305
 306         init_package.move();  // sending init
 307
 308         if (init_package.session().is_closed())
 309         {
 310             Z_APDU *apdu = zget_APDU(odr, Z_APDU_searchResponse);
 311
 312             Z_Records *rec = (Z_Records *) odr_malloc(odr, sizeof(Z_Records));
 313             apdu->u.searchResponse->records = rec;
 314             rec->which = Z_Records_NSD;
 315             rec->u.nonSurrogateDiagnostic =
 316                 zget_DefaultDiagFormat(
 317                     odr, YAZ_BIB1_DATABASE_UNAVAILABLE, database.c_str());
 318             package.response() = apdu;
 319         }
 320         Z_GDU *gdu = init_package.response().get();
 321         // we hope to get an init response
 322         if (gdu && gdu->which == Z_GDU_Z3950 && gdu->u.z3950->which ==
 323             Z_APDU_initResponse)
 324         {
 325             if (ODR_MASK_GET(gdu->u.z3950->u.initResponse->options,
 326                              Z_Options_namedResultSets))
 327                 support_named_result_sets = true;
 328         }
 329         else
 330         {
 331             Z_APDU *apdu = zget_APDU(odr, Z_APDU_searchResponse);
 332
 333             Z_Records *rec = (Z_Records *) odr_malloc(odr, sizeof(Z_Records));
 334             apdu->u.searchResponse->records = rec;
 335             rec->which = Z_Records_NSD;
 336             rec->u.nonSurrogateDiagnostic =
 337                 zget_DefaultDiagFormat(
 338                     odr, YAZ_BIB1_DATABASE_UNAVAILABLE, database.c_str());
 339             package.response() = apdu;
 340
 341             return;
 342         }
 343     }
 344     // sending search to backend
 345     Package search_package(id, package.origin());
 346
 347     search_package.copy_filter(package);
 348     const char *sep = strchr(vhost_cstr, '/');
 349     if (sep)
 350         req->databaseNames[0] = odr_strdup(odr, sep+1);
 351
 352     *req->replaceIndicator = 1;
 353
 354     std::string backend_resultSetId = "default";
 355     req->resultSetName = odr_strdup(odr, backend_resultSetId.c_str());
 356     search_package.request() = yazpp_1::GDU(apdu);
 357
 358     search_package.move();
 359
 360     if (search_package.session().is_closed())
 361     {
 362         Z_APDU *apdu = zget_APDU(odr, Z_APDU_searchResponse);
 363
 364         Z_Records *rec = (Z_Records *) odr_malloc(odr, sizeof(Z_Records));
 365         apdu->u.searchResponse->records = rec;
 366         rec->which = Z_Records_NSD;
 367         rec->u.nonSurrogateDiagnostic =
 368             zget_DefaultDiagFormat(
 369                 odr, YAZ_BIB1_DATABASE_UNAVAILABLE, database.c_str());
 370         package.response() = apdu;
 371
 372         return;
 373     }
 374     package.response() = search_package.response();
 375
 376     boost::mutex::scoped_lock lock(m_sessions_mutex);
 377     Ses_it it = m_sessions.find(package.session());
 378     if (it != m_sessions.end())
 379         it->second.m_sets[resultSetId] =
 380             Virt_db_set(id, backend_resultSetId, vhost,
 381                         support_named_result_sets);
 382 }
 383
 384 void yf::Virt_db::Rep::init(Package &package, Z_APDU *apdu, bool &move_later)
 385 {
 386     release_session(package);
 387     boost::mutex::scoped_lock lock(m_sessions_mutex);
 388
 389     Z_InitRequest *req = apdu->u.initRequest;
 390
 391     const char *vhost =
 392         yaz_oi_get_string_oidval(&req->otherInfo, VAL_PROXY, 1, 0);
 393     if (!vhost)
 394     {
 395         yp2::odr odr;
 396         Z_APDU *apdu = zget_APDU(odr, Z_APDU_initResponse);
 397         Z_InitResponse *resp = apdu->u.initResponse;
 398
 399         int i;
 400         static const int masks[] = {
 401             Z_Options_search, Z_Options_present, Z_Options_namedResultSets, -1
 402         };
 403         for (i = 0; masks[i] != -1; i++)
 404             if (ODR_MASK_GET(req->options, masks[i]))
 405                 ODR_MASK_SET(resp->options, masks[i]);
 406
 407         static const int versions[] = {
 408             Z_ProtocolVersion_1,
 409             Z_ProtocolVersion_2,
 410             Z_ProtocolVersion_3,
 411             -1
 412         };
 413         for (i = 0; versions[i] != -1; i++)
 414             if (ODR_MASK_GET(req->protocolVersion, versions[i]))
 415                 ODR_MASK_SET(resp->protocolVersion, versions[i]);
 416             else
 417                 break;
 418
 419         package.response() = apdu;
 420
 421         m_sessions[package.session()] = Virt_db_session(package.session(), false);
 422     }
 423     else
 424     {
 425         m_sessions[package.session()] = Virt_db_session(package.session(), true);
 426         move_later = true;
 427     }
 428 }
 429
 430 void yf::Virt_db::add_map_db2vhost(std::string db, std::string vhost)
 431 {
 432     m_p->m_maps[db] = Virt_db_map(vhost);
 433 }
 434
 435 void yf::Virt_db::process(Package &package) const
 436 {
 437     Z_GDU *gdu = package.request().get();
 438
 439     if (!gdu || gdu->which != Z_GDU_Z3950)
 440         package.move();
 441     else
 442     {
 443         bool move_later = false;
 444         Z_APDU *apdu = gdu->u.z3950;
 445         if (apdu->which == Z_APDU_initRequest)
 446         {
 447             m_p->init(package, apdu, move_later);
 448         }
 449         else if (apdu->which == Z_APDU_searchRequest)
 450         {
 451             m_p->search(package, apdu, move_later);
 452         }
 453         else if (apdu->which == Z_APDU_presentRequest)
 454         {
 455             m_p->present(package, apdu, move_later);
 456         }
 457         else
 458         {
 459             yp2::odr odr;
 460
 461             Z_APDU *apdu = zget_APDU(odr, Z_APDU_close);
 462
 463             *apdu->u.close->closeReason = Z_Close_protocolError;
 464
 465             apdu->u.close->diagnosticInformation =
 466                 odr_strdup(odr, "unsupported APDU in filter_virt_db");
 467
 468             package.response() = apdu;
 469             package.session().close();
 470         }
 471         if (move_later)
 472             package.move();
 473     }
 474     if (package.session().is_closed())
 475         m_p->release_session(package);
 476 }
 477
 478
 479 /*
 480  * Local variables:
 481  * c-basic-offset: 4
 482  * indent-tabs-mode: nil
 483  * c-file-style: "stroustrup"
 484  * End:
 485  * vim: shiftwidth=4 tabstop=8 expandtab
 486  */