metaproxy  1.21.0
Public Member Functions | Private Member Functions | Private Attributes | Friends | List of all members
metaproxy_1::filter::Zoom::Impl Class Reference
Collaboration diagram for metaproxy_1::filter::Zoom::Impl:
Collaboration graph

Public Member Functions

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

Private Member Functions

void configure_local_records (const xmlNode *ptr, bool test_only)
 
bool check_proxy (const char *proxy)
 
FrontendPtr get_frontend (mp::Package &package)
 
void release_frontend (mp::Package &package)
 
SearchablePtr parse_torus_record (const xmlNode *ptr)
 
struct cql_node * convert_cql_fields (struct cql_node *cn, ODR odr)
 

Private Attributes

std::map< mp::Session, FrontendPtrm_clients
 
boost::mutex m_mutex
 
boost::condition m_cond_session_ready
 
std::string torus_searchable_url
 
std::string torus_content_url
 
std::string torus_auth_url
 
std::string torus_allow_ip
 
std::string default_realm
 
std::string torus_auth_hostname
 
std::map< std::string, std::string > fieldmap
 
std::string xsldir
 
std::string file_path
 
std::string content_proxy_server
 
std::string content_tmp_file
 
std::string content_config_file
 
bool apdu_log
 
CCL_bibset bibset
 
std::string element_transform
 
std::string element_raw
 
std::string element_marcxml
 
std::string element_passthru
 
std::string proxy
 
xsltStylesheetPtr explain_xsp
 
xsltStylesheetPtr record_xsp
 
std::map< std::string, SearchablePtrs_map
 
std::string zoom_timeout
 
int proxy_timeout
 

Friends

class Frontend
 

Detailed Description

Definition at line 203 of file filter_zoom.cpp.

Constructor & Destructor Documentation

◆ Impl()

mp::filter::Zoom::Impl::Impl ( )

Definition at line 563 of file filter_zoom.cpp.

563  :
564  apdu_log(false), element_transform("pz2") , element_raw("raw") ,
565  element_marcxml("marcxml"), element_passthru("F"),
566  zoom_timeout("40"), proxy_timeout(1)
567 {
568  bibset = ccl_qual_mk();
569 
570  explain_xsp = 0;
571  record_xsp = 0;
572  srand((unsigned int) time(0));
573 }

References bibset, explain_xsp, and record_xsp.

◆ ~Impl()

mp::filter::Zoom::Impl::~Impl ( )

Definition at line 575 of file filter_zoom.cpp.

576 {
577  if (explain_xsp)
578  xsltFreeStylesheet(explain_xsp);
579  ccl_qual_rm(&bibset);
580 }

Member Function Documentation

◆ check_proxy()

bool mp::filter::Zoom::Impl::check_proxy ( const char *  proxy)
private

Definition at line 2188 of file filter_zoom.cpp.

2189 {
2190  COMSTACK conn = 0;
2191  const char *uri = "http://localhost/";
2192  void *add;
2193  mp::odr odr;
2194  bool outcome = false;
2195  conn = cs_create_host_proxy(uri, 0, &add, proxy);
2196 
2197  if (!conn)
2198  return false;
2199 
2200  Z_GDU *gdu = z_get_HTTP_Request_uri(odr, uri, 0, 1);
2201  gdu->u.HTTP_Request->method = odr_strdup(odr, "GET");
2202 
2203  if (z_GDU(odr, &gdu, 0, 0))
2204  {
2205  int len;
2206  char *buf = odr_getbuf(odr, &len, 0);
2207 
2208  int ret = cs_connect(conn, add);
2209  if (ret > 0 || (ret == 0 && wait_conn(conn, 1)))
2210  {
2211  while (1)
2212  {
2213  ret = cs_put(conn, buf, len);
2214  if (ret != 1)
2215  break;
2216  if (!wait_conn(conn, proxy_timeout))
2217  break;
2218  }
2219  if (ret == 0)
2220  outcome = true;
2221  }
2222  }
2223  cs_close(conn);
2224  return outcome;
2225 }
static bool wait_conn(COMSTACK cs, int secs)

References wait_conn().

Here is the call graph for this function:

◆ configure()

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

Definition at line 783 of file filter_zoom.cpp.

