src/filter_zoom.cpp

   1 /* This file is part of Metaproxy.
   2    Copyright (C) 2005-2011 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 #include "filter_zoom.hpp"
  21 #include <yaz/zoom.h>
  22 #include <metaproxy/package.hpp>
  23 #include <metaproxy/util.hpp>
  24
  25 #include <boost/thread/mutex.hpp>
  26 #include <boost/thread/condition.hpp>
  27 #include <yaz/diagbib1.h>
  28 #include <yaz/log.h>
  29 #include <yaz/zgdu.h>
  30
  31 namespace mp = metaproxy_1;
  32 namespace yf = mp::filter;
  33
  34 namespace metaproxy_1 {
  35     namespace filter {
  36         class Zoom::Backend {
  37             friend class Impl;
  38             friend class Frontend;
  39             std::string zurl;
  40             ZOOM_connection m_connection;
  41             ZOOM_resultset m_resultset;
  42             std::string m_frontend_database;
  43         public:
  44             Backend();
  45             ~Backend();
  46             void connect(std::string zurl);
  47         };
  48         class Zoom::Frontend {
  49             friend class Impl;
  50             Impl *m_p;
  51             bool m_is_virtual;
  52             bool m_in_use;
  53             yazpp_1::GDU m_init_gdu;
  54             std::list<BackendPtr> m_backend_list;
  55             void handle_package(mp::Package &package);
  56             void handle_search(mp::Package &package);
  57             void handle_present(mp::Package &package);
  58             BackendPtr get_backend_from_databases(std::string database);
  59         public:
  60             Frontend(Impl *impl);
  61             ~Frontend();
  62         };
  63         class Zoom::Impl {
  64         public:
  65             Impl();
  66             ~Impl();
  67             void process(metaproxy_1::Package & package);
  68             void configure(const xmlNode * ptr);
  69         private:
  70             FrontendPtr get_frontend(mp::Package &package);
  71             void release_frontend(mp::Package &package);
  72
  73             std::map<mp::Session, FrontendPtr> m_clients;
  74             boost::mutex m_mutex;
  75             boost::condition m_cond_session_ready;
  76         };
  77     }
  78 }
  79
  80 // define Pimpl wrapper forwarding to Impl
  81
  82 yf::Zoom::Zoom() : m_p(new Impl)
  83 {
  84 }
  85
  86 yf::Zoom::~Zoom()
  87 {  // must have a destructor because of boost::scoped_ptr
  88 }
  89
  90 void yf::Zoom::configure(const xmlNode *xmlnode, bool test_only)
  91 {
  92     m_p->configure(xmlnode);
  93 }
  94
  95 void yf::Zoom::process(mp::Package &package) const
  96 {
  97     m_p->process(package);
  98 }
  99
 100
 101 // define Implementation stuff
 102
 103 yf::Zoom::Backend::Backend()
 104 {
 105     m_connection = ZOOM_connection_create(0);
 106     m_resultset = 0;
 107 }
 108
 109 yf::Zoom::Backend::~Backend()
 110 {
 111     ZOOM_connection_destroy(m_connection);
 112     ZOOM_resultset_destroy(m_resultset);
 113 }
 114
 115 void yf::Zoom::Backend::connect(std::string zurl)
 116 {
 117     ZOOM_connection_connect(m_connection, zurl.c_str(), 0);
 118 }
 119
 120 yf::Zoom::Frontend::Frontend(Impl *impl) :
 121     m_p(impl), m_is_virtual(false), m_in_use(true)
 122 {
 123 }
 124
 125 yf::Zoom::Frontend::~Frontend()
 126 {
 127 }
 128
 129 yf::Zoom::FrontendPtr yf::Zoom::Impl::get_frontend(mp::Package &package)
 130 {
 131     boost::mutex::scoped_lock lock(m_mutex);
 132
 133     std::map<mp::Session,yf::Zoom::FrontendPtr>::iterator it;
 134
 135     while(true)
 136     {
 137         it = m_clients.find(package.session());
 138         if (it == m_clients.end())
 139             break;
 140
 141         if (!it->second->m_in_use)
 142         {
 143             it->second->m_in_use = true;
 144             return it->second;
 145         }
 146         m_cond_session_ready.wait(lock);
 147     }
 148     FrontendPtr f(new Frontend(this));
 149     m_clients[package.session()] = f;
 150     f->m_in_use = true;
 151     return f;
 152 }
 153
 154 void yf::Zoom::Impl::release_frontend(mp::Package &package)
 155 {
 156     boost::mutex::scoped_lock lock(m_mutex);
 157     std::map<mp::Session,yf::Zoom::FrontendPtr>::iterator it;
 158
 159     it = m_clients.find(package.session());
 160     if (it != m_clients.end())
 161     {
 162         if (package.session().is_closed())
 163         {
 164             m_clients.erase(it);
 165         }
 166         else
 167         {
 168             it->second->m_in_use = false;
 169         }
 170         m_cond_session_ready.notify_all();
 171     }
 172 }
 173
 174 yf::Zoom::Impl::Impl()
 175 {
 176 }
 177
 178 yf::Zoom::Impl::~Impl()
 179 {
 180 }
 181
 182 void yf::Zoom::Impl::configure(const xmlNode *xmlnode)
 183 {
 184 }
 185
 186 yf::Zoom::BackendPtr yf::Zoom::Frontend::get_backend_from_databases(
 187     std::string database)
 188 {
 189     std::list<BackendPtr>::const_iterator map_it;
 190     map_it = m_backend_list.begin();
 191     for (; map_it != m_backend_list.end(); map_it++)
 192         if ((*map_it)->m_frontend_database == database)
 193             return *map_it;
 194
 195     BackendPtr b(new Backend);
 196
 197     std::string url = "localhost:9999/" + database;
 198     yaz_log(YLOG_LOG, "new backend url=%s", url.c_str());
 199     b->connect(url);
 200     return b;
 201 }
 202
 203 void yf::Zoom::Frontend::handle_search(mp::Package &package)
 204 {
 205     Z_GDU *gdu = package.request().get();
 206     Z_APDU *apdu_req = gdu->u.z3950;
 207     Z_APDU *apdu_res = 0;
 208     mp::odr odr;
 209     Z_SearchRequest *sr = apdu_req->u.searchRequest;
 210     if (sr->num_databaseNames != 1)
 211     {
 212         apdu_res = odr.create_searchResponse(
 213             apdu_req, YAZ_BIB1_TOO_MANY_DATABASES_SPECIFIED, 0);
 214         package.response() = apdu_res;
 215         return;
 216     }
 217     BackendPtr b = get_backend_from_databases(sr->databaseNames[0]);
 218     switch (sr->query->which)
 219     {
 220     case Z_Query_type_1:
 221     case Z_Query_type_101:
 222         apdu_res =
 223             odr.create_searchResponse(
 224                 apdu_req,
 225                 YAZ_BIB1_TEMPORARY_SYSTEM_ERROR,
 226                 "search filter do not handle type-1/type-101 yet");
 227         package.response() = apdu_res;
 228         break;
 229     default:
 230         apdu_res =
 231             odr.create_searchResponse(
 232                 apdu_req,
 233                 YAZ_BIB1_QUERY_TYPE_UNSUPP, 0);
 234         package.response() = apdu_res;
 235         return;
 236     }
 237 }
 238
 239 void yf::Zoom::Frontend::handle_present(mp::Package &package)
 240 {
 241     Z_GDU *gdu = package.request().get();
 242     Z_APDU *apdu_req = gdu->u.z3950;
 243     mp::odr odr;
 244     package.response() = odr.create_close(
 245         apdu_req,
 246         Z_Close_protocolError,
 247         "zoom filter has not implemented present request yet");
 248     package.session().close();
 249 }
 250
 251 void yf::Zoom::Frontend::handle_package(mp::Package &package)
 252 {
 253     Z_GDU *gdu = package.request().get();
 254     if (!gdu)
 255         ;
 256     else if (gdu->which == Z_GDU_Z3950)
 257     {
 258         Z_APDU *apdu_req = gdu->u.z3950;
 259         if (apdu_req->which == Z_APDU_initRequest)
 260         {
 261             mp::odr odr;
 262             package.response() = odr.create_close(
 263                 apdu_req,
 264                 Z_Close_protocolError,
 265                 "double init");
 266         }
 267         else if (apdu_req->which == Z_APDU_searchRequest)
 268         {
 269             handle_search(package);
 270         }
 271         else if (apdu_req->which == Z_APDU_presentRequest)
 272         {
 273             handle_present(package);
 274         }
 275         else
 276         {
 277             mp::odr odr;
 278             package.response() = odr.create_close(
 279                 apdu_req,
 280                 Z_Close_protocolError,
 281                 "zoom filter cannot handle this APDU");
 282             package.session().close();
 283         }
 284     }
 285     else
 286     {
 287         package.session().close();
 288     }
 289 }
 290
 291 void yf::Zoom::Impl::process(mp::Package &package)
 292 {
 293     FrontendPtr f = get_frontend(package);
 294     Z_GDU *gdu = package.request().get();
 295
 296     if (f->m_is_virtual)
 297     {
 298         f->handle_package(package);
 299     }
 300     else if (gdu && gdu->which == Z_GDU_Z3950 && gdu->u.z3950->which ==
 301              Z_APDU_initRequest)
 302     {
 303         Z_InitRequest *req = gdu->u.z3950->u.initRequest;
 304         f->m_init_gdu = gdu;
 305
 306         mp::odr odr;
 307         Z_APDU *apdu = odr.create_initResponse(gdu->u.z3950, 0, 0);
 308         Z_InitResponse *resp = apdu->u.initResponse;
 309
 310         int i;
 311         static const int masks[] = {
 312             Z_Options_search,
 313             Z_Options_present,
 314             -1
 315         };
 316         for (i = 0; masks[i] != -1; i++)
 317             if (ODR_MASK_GET(req->options, masks[i]))
 318                 ODR_MASK_SET(resp->options, masks[i]);
 319
 320         static const int versions[] = {
 321             Z_ProtocolVersion_1,
 322             Z_ProtocolVersion_2,
 323             Z_ProtocolVersion_3,
 324             -1
 325         };
 326         for (i = 0; versions[i] != -1; i++)
 327             if (ODR_MASK_GET(req->protocolVersion, versions[i]))
 328                 ODR_MASK_SET(resp->protocolVersion, versions[i]);
 329             else
 330                 break;
 331
 332         *resp->preferredMessageSize = *req->preferredMessageSize;
 333         *resp->maximumRecordSize = *req->maximumRecordSize;
 334
 335         package.response() = apdu;
 336         f->m_is_virtual = true;
 337     }
 338     else
 339         package.move();
 340
 341     release_frontend(package);
 342 }
 343
 344
 345 static mp::filter::Base* filter_creator()
 346 {
 347     return new mp::filter::Zoom;
 348 }
 349
 350 extern "C" {
 351     struct metaproxy_1_filter_struct metaproxy_1_filter_zoom = {
 352         0,
 353         "zoom",
 354         filter_creator
 355     };
 356 }
 357
 358
 359 /*
 360  * Local variables:
 361  * c-basic-offset: 4
 362  * c-file-style: "Stroustrup"
 363  * indent-tabs-mode: nil
 364  * End:
 365  * vim: shiftwidth=4 tabstop=8 expandtab
 366  */
 367