X-Git-Url: http://git.indexdata.com/?a=blobdiff_plain;f=src%2Frouter_flexml.cpp;h=0233cdc5ee1a5446fd278be9d37e947031f495a2;hb=575099e940a170b75b8d2caad5e2cafe39ed89bb;hp=fc3c6f02190686497c92b011b36b82e025966865;hpb=63ea8aedbfd7dc56ab28dbc82c38b4458dcecb68;p=metaproxy-moved-to-github.git diff --git a/src/router_flexml.cpp b/src/router_flexml.cpp index fc3c6f0..0233cdc 100644 --- a/src/router_flexml.cpp +++ b/src/router_flexml.cpp @@ -1,17 +1,31 @@ -/* $Id: router_flexml.cpp,v 1.7 2006-01-04 11:19:04 adam Exp $ - Copyright (c) 2005, Index Data. +/* This file is part of Metaproxy. + Copyright (C) 2005-2009 Index Data -%LICENSE% - */ +Metaproxy is free software; you can redistribute it and/or modify it under +the terms of the GNU General Public License as published by the Free +Software Foundation; either version 2, or (at your option) any later +version. + +Metaproxy is distributed in the hope that it will be useful, but WITHOUT ANY +WARRANTY; without even the implied warranty of MERCHANTABILITY or +FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +for more details. + +You should have received a copy of the GNU General Public License +along with this program; if not, write to the Free Software +Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA +*/ #include "config.hpp" +#include "xmlutil.hpp" #include "router_flexml.hpp" -#include "filter_factory.hpp" +#include "factory_filter.hpp" #include "factory_static.hpp" #include #include #include +#include #include @@ -19,134 +33,72 @@ #include #include +namespace mp = metaproxy_1; -namespace yp2 { +namespace metaproxy_1 { + class RouterFleXML::Route { + friend class RouterFleXML::Rep; + friend class RouterFleXML::Pos; + friend class RouterFleXML; + std::list > m_list; + }; class RouterFleXML::Rep { friend class RouterFleXML; + friend class RouterFleXML::Pos; Rep(); - typedef std::map > - IdFilterMap ; - typedef std::list FilterIdList; - typedef std::map IdRouteMap ; + void base(xmlDocPtr doc, mp::FactoryFilter &factory, bool test_only); + + typedef std::map > + IdFilterMap ; - bool m_xinclude; IdFilterMap m_id_filter_map; - FilterIdList m_filter_id_list; - IdRouteMap m_id_route_map; - - void create_filter(std::string type, - const xmlDoc * xmldoc, - std::string id = ""); - - void parse_xml_config_dom(xmlDocPtr doc); - - bool is_element(const xmlNode *ptr, - const std::string &ns, - const std::string &name); - - bool is_element_yp2(const xmlNode *ptr, - const std::string &name); - - bool check_element_yp2(const xmlNode *ptr, - const std::string &name); - - const xmlNode* jump_to(const xmlNode* node, int xml_node_type); - - const xmlNode* jump_to_next(const xmlNode* node, int xml_node_type); - - const xmlNode* jump_to_children(const xmlNode* node, int xml_node_type); - FilterFactory m_factory; - }; -} -const xmlNode* yp2::RouterFleXML::Rep::jump_to_children(const xmlNode* node, int xml_node_type) -{ - node = node->children; - for (; node && node->type != xml_node_type; node = node->next) - ; - return node; -} - -const xmlNode* yp2::RouterFleXML::Rep::jump_to_next(const xmlNode* node, int xml_node_type) -{ - node = node->next; - for (; node && node->type != xml_node_type; node = node->next) - ; - return node; -} - -const xmlNode* yp2::RouterFleXML::Rep::jump_to(const xmlNode* node, int xml_node_type) -{ - for (; node && node->type != xml_node_type; node = node->next) - ; - return node; -} + std::map m_routes; -bool yp2::RouterFleXML::Rep::is_element(const xmlNode *ptr, - const std::string &ns, - const std::string &name) -{ - if (ptr && ptr->type == XML_ELEMENT_NODE && ptr->ns && ptr->ns->href - && !xmlStrcmp(BAD_CAST ns.c_str(), ptr->ns->href) - && !xmlStrcmp(BAD_CAST name.c_str(), ptr->name)) - return true; - return false; -} + std::string m_start_route; -bool yp2::RouterFleXML::Rep::is_element_yp2(const xmlNode *ptr, - const std::string &name) -{ - return is_element(ptr, "http://indexdata.dk/yp2/config/1", name); -} + std::string m_dl_path; -bool yp2::RouterFleXML::Rep::check_element_yp2(const xmlNode *ptr, - const std::string &name) -{ - if (!is_element_yp2(ptr, name)) - throw XMLError("Error. Expected element name " + name); - return true; -} + void parse_xml_config_dom(xmlDocPtr doc, bool test_only); -void yp2::RouterFleXML::Rep::parse_xml_config_dom(xmlDocPtr doc) -{ - if (!doc) - throw XMLError("Empty XML Document"); - - const xmlNode* root = xmlDocGetRootElement(doc); - - check_element_yp2(root, "yp2"); + void parse_xml_filters(xmlDocPtr doc, const xmlNode *node, + bool test_only); + void parse_xml_routes(xmlDocPtr doc, const xmlNode *node, + bool test_only); - std::cout << "processing /yp2" << std::endl; - - // process node which is expected first element node - const xmlNode* node = jump_to_children(root, XML_ELEMENT_NODE); - //for (; node && node->type != XML_ELEMENT_NODE; node = node->next) - // ; + bool m_xinclude; + private: + FactoryFilter *m_factory; // TODO shared_ptr + }; - check_element_yp2(node, "start"); + class RouterFleXML::Pos : public RoutePos { + public: + virtual const filter::Base *move(const char *route); + virtual RoutePos *clone(); + virtual ~Pos(); + mp::RouterFleXML::Rep *m_p; - std::cout << "processing /yp2/start" << std::endl; - - // process node which is expected second element node - node = jump_to_next(node, XML_ELEMENT_NODE); - check_element_yp2(node, "filters"); - std::cout << "processing /yp2/filters" << std::endl; - - // process nodes in next level - const xmlNode* node2 = jump_to_children(node, XML_ELEMENT_NODE); - + std::map::iterator m_route_it; + std::list >::iterator m_filter_it; + }; +} + +void mp::RouterFleXML::Rep::parse_xml_filters(xmlDocPtr doc, + const xmlNode *node, + bool test_only) +{ unsigned int filter_nr = 0; - while(node2 && check_element_yp2(node2, "filter")) + while(node && mp::xml::check_element_mp(node, "filter")) { filter_nr++; - std::cout << "processing /yp2/filters/filter[" - << filter_nr << "]" << std::endl; const struct _xmlAttr *attr; std::string id_value; std::string type_value; - for (attr = node2->properties; attr; attr = attr->next) + for (attr = node->properties; attr; attr = attr->next) { std::string name = std::string((const char *) attr->name); std::string value; @@ -159,103 +111,285 @@ void yp2::RouterFleXML::Rep::parse_xml_config_dom(xmlDocPtr doc) else if (name == "type") type_value = value; else - throw XMLError("Error. Only attribute id or type allowed in filter element. Got " + name); - - std::cout << "attr " << name << "=" << value << "\n"; + throw mp::XMLError("Only attribute id or type allowed" + " in filter element. Got " + name); + } - //const xmlNode *val; + if (!m_factory->exist(type_value)) + { + yaz_log(YLOG_LOG, "Loading %s (dlpath %s)", + type_value.c_str(), m_dl_path.c_str()); + m_factory->add_creator_dl(type_value, m_dl_path); } + mp::filter::Base* filter_base = m_factory->create(type_value); - yp2::filter::Base* filter_base = m_factory.create(type_value); + filter_base->configure(node, test_only); - node2 = jump_to_next(node2, XML_ELEMENT_NODE); + if (m_id_filter_map.find(id_value) != m_id_filter_map.end()) + throw mp::XMLError("Filter " + id_value + " already defined"); + + m_id_filter_map[id_value] = + boost::shared_ptr(filter_base); + + node = mp::xml::jump_to_next(node, XML_ELEMENT_NODE); } - - // process node which is expected third element node - node = jump_to_next(node, XML_ELEMENT_NODE); - check_element_yp2(node, "routes"); - std::cout << "processing /yp2/routes" << std::endl; - - // process nodes in next level - node2 = jump_to_children(node, XML_ELEMENT_NODE); - check_element_yp2(node2, "route"); - +} + +void mp::RouterFleXML::Rep::parse_xml_routes(xmlDocPtr doc, + const xmlNode *node, + bool test_only) +{ + mp::xml::check_element_mp(node, "route"); + unsigned int route_nr = 0; - while(is_element_yp2(node2, "router")) + while(mp::xml::is_element_mp(node, "route")) { route_nr++; - std::cout << "processing /yp2/routes/route[" - << route_nr << "]" << std::endl; - + + const struct _xmlAttr *attr; + std::string id_value; + for (attr = node->properties; attr; attr = attr->next) + { + std::string name = std::string((const char *) attr->name); + std::string value; + + if (attr->children && attr->children->type == XML_TEXT_NODE) + value = std::string((const char *)attr->children->content); + + if (name == "id") + id_value = value; + else + throw mp::XMLError("Only attribute 'id' allowed for" + " element 'route'." + " Got " + name); + } + + Route route; + // process nodes in third level - const xmlNode* node3 = jump_to_children(node2, XML_ELEMENT_NODE); - + const xmlNode* node3 = mp::xml::jump_to_children(node, XML_ELEMENT_NODE); + unsigned int filter3_nr = 0; - while(node3 && check_element_yp2(node3, "filter")) + while(node3 && mp::xml::check_element_mp(node3, "filter")) { filter3_nr++; - std::cout << "processing /yp2/routes/route[" - << route_nr << "]/filter[" - << filter3_nr << "]" << std::endl; - - node3 = jump_to_next(node3, XML_ELEMENT_NODE); + const struct _xmlAttr *attr; + std::string refid_value; + std::string type_value; + for (attr = node3->properties; attr; attr = attr->next) + { + std::string name = std::string((const char *) attr->name); + std::string value; + + if (attr->children && attr->children->type == XML_TEXT_NODE) + value = std::string((const char *)attr->children->content); + + if (name == "refid") + refid_value = value; + else if (name == "type") + type_value = value; + else + throw mp::XMLError("Only attribute 'refid' or 'type'" + " allowed for element 'filter'." + " Got " + name); + } + if (refid_value.length()) + { + std::map >::iterator it; + it = m_id_filter_map.find(refid_value); + if (it == m_id_filter_map.end()) + throw mp::XMLError("Unknown filter refid " + + refid_value); + else + route.m_list.push_back(it->second); + } + else if (type_value.length()) + { + if (!m_factory->exist(type_value)) + { + yaz_log(YLOG_LOG, "Loading %s (dlpath %s)", + type_value.c_str(), m_dl_path.c_str()); + m_factory->add_creator_dl(type_value, m_dl_path); + } + mp::filter::Base* filter_base = m_factory->create(type_value); + + filter_base->configure(node3, test_only); + + route.m_list.push_back( + boost::shared_ptr(filter_base)); + } + node3 = mp::xml::jump_to_next(node3, XML_ELEMENT_NODE); } - node2 = jump_to_next(node2, XML_ELEMENT_NODE); + std::map::iterator it; + it = m_routes.find(id_value); + if (it != m_routes.end()) + throw mp::XMLError("Route id='" + id_value + + "' already exist"); + else + m_routes[id_value] = route; + node = mp::xml::jump_to_next(node, XML_ELEMENT_NODE); + } +} + +void mp::RouterFleXML::Rep::parse_xml_config_dom(xmlDocPtr doc, + bool test_only) +{ + if (!doc) + throw mp::XMLError("Empty XML Document"); + + const xmlNode* root = xmlDocGetRootElement(doc); + + mp::xml::check_element_mp(root, "metaproxy"); + + const xmlNode* node = mp::xml::jump_to_children(root, XML_ELEMENT_NODE); + + if (mp::xml::is_element_mp(node, "dlpath")) + { + m_dl_path = mp::xml::get_text(node); + node = mp::xml::jump_to_next(node, XML_ELEMENT_NODE); + } + // process node which is expected first element node + if (mp::xml::check_element_mp(node, "start")) + { + const struct _xmlAttr *attr; + std::string id_value; + for (attr = node->properties; attr; attr = attr->next) + { + std::string name = std::string((const char *) attr->name); + std::string value; + + if (attr->children && attr->children->type == XML_TEXT_NODE) + value = std::string((const char *)attr->children->content); + + if (name == "route") + m_start_route = value; + else + throw mp::XMLError("Only attribute start allowed" + " in element 'start'. Got " + name); + } + node = mp::xml::jump_to_next(node, XML_ELEMENT_NODE); + } + // process node if given + if (mp::xml::is_element_mp(node, "filters")) + { + parse_xml_filters(doc, mp::xml::jump_to_children(node, + XML_ELEMENT_NODE), + test_only); + + node = mp::xml::jump_to_next(node, XML_ELEMENT_NODE); + } + // process node which is expected third element node + mp::xml::check_element_mp(node, "routes"); + + parse_xml_routes(doc, mp::xml::jump_to_children(node, XML_ELEMENT_NODE), + test_only); + + node = mp::xml::jump_to_next(node, XML_ELEMENT_NODE); + if (node) + { + throw mp::XMLError("Unexpected element " + + std::string((const char *)node->name)); } } -void yp2::RouterFleXML::Rep::create_filter(std::string type, - const xmlDoc * xmldoc, - std::string id) +mp::RouterFleXML::Rep::Rep() : m_xinclude(false) { - std::cout << "Created Filter type='" << type - << "' id='" << id << "'" << std::endl; } -yp2::RouterFleXML::Rep::Rep() : - m_xinclude(false) +void mp::RouterFleXML::Rep::base(xmlDocPtr doc, mp::FactoryFilter &factory, + bool test_only) { + m_factory = &factory; + parse_xml_config_dom(doc, test_only); + m_start_route = "start"; } -yp2::RouterFleXML::RouterFleXML(std::string xmlconf) +mp::RouterFleXML::RouterFleXML(xmlDocPtr doc, mp::FactoryFilter &factory, + bool test_only) : m_p(new Rep) -{ - { - yp2::FactoryStatic fs(m_p->m_factory); - } +{ + m_p->base(doc, factory, test_only); +} +mp::RouterFleXML::RouterFleXML(std::string xmlconf, mp::FactoryFilter &factory, + bool test_only) + : m_p(new Rep) +{ LIBXML_TEST_VERSION; xmlDocPtr doc = xmlParseMemory(xmlconf.c_str(), xmlconf.size()); if (!doc) - throw XMLError("xmlParseMemory failed"); + throw mp::XMLError("xmlParseMemory failed"); else { - m_p->parse_xml_config_dom(doc); + m_p->base(doc, factory, test_only); xmlFreeDoc(doc); } } -yp2::RouterFleXML::~RouterFleXML() +mp::RouterFleXML::~RouterFleXML() +{ +} + +const mp::filter::Base *mp::RouterFleXML::Pos::move(const char *route) +{ + if (route && *route) + { + //std::cout << "move to " << route << "\n"; + m_route_it = m_p->m_routes.find(route); + if (m_route_it == m_p->m_routes.end()) + { + std::cout << "no such route " << route << "\n"; + throw mp::XMLError("bad route " + std::string(route)); + } + m_filter_it = m_route_it->second.m_list.begin(); + } + if (m_filter_it == m_route_it->second.m_list.end()) + return 0; + const mp::filter::Base *f = (*m_filter_it).get(); + m_filter_it++; + return f; +} + +mp::RoutePos *mp::RouterFleXML::createpos() const { + mp::RouterFleXML::Pos *p = new mp::RouterFleXML::Pos; + + p->m_route_it = m_p->m_routes.find(m_p->m_start_route); + if (p->m_route_it == m_p->m_routes.end()) + { + delete p; + return 0; + } + p->m_filter_it = p->m_route_it->second.m_list.begin(); + p->m_p = m_p.get(); + return p; +} + +mp::RoutePos *mp::RouterFleXML::Pos::clone() +{ + mp::RouterFleXML::Pos *p = new mp::RouterFleXML::Pos; + p->m_filter_it = m_filter_it; + p->m_route_it = m_route_it; + p->m_p = m_p; + return p; } -const yp2::filter::Base * -yp2::RouterFleXML::move(const yp2::filter::Base *filter, - const yp2::Package *package) const +mp::RouterFleXML::Pos::~Pos() { - return 0; } - + /* * Local variables: * c-basic-offset: 4 + * c-file-style: "Stroustrup" * indent-tabs-mode: nil - * c-file-style: "stroustrup" * End: * vim: shiftwidth=4 tabstop=8 expandtab */ +