785 {
786  std::string explain_xslt_fname;
787  std::string record_xslt_fname;
788 
789  if (path && *path)
790  {
791  file_path = path;
792  }
793  for (ptr = ptr->children; ptr; ptr = ptr->next)
794  {
795  if (ptr->type != XML_ELEMENT_NODE)
796  continue;
797  else if (!strcmp((const char *) ptr->name, "torus"))
798  {
799  const struct _xmlAttr *attr;
800  for (attr = ptr->properties; attr; attr = attr->next)
801  {
802  if (!strcmp((const char *) attr->name, "url"))
803  torus_searchable_url = mp::xml::get_text(attr->children);
804  else if (!strcmp((const char *) attr->name, "content_url"))
805  torus_content_url = mp::xml::get_text(attr->children);
806  else if (!strcmp((const char *) attr->name, "auth_url"))
807  torus_auth_url = mp::xml::get_text(attr->children);
808  else if (!strcmp((const char *) attr->name, "allow_ip"))
809  torus_allow_ip = mp::xml::get_text(attr->children);
810  else if (!strcmp((const char *) attr->name, "realm"))
811  default_realm = mp::xml::get_text(attr->children);
812  else if (!strcmp((const char *) attr->name, "auth_hostname"))
813  torus_auth_hostname = mp::xml::get_text(attr->children);
814  else if (!strcmp((const char *) attr->name, "xsldir"))
815  xsldir = mp::xml::get_text(attr->children);
816  else if (!strcmp((const char *) attr->name, "element_transform"))
817  element_transform = mp::xml::get_text(attr->children);
818  else if (!strcmp((const char *) attr->name, "element_raw"))
819  element_raw = mp::xml::get_text(attr->children);
820  else if (!strcmp((const char *) attr->name, "element_marcxml"))
821  element_marcxml = mp::xml::get_text(attr->children);
822  else if (!strcmp((const char *) attr->name, "element_passthru"))
823  element_passthru = mp::xml::get_text(attr->children);
824  else if (!strcmp((const char *) attr->name, "proxy"))
825  proxy = mp::xml::get_text(attr->children);
826  else if (!strcmp((const char *) attr->name, "explain_xsl"))
827  explain_xslt_fname = mp::xml::get_text(attr->children);
828  else if (!strcmp((const char *) attr->name, "record_xsl"))
829  record_xslt_fname = mp::xml::get_text(attr->children);
830  else
831  throw mp::filter::FilterException(
832  "Bad attribute " + std::string((const char *)
833  attr->name));
834  }
835  // If content_url is not given, use value of searchable, to
836  // ensure backwards compatibility
837  if (!torus_content_url.length())
839  configure_local_records(ptr->children, test_only);
840  }
841  else if (!strcmp((const char *) ptr->name, "cclmap"))
842  {
843  const char *addinfo = 0;
844  ccl_xml_config(bibset, ptr, &addinfo);
845  }
846  else if (!strcmp((const char *) ptr->name, "fieldmap"))
847  {
848  const struct _xmlAttr *attr;
849  std::string ccl_field;
850  std::string cql_field;
851  for (attr = ptr->properties; attr; attr = attr->next)
852  {
853  if (!strcmp((const char *) attr->name, "ccl"))
854  ccl_field = mp::xml::get_text(attr->children);
855  else if (!strcmp((const char *) attr->name, "cql"))
856  cql_field = mp::xml::get_text(attr->children);
857  else
858  throw mp::filter::FilterException(
859  "Bad attribute " + std::string((const char *)
860  attr->name));
861  }
862  if (cql_field.length())
863  fieldmap[cql_field] = ccl_field;
864  }
865  else if (!strcmp((const char *) ptr->name, "contentProxy"))
866  {
867  const struct _xmlAttr *attr;
868  for (attr = ptr->properties; attr; attr = attr->next)
869  {
870  if (!strcmp((const char *) attr->name, "server"))
871  {
872  yaz_log(YLOG_WARN,
873  "contentProxy's server attribute is deprecated");
874  yaz_log(YLOG_LOG,
875  "Specify config_file instead. For example:");
876  yaz_log(YLOG_LOG,
877  " content_file=\"/etc/cf-proxy/cproxy.cfg\"");
878  content_proxy_server = mp::xml::get_text(attr->children);
879  }
880  else if (!strcmp((const char *) attr->name, "tmp_file"))
881  content_tmp_file = mp::xml::get_text(attr->children);
882  else if (!strcmp((const char *) attr->name, "config_file"))
883  content_config_file = mp::xml::get_text(attr->children);
884  else
885  throw mp::filter::FilterException(
886  "Bad attribute " + std::string((const char *)
887  attr->name));
888  }
889  }
890  else if (!strcmp((const char *) ptr->name, "log"))
891  {
892  const struct _xmlAttr *attr;
893  for (attr = ptr->properties; attr; attr = attr->next)
894  {
895  if (!strcmp((const char *) attr->name, "apdu"))
896  apdu_log = mp::xml::get_bool(attr->children, false);
897  else
898  throw mp::filter::FilterException(
899  "Bad attribute " + std::string((const char *)
900  attr->name));
901  }
902  }
903  else if (!strcmp((const char *) ptr->name, "zoom"))
904  {
905  const struct _xmlAttr *attr;
906  for (attr = ptr->properties; attr; attr = attr->next)
907  {
908  if (!strcmp((const char *) attr->name, "timeout"))
909  zoom_timeout = mp::xml::get_text(attr->children);
910  else if (!strcmp((const char *) attr->name, "proxy_timeout"))
911  proxy_timeout = mp::xml::get_int(attr->children, 1);
912  else
913  throw mp::filter::FilterException(
914  "Bad attribute " + std::string((const char *)
915  attr->name));
916  }
917  }
918  else
919  {
920  throw mp::filter::FilterException
921  ("Bad element "
922  + std::string((const char *) ptr->name)
923  + " in zoom filter");
924  }
925  }
926 
927  if (explain_xslt_fname.length())
928  {
929  const char *path = 0;
930 
931  if (xsldir.length())
932  path = xsldir.c_str();
933  else
934  path = file_path.c_str();
935 
936  char fullpath[1024];
937  char *cp = yaz_filepath_resolve(explain_xslt_fname.c_str(),
938  path, 0, fullpath);
939  if (!cp)
940  {
941  throw mp::filter::FilterException
942  ("Cannot read XSLT " + explain_xslt_fname);
943  }
944 
945  xmlDoc *xsp_doc = xmlParseFile(cp);
946  if (!xsp_doc)
947  {
948  throw mp::filter::FilterException
949  ("Cannot parse XSLT " + explain_xslt_fname);
950  }
951 
952  explain_xsp = xsltParseStylesheetDoc(xsp_doc);
953  if (!explain_xsp)
954  {
955  xmlFreeDoc(xsp_doc);
956  throw mp::filter::FilterException
957  ("Cannot parse XSLT " + explain_xslt_fname);
958 
959  }
960  }
961 
962  if (record_xslt_fname.length())
963  {
964  const char *path = 0;
965 
966  if (xsldir.length())
967  path = xsldir.c_str();
968  else
969  path = file_path.c_str();
970 
971  char fullpath[1024];
972  char *cp = yaz_filepath_resolve(record_xslt_fname.c_str(),
973  path, 0, fullpath);
974  if (!cp)
975  {
976  throw mp::filter::FilterException
977  ("Cannot read XSLT " + record_xslt_fname);
978  }
979 
980  xmlDoc *xsp_doc = xmlParseFile(cp);
981  if (!xsp_doc)
982  {
983  throw mp::filter::FilterException
984  ("Cannot parse XSLT " + record_xslt_fname);
985  }
986 
987  record_xsp = xsltParseStylesheetDoc(xsp_doc);
988  if (!record_xsp)
989  {
990  xmlFreeDoc(xsp_doc);
991  throw mp::filter::FilterException
992  ("Cannot parse XSLT " + record_xslt_fname);
993 
994  }
995  }
996 }
std::map< std::string, std::string > fieldmap
void configure_local_records(const xmlNode *ptr, bool test_only)

◆ configure_local_records()

void mp::filter::Zoom::Impl::configure_local_records ( const xmlNode *  ptr,
bool  test_only 
)
private

Definition at line 735 of file filter_zoom.cpp.

736 {
737  while (ptr && ptr->type != XML_ELEMENT_NODE)
738  ptr = ptr->next;
739 
740  if (ptr)
741  {
742  if (!strcmp((const char *) ptr->name, "records"))
743  {
744  for (ptr = ptr->children; ptr; ptr = ptr->next)
745  {
746  if (ptr->type != XML_ELEMENT_NODE)
747  continue;
748  if (!strcmp((const char *) ptr->name, "record"))
749  {
751  if (s)
752  {
753  std::string udb = s->udb;
754  if (udb.length())
755  s_map[s->udb] = s;
756  else
757  {
758  throw mp::filter::FilterException
759  ("No udb for local torus record");
760  }
761  }
762  }
763  else
764  {
765  throw mp::filter::FilterException
766  ("Bad element "
767  + std::string((const char *) ptr->name)
768  + " in zoom filter inside element "
769  "<torus><records>");
770  }
771  }
772  }
773  else
774  {
775  throw mp::filter::FilterException
776  ("Bad element "
777  + std::string((const char *) ptr->name)
778  + " in zoom filter inside element <torus>");
779  }
780  }
781 }
std::map< std::string, SearchablePtr > s_map
SearchablePtr parse_torus_record(const xmlNode *ptr)
boost::shared_ptr< Searchable > SearchablePtr
Definition: filter_zoom.hpp:37

◆ convert_cql_fields()

struct cql_node * mp::filter::Zoom::Impl::convert_cql_fields ( struct cql_node *  cn,
ODR  odr 
)
private

Definition at line 2048 of file filter_zoom.cpp.

2050 {
2051  struct cql_node *r = 0;
2052  if (!cn)
2053  return 0;
2054  switch (cn->which)
2055  {
2056  case CQL_NODE_ST:
2057  if (cn->u.st.index)
2058  {
2059  std::map<std::string,std::string>::const_iterator it;
2060  it = fieldmap.find(cn->u.st.index);
2061  if (it == fieldmap.end())
2062  return cn;
2063  if (it->second.length())
2064  cn->u.st.index = odr_strdup(odr, it->second.c_str());
2065  else
2066  cn->u.st.index = 0;
2067  }
2068  break;
2069  case CQL_NODE_BOOL:
2070  r = convert_cql_fields(cn->u.boolean.left, odr);
2071  if (!r)
2072  r = convert_cql_fields(cn->u.boolean.right, odr);
2073  break;
2074  case CQL_NODE_SORT:
2075  r = convert_cql_fields(cn->u.sort.search, odr);
2076  break;
2077  }
2078  return r;
2079 }
struct cql_node * convert_cql_fields(struct cql_node *cn, ODR odr)

◆ get_frontend()

yf::Zoom::FrontendPtr mp::filter::Zoom::Impl::get_frontend ( mp::Package &  package)
private

Definition at line 518 of file filter_zoom.cpp.

519 {
520  boost::mutex::scoped_lock lock(m_mutex);
521 
522  std::map<mp::Session,yf::Zoom::FrontendPtr>::iterator it;
523 
524  while(true)
525  {
526  it = m_clients.find(package.session());
527  if (it == m_clients.end())
528  break;
529 
530  if (!it->second->m_in_use)
531  {
532  it->second->m_in_use = true;
533  return it->second;
534  }
535  m_cond_session_ready.wait(lock);
536  }
537  FrontendPtr f(new Frontend(this));
538  m_clients[package.session()] = f;
539  f->m_in_use = true;
540  return f;
541 }
boost::condition m_cond_session_ready
std::map< mp::Session, FrontendPtr > m_clients
boost::shared_ptr< Frontend > FrontendPtr
Definition: filter_zoom.hpp:35

◆ parse_torus_record()

yf::Zoom::SearchablePtr mp::filter::Zoom::Impl::parse_torus_record ( const xmlNode *  ptr)
private

Definition at line 582 of file filter_zoom.cpp.

583 {
584  Zoom::SearchablePtr s(new Searchable(bibset));
585 
586  for (ptr = ptr->children; ptr; ptr = ptr->next)
587  {
588  if (ptr->type != XML_ELEMENT_NODE)
589  continue;
590  if (!strcmp((const char *) ptr->name, "layer"))
591  ptr = ptr->children;
592  else if (!strcmp((const char *) ptr->name,
593  "authentication"))
594  {
595  s->authentication = mp::xml::get_text(ptr);
596  }
597  else if (!strcmp((const char *) ptr->name,
598  "authenticationMode"))
599  {
600  s->authenticationMode = mp::xml::get_text(ptr);
601  }
602  else if (!strcmp((const char *) ptr->name,
603  "contentAuthentication"))
604  {
605  s->contentAuthentication = mp::xml::get_text(ptr);
606  }
607  else if (!strcmp((const char *) ptr->name,
608  "cfAuth"))
609  {
610  s->cfAuth = mp::xml::get_text(ptr);
611  }
612  else if (!strcmp((const char *) ptr->name,
613  "cfProxy"))
614  {
615  s->cfProxy = mp::xml::get_text(ptr);
616  }
617  else if (!strcmp((const char *) ptr->name,
618  "cfSubDB"))
619  {
620  s->cfSubDB = mp::xml::get_text(ptr);
621  }
622  else if (!strcmp((const char *) ptr->name,
623  "contentConnector"))
624  {
625  s->contentConnector = mp::xml::get_text(ptr);
626  }
627  else if (!strcmp((const char *) ptr->name, "udb"))
628  {
629  s->udb = mp::xml::get_text(ptr);
630  }
631  else if (!strcmp((const char *) ptr->name, "zurl"))
632  {
633  s->target = mp::xml::get_text(ptr);
634  }
635  else if (!strcmp((const char *) ptr->name, "sru"))
636  {
637  s->sru = mp::xml::get_text(ptr);
638  }
639  else if (!strcmp((const char *) ptr->name, "SRUVersion") ||
640  !strcmp((const char *) ptr->name, "sruVersion"))
641  {
642  s->sru_version = mp::xml::get_text(ptr);
643  }
644  else if (!strcmp((const char *) ptr->name,
645  "queryEncoding"))
646  {
647  s->query_encoding = mp::xml::get_text(ptr);
648  }
649  else if (!strcmp((const char *) ptr->name,
650  "piggyback"))
651  {
652  s->piggyback = mp::xml::get_bool(ptr, true);
653  }
654  else if (!strcmp((const char *) ptr->name,
655  "requestSyntax"))
656  {
657  s->request_syntax = mp::xml::get_text(ptr);
658  }
659  else if (!strcmp((const char *) ptr->name,
660  "elementSet"))
661  {
662  s->element_set = mp::xml::get_text(ptr);
663  }
664  else if (!strcmp((const char *) ptr->name,
665  "recordEncoding"))
666  {
667  s->record_encoding = mp::xml::get_text(ptr);
668  }
669  else if (!strcmp((const char *) ptr->name,
670  "transform"))
671  {
672  s->transform_xsl_fname = mp::xml::get_text(ptr);
673  }
674  else if (!strcmp((const char *) ptr->name,
675  "literalTransform"))
676  {
677  s->transform_xsl_content = mp::xml::get_text(ptr);
678  }
679  else if (!strcmp((const char *) ptr->name,
680  "urlRecipe"))
681  {
682  s->urlRecipe = mp::xml::get_text(ptr);
683  }
684  else if (!strcmp((const char *) ptr->name,
685  "useTurboMarc"))
686  {
687  ; // useTurboMarc is ignored
688  }
689  else if (!strncmp((const char *) ptr->name,
690  "cclmap_", 7))
691  {
692  std::string value = mp::xml::get_text(ptr);
693  if (value.length() > 0)
694  {
695  ccl_qual_fitem(s->ccl_bibset, value.c_str(),
696  (const char *) ptr->name + 7);
697  }
698  }
699  else if (!strncmp((const char *) ptr->name,
700  "sortmap_", 8))
701  {
702  std::string value = mp::xml::get_text(ptr);
703  s->sortmap[(const char *) ptr->name + 8] = value;
704  }
705  else if (!strcmp((const char *) ptr->name,
706  "sortStrategy"))
707  {
708  s->sortStrategy = mp::xml::get_text(ptr);
709  }
710  else if (!strcmp((const char *) ptr->name,
711  "extraArgs"))
712  {
713  s->extraArgs = mp::xml::get_text(ptr);
714  }
715  else if (!strcmp((const char *) ptr->name, "rpn2cql"))
716  s->rpn2cql_fname = mp::xml::get_text(ptr);
717  else if (!strcmp((const char *) ptr->name,
718  "retryOnFailure"))
719  {
720  s->retry_on_failure = mp::xml::get_text(ptr);
721  }
722  else if (!strcmp((const char *) ptr->name, "noCproxy"))
723  {
724  s->no_cproxy = mp::xml::get_text(ptr);
725  }
726  else if (strlen((const char *) ptr->name) > 3 &&
727  !memcmp((const char *) ptr->name, "cf_", 3))
728  {
729  s->cf_param[(const char *) ptr->name + 3] = mp::xml::get_text(ptr);
730  }
731  }
732  return s;
733 }

◆ process()

void mp::filter::Zoom::Impl::process ( metaproxy_1::Package &  package)

Definition at line 2822 of file filter_zoom.cpp.

2823 {
2824  FrontendPtr f = get_frontend(package);
2825  Z_GDU *gdu = package.request().get();
2826 
2827  if (f->m_is_virtual)
2828  {
2829  f->handle_package(package);
2830  }
2831  else if (gdu && gdu->which == Z_GDU_Z3950 && gdu->u.z3950->which ==
2832  Z_APDU_initRequest)
2833  {
2834  Z_InitRequest *req = gdu->u.z3950->u.initRequest;
2835  f->m_init_gdu = gdu;
2836 
2837  mp::odr odr;
2838  Z_APDU *apdu = odr.create_initResponse(gdu->u.z3950, 0, 0);
2839  Z_InitResponse *resp = apdu->u.initResponse;
2840 
2841  int i;
2842  static const int masks[] = {
2843  Z_Options_search,
2844  Z_Options_present,
2845  -1
2846  };
2847  for (i = 0; masks[i] != -1; i++)
2848  if (ODR_MASK_GET(req->options, masks[i]))
2849  ODR_MASK_SET(resp->options, masks[i]);
2850 
2851  static const int versions[] = {
2852  Z_ProtocolVersion_1,
2853  Z_ProtocolVersion_2,
2854  Z_ProtocolVersion_3,
2855  -1
2856  };
2857  for (i = 0; versions[i] != -1; i++)
2858  if (ODR_MASK_GET(req->protocolVersion, versions[i]))
2859  ODR_MASK_SET(resp->protocolVersion, versions[i]);
2860  else
2861  break;
2862 
2863  *resp->preferredMessageSize = *req->preferredMessageSize;
2864  *resp->maximumRecordSize = *req->maximumRecordSize;
2865 
2866  int error = 0;
2867  char *addinfo = 0;
2868  f->auth(package, req, &error, &addinfo, odr);
2869  if (error)
2870  {
2871  resp->userInformationField =
2872  zget_init_diagnostics(odr, error, addinfo);
2873  *resp->result = 0;
2874  package.session().close();
2875  }
2876  else
2877  f->m_is_virtual = true;
2878  package.response() = apdu;
2879  }
2880  else
2881  package.move();
2882 
2883  release_frontend(package);
2884 }
void release_frontend(mp::Package &package)
FrontendPtr get_frontend(mp::Package &package)

◆ release_frontend()

void mp::filter::Zoom::Impl::release_frontend ( mp::Package &  package)
private

Definition at line 543 of file filter_zoom.cpp.

544 {
545  boost::mutex::scoped_lock lock(m_mutex);
546  std::map<mp::Session,yf::Zoom::FrontendPtr>::iterator it;
547 
548  it = m_clients.find(package.session());
549  if (it != m_clients.end())
550  {
551  if (package.session().is_closed())
552  {
553  m_clients.erase(it);
554  }
555  else
556  {
557  it->second->m_in_use = false;
558  }
559  m_cond_session_ready.notify_all();
560  }
561 }

Friends And Related Function Documentation

◆ Frontend

friend class Frontend
friend

Definition at line 204 of file filter_zoom.cpp.

Member Data Documentation

◆ apdu_log

bool metaproxy_1::filter::Zoom::Impl::apdu_log
private

Definition at line 236 of file filter_zoom.cpp.

◆ bibset

CCL_bibset metaproxy_1::filter::Zoom::Impl::bibset
private

Definition at line 237 of file filter_zoom.cpp.

Referenced by Impl().

◆ content_config_file

std::string metaproxy_1::filter::Zoom::Impl::content_config_file
private

Definition at line 235 of file filter_zoom.cpp.

◆ content_proxy_server

std::string metaproxy_1::filter::Zoom::Impl::content_proxy_server
private

Definition at line 233 of file filter_zoom.cpp.

◆ content_tmp_file

std::string metaproxy_1::filter::Zoom::Impl::content_tmp_file
private

Definition at line 234 of file filter_zoom.cpp.

◆ default_realm

std::string metaproxy_1::filter::Zoom::Impl::default_realm
private

Definition at line 228 of file filter_zoom.cpp.

◆ element_marcxml

std::string metaproxy_1::filter::Zoom::Impl::element_marcxml
private

Definition at line 240 of file filter_zoom.cpp.

◆ element_passthru

std::string metaproxy_1::filter::Zoom::Impl::element_passthru
private

Definition at line 241 of file filter_zoom.cpp.

◆ element_raw

std::string metaproxy_1::filter::Zoom::Impl::element_raw
private

Definition at line 239 of file filter_zoom.cpp.

◆ element_transform

std::string metaproxy_1::filter::Zoom::Impl::element_transform
private

Definition at line 238 of file filter_zoom.cpp.

◆ explain_xsp

xsltStylesheetPtr metaproxy_1::filter::Zoom::Impl::explain_xsp
private

Definition at line 243 of file filter_zoom.cpp.

Referenced by Impl().

◆ fieldmap

std::map<std::string,std::string> metaproxy_1::filter::Zoom::Impl::fieldmap
private

Definition at line 230 of file filter_zoom.cpp.

◆ file_path

std::string metaproxy_1::filter::Zoom::Impl::file_path
private

Definition at line 232 of file filter_zoom.cpp.

◆ m_clients

std::map<mp::Session, FrontendPtr> metaproxy_1::filter::Zoom::Impl::m_clients
private

Definition at line 221 of file filter_zoom.cpp.

◆ m_cond_session_ready

boost::condition metaproxy_1::filter::Zoom::Impl::m_cond_session_ready
private

Definition at line 223 of file filter_zoom.cpp.

◆ m_mutex

boost::mutex metaproxy_1::filter::Zoom::Impl::m_mutex
private

Definition at line 222 of file filter_zoom.cpp.

◆ proxy

std::string metaproxy_1::filter::Zoom::Impl::proxy
private

Definition at line 242 of file filter_zoom.cpp.

◆ proxy_timeout

int metaproxy_1::filter::Zoom::Impl::proxy_timeout
private

Definition at line 247 of file filter_zoom.cpp.

◆ record_xsp

xsltStylesheetPtr metaproxy_1::filter::Zoom::Impl::record_xsp
private

Definition at line 244 of file filter_zoom.cpp.

Referenced by Impl().

◆ s_map

std::map<std::string,SearchablePtr> metaproxy_1::filter::Zoom::Impl::s_map
private

Definition at line 245 of file filter_zoom.cpp.

◆ torus_allow_ip

std::string metaproxy_1::filter::Zoom::Impl::torus_allow_ip
private

Definition at line 227 of file filter_zoom.cpp.

◆ torus_auth_hostname

std::string metaproxy_1::filter::Zoom::Impl::torus_auth_hostname
private

Definition at line 229 of file filter_zoom.cpp.

◆ torus_auth_url

std::string metaproxy_1::filter::Zoom::Impl::torus_auth_url
private

Definition at line 226 of file filter_zoom.cpp.

◆ torus_content_url

std::string metaproxy_1::filter::Zoom::Impl::torus_content_url
private

Definition at line 225 of file filter_zoom.cpp.

◆ torus_searchable_url

std::string metaproxy_1::filter::Zoom::Impl::torus_searchable_url
private

Definition at line 224 of file filter_zoom.cpp.

◆ xsldir

std::string metaproxy_1::filter::Zoom::Impl::xsldir
private

Definition at line 231 of file filter_zoom.cpp.

◆ zoom_timeout

std::string metaproxy_1::filter::Zoom::Impl::zoom_timeout
private

Definition at line 246 of file filter_zoom.cpp.


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