src/test/feature/lib/xml_parser.cpp - hawq - Git at Google

 /*
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements.  See the NOTICE file
  * distributed with this work for additional information
  * regarding copyright ownership.  The ASF licenses this file
  * to you under the Apache License, Version 2.0 (the
  * "License"); you may not use this file except in compliance
  * with the License.  You may obtain a copy of the License at
  *
  *   http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 #include <unistd.h>
 #include <cstring>
 #include <string>
 #include <limits>
 #include "xml_parser.h"

 using std::string;

 namespace hawq {
 namespace test {

 XmlConfig::XmlConfig(string p) :
     path(p) {
   parse();
 }

 bool XmlConfig::open() {
   if (access(path.c_str(), R_OK)) {
     return false;
   }

   doc = xmlReadFile(path.c_str(), nullptr, 0);
   if (doc == nullptr) {
     return false;
   }

   return true;
 }

 void XmlConfig::closeNotSave() {
     xmlFreeDoc(doc);
 }

 void XmlConfig::closeAndSave() {
     xmlSaveFormatFile(path.c_str(), doc, 0);
     xmlFreeDoc(doc);
 }

 bool XmlConfig::parse() {
   LIBXML_TEST_VERSION kv
   .clear();

   if (!open()) {
     return false;
   }
   try {
     readConfigItems(doc);
     closeNotSave();
     return true;
   } catch (...) {
     closeNotSave();
     return false;
   }
 }

 void XmlConfig::readConfigItems(xmlDocPtr doc) {
   xmlNodePtr root, curNode;
   root = xmlDocGetRootElement(doc);
   if (root == nullptr || strcmp((const char *) root->name, "configuration")) {
     return ;
   }
   // for each property
   for (curNode = root->children; curNode != nullptr; curNode = curNode->next) {
     if (curNode->type != XML_ELEMENT_NODE) {
       continue;
     }
     if (strcmp((const char *) curNode->name, "property")) {
       return;
     }
     readConfigItem(curNode->children);
   }
 }

 void XmlConfig::readConfigItem(xmlNodePtr root) {
   string key, value, scope;
   xmlNodePtr curNode;
   bool hasName = false, hasValue = false, hasScope = false;
   for (curNode = root; curNode != nullptr; curNode = curNode->next) {
     if (curNode->type != XML_ELEMENT_NODE) {
       continue;
     }
     if (!hasName && !strcmp((const char *) curNode->name, "name")) {
       if (curNode->children != nullptr
           && XML_TEXT_NODE == curNode->children->type) {
         key = (const char *) curNode->children->content;
         hasName = true;
       }
     } else if (!hasValue && !strcmp((const char *) curNode->name, "value")) {
       if (curNode->children != nullptr
           && XML_TEXT_NODE == curNode->children->type) {
         value = (const char *) curNode->children->content;
         hasValue = true;
       }
     } else {
       continue;
     }
   }
   if (hasName && hasValue) {
     kv[key] = value;
     return;
   } else if (hasName && hasValue) {
     return;
   } else if (hasName && hasScope) {
     return;
   } else if (hasName) {
     return;
   }
 }

 bool XmlConfig::setString(const string &key,
                           const string &value,
                           bool save) {
   bool result = false;

   if (save) {
     if (!open()) {
       return false;
     }
   }
   try {
     result = writeConfigItem(doc, key, value);
     if (save) {
       closeAndSave();
     }
   } catch (...) {
     if (save) {
       closeNotSave();
     }
   }
   return result;
 }

 bool XmlConfig::setString(const string &key,
                           const string &value) {
   return setString(key, value, true);
 }

 bool XmlConfig::writeConfigItem(xmlDocPtr doc,
                                 const string &key,
                                 const string &value) {
   xmlNodePtr root, curNode, curNodeChild, findNode;
   root = xmlDocGetRootElement(doc);
   bool findkey = false;
   if (root == nullptr || strcmp((const char *) root->name, "configuration")) {
     return false;
   }
   // for each property
   for (curNode = root->children; curNode != nullptr; curNode = curNode->next) {
     if (curNode->type != XML_ELEMENT_NODE) {
       continue;
     }
     if (strcmp((const char *) curNode->name, "property")) {
       return false;
     }
     curNodeChild = curNode->children;
     for (curNodeChild = curNode->children; curNodeChild != nullptr; curNodeChild = curNodeChild->next) {
       if (curNodeChild->type != XML_ELEMENT_NODE) {
         continue;
       }
       if (!strcmp((const char *) curNodeChild->name, "name")) {
         if (curNodeChild->children != nullptr
             && XML_TEXT_NODE == curNodeChild->children->type
             && !strcmp((const char *) curNodeChild->children->content, key.c_str())) {
           findNode = curNode;
           findkey = true;
         } else {
           if (findkey) {
             xmlNewTextChild(findNode, NULL, BAD_CAST "value", BAD_CAST value.c_str());
             return true;
           }
         }
       } else if (!strcmp((const char *) curNodeChild->name, "value")) {
         if (findkey
             && curNodeChild->children != nullptr
             && XML_TEXT_NODE == curNodeChild->children->type) {
           xmlNodeSetContent(curNodeChild->children, (xmlChar*) const_cast<char*>(value.c_str()));
           return true;
         }
       } else {
         continue;
       }
     }
   }

   xmlNodePtr newNode = xmlNewNode(NULL, BAD_CAST "property");
   xmlAddChild(root, newNode);
   xmlNewTextChild(newNode, NULL, BAD_CAST "name", BAD_CAST key.c_str());
   xmlNewTextChild(newNode, NULL, BAD_CAST "value", BAD_CAST value.c_str());
   return true;
 }

 const string XmlConfig::getString(const char *key) {
   XmlConfigMapIterator it = kv.find(key);
   if (kv.end() == it) {
     return "";
   }
   return it->second;
 }

 const string XmlConfig::getString(const char *key, const char *def) {
   XmlConfigMapIterator it = kv.find(key);
   if (kv.end() == it) {
     return string(def);
   } else {
     return it->second;
   }
 }

 const string XmlConfig::getString(const string & key) {
   return getString(key.c_str());
 }

 const string XmlConfig::getString(const string & key,
                                   const string & def) {
   return getString(key.c_str(), def.c_str());
 }

 int64_t XmlConfig::getInt64(const char *key) {
   int64_t retval;
   XmlConfigMapIterator it = kv.find(key);
   if (kv.end() == it) {
     return 0;
   }
   retval = strToInt64(it->second.c_str());
   return retval;
 }

 int64_t XmlConfig::getInt64(const char *key, int64_t def) {
   int64_t retval;
   XmlConfigMapIterator it = kv.find(key);
   if (kv.end() == it) {
     return def;
   }
   retval = strToInt64(it->second.c_str());
   return retval;
 }

 int32_t XmlConfig::getInt32(const char *key) {
   int32_t retval;
   XmlConfigMapIterator it = kv.find(key);
   if (kv.end() == it) {
     return 0;
   }
   retval = strToInt32(it->second.c_str());
   return retval;
 }

 int32_t XmlConfig::getInt32(const char *key, int32_t def) {
   int32_t retval;
   XmlConfigMapIterator it = kv.find(key);
   if (kv.end() == it) {
     return def;
   }
   retval = strToInt32(it->second.c_str());
   return retval;
 }

 double XmlConfig::getDouble(const char *key) {
   double retval;
   XmlConfigMapIterator it = kv.find(key);
   if (kv.end() == it) {
     return 0.0;
   }
   retval = strToDouble(it->second.c_str());
   return retval;
 }

 double XmlConfig::getDouble(const char *key, double def) {
   double retval;
   XmlConfigMapIterator it = kv.find(key);
   if (kv.end() == it) {
     return def;
   }
   retval = strToDouble(it->second.c_str());
   return retval;
 }

 bool XmlConfig::getBool(const char *key) {
   bool retval;
   XmlConfigMapIterator it = kv.find(key);
   if (kv.end() == it) {
       return false;
   }
   retval = strToBool(it->second.c_str());
   return retval;
 }

 bool XmlConfig::getBool(const char *key, bool def) {
   bool retval;
   XmlConfigMapIterator it = kv.find(key);
   if (kv.end() == it) {
     return def;
   }
   retval = strToBool(it->second.c_str());
   return retval;
 }

 int64_t XmlConfig::strToInt64(const char *str) {
   int64_t retval;
   char *end = nullptr;
   retval = strtoll(str, &end, 0);
   return retval;
 }

 int32_t XmlConfig::strToInt32(const char *str) {
   int32_t retval;
   char *end = nullptr;
   retval = strtoll(str, &end, 0);
   return retval;
 }

 bool XmlConfig::strToBool(const char *str) {
   bool retval = false;
   if (!strcasecmp(str, "true") || !strcmp(str, "1")) {
     retval = true;
   } else if (!strcasecmp(str, "false") || !strcmp(str, "0")) {
     retval = false;
   } else {
     return false;
   }
   return retval;
 }

 double XmlConfig::strToDouble(const char *str) {
   double retval;
   char *end = nullptr;
   retval = strtod(str, &end);
   return retval;
 }

 } // namespace test
 } // namespace hawq
	/*
	* Licensed to the Apache Software Foundation (ASF) under one
	* or more contributor license agreements. See the NOTICE file
	* distributed with this work for additional information
	* regarding copyright ownership. The ASF licenses this file
	* to you under the Apache License, Version 2.0 (the
	* "License"); you may not use this file except in compliance
	* with the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	#include <unistd.h>
	#include <cstring>
	#include <string>
	#include <limits>
	#include "xml_parser.h"

	using std::string;

	namespace hawq {
	namespace test {

	XmlConfig::XmlConfig(string p) :
	path(p) {
	parse();
	}

	bool XmlConfig::open() {
	if (access(path.c_str(), R_OK)) {
	return false;
	}

	doc = xmlReadFile(path.c_str(), nullptr, 0);
	if (doc == nullptr) {
	return false;
	}

	return true;
	}

	void XmlConfig::closeNotSave() {
	xmlFreeDoc(doc);
	}

	void XmlConfig::closeAndSave() {
	xmlSaveFormatFile(path.c_str(), doc, 0);
	xmlFreeDoc(doc);
	}

	bool XmlConfig::parse() {
	LIBXML_TEST_VERSION kv
	.clear();

	if (!open()) {
	return false;
	}
	try {
	readConfigItems(doc);
	closeNotSave();
	return true;
	} catch (...) {
	closeNotSave();
	return false;
	}
	}

	void XmlConfig::readConfigItems(xmlDocPtr doc) {
	xmlNodePtr root, curNode;
	root = xmlDocGetRootElement(doc);
	if (root == nullptr \|\| strcmp((const char *) root->name, "configuration")) {
	return ;
	}
	// for each property
	for (curNode = root->children; curNode != nullptr; curNode = curNode->next) {
	if (curNode->type != XML_ELEMENT_NODE) {
	continue;
	}
	if (strcmp((const char *) curNode->name, "property")) {
	return;
	}
	readConfigItem(curNode->children);
	}
	}

	void XmlConfig::readConfigItem(xmlNodePtr root) {
	string key, value, scope;
	xmlNodePtr curNode;
	bool hasName = false, hasValue = false, hasScope = false;
	for (curNode = root; curNode != nullptr; curNode = curNode->next) {
	if (curNode->type != XML_ELEMENT_NODE) {
	continue;
	}
	if (!hasName && !strcmp((const char *) curNode->name, "name")) {
	if (curNode->children != nullptr
	&& XML_TEXT_NODE == curNode->children->type) {
	key = (const char *) curNode->children->content;
	hasName = true;
	}
	} else if (!hasValue && !strcmp((const char *) curNode->name, "value")) {
	if (curNode->children != nullptr
	&& XML_TEXT_NODE == curNode->children->type) {
	value = (const char *) curNode->children->content;
	hasValue = true;
	}
	} else {
	continue;
	}
	}
	if (hasName && hasValue) {
	kv[key] = value;
	return;
	} else if (hasName && hasValue) {
	return;
	} else if (hasName && hasScope) {
	return;
	} else if (hasName) {
	return;
	}
	}

	bool XmlConfig::setString(const string &key,
	const string &value,
	bool save) {
	bool result = false;

	if (save) {
	if (!open()) {
	return false;
	}
	}
	try {
	result = writeConfigItem(doc, key, value);
	if (save) {
	closeAndSave();
	}
	} catch (...) {
	if (save) {
	closeNotSave();
	}
	}
	return result;
	}

	bool XmlConfig::setString(const string &key,
	const string &value) {
	return setString(key, value, true);
	}

	bool XmlConfig::writeConfigItem(xmlDocPtr doc,
	const string &key,
	const string &value) {
	xmlNodePtr root, curNode, curNodeChild, findNode;
	root = xmlDocGetRootElement(doc);
	bool findkey = false;
	if (root == nullptr \|\| strcmp((const char *) root->name, "configuration")) {
	return false;
	}
	// for each property
	for (curNode = root->children; curNode != nullptr; curNode = curNode->next) {
	if (curNode->type != XML_ELEMENT_NODE) {
	continue;
	}
	if (strcmp((const char *) curNode->name, "property")) {
	return false;
	}
	curNodeChild = curNode->children;
	for (curNodeChild = curNode->children; curNodeChild != nullptr; curNodeChild = curNodeChild->next) {
	if (curNodeChild->type != XML_ELEMENT_NODE) {
	continue;
	}
	if (!strcmp((const char *) curNodeChild->name, "name")) {
	if (curNodeChild->children != nullptr
	&& XML_TEXT_NODE == curNodeChild->children->type
	&& !strcmp((const char *) curNodeChild->children->content, key.c_str())) {
	findNode = curNode;
	findkey = true;
	} else {
	if (findkey) {
	xmlNewTextChild(findNode, NULL, BAD_CAST "value", BAD_CAST value.c_str());
	return true;
	}
	}
	} else if (!strcmp((const char *) curNodeChild->name, "value")) {
	if (findkey
	&& curNodeChild->children != nullptr
	&& XML_TEXT_NODE == curNodeChild->children->type) {
	xmlNodeSetContent(curNodeChild->children, (xmlChar) const_cast<char>(value.c_str()));
	return true;
	}
	} else {
	continue;
	}
	}
	}

	xmlNodePtr newNode = xmlNewNode(NULL, BAD_CAST "property");
	xmlAddChild(root, newNode);
	xmlNewTextChild(newNode, NULL, BAD_CAST "name", BAD_CAST key.c_str());
	xmlNewTextChild(newNode, NULL, BAD_CAST "value", BAD_CAST value.c_str());
	return true;
	}

	const string XmlConfig::getString(const char *key) {
	XmlConfigMapIterator it = kv.find(key);
	if (kv.end() == it) {
	return "";
	}
	return it->second;
	}

	const string XmlConfig::getString(const char key, const char def) {
	XmlConfigMapIterator it = kv.find(key);
	if (kv.end() == it) {
	return string(def);
	} else {
	return it->second;
	}
	}

	const string XmlConfig::getString(const string & key) {
	return getString(key.c_str());
	}

	const string XmlConfig::getString(const string & key,
	const string & def) {
	return getString(key.c_str(), def.c_str());
	}

	int64_t XmlConfig::getInt64(const char *key) {
	int64_t retval;
	XmlConfigMapIterator it = kv.find(key);
	if (kv.end() == it) {
	return 0;
	}
	retval = strToInt64(it->second.c_str());
	return retval;
	}

	int64_t XmlConfig::getInt64(const char *key, int64_t def) {
	int64_t retval;
	XmlConfigMapIterator it = kv.find(key);
	if (kv.end() == it) {
	return def;
	}
	retval = strToInt64(it->second.c_str());
	return retval;
	}

	int32_t XmlConfig::getInt32(const char *key) {
	int32_t retval;
	XmlConfigMapIterator it = kv.find(key);
	if (kv.end() == it) {
	return 0;
	}
	retval = strToInt32(it->second.c_str());
	return retval;
	}

	int32_t XmlConfig::getInt32(const char *key, int32_t def) {
	int32_t retval;
	XmlConfigMapIterator it = kv.find(key);
	if (kv.end() == it) {
	return def;
	}
	retval = strToInt32(it->second.c_str());
	return retval;
	}

	double XmlConfig::getDouble(const char *key) {
	double retval;
	XmlConfigMapIterator it = kv.find(key);
	if (kv.end() == it) {
	return 0.0;
	}
	retval = strToDouble(it->second.c_str());
	return retval;
	}

	double XmlConfig::getDouble(const char *key, double def) {
	double retval;
	XmlConfigMapIterator it = kv.find(key);
	if (kv.end() == it) {
	return def;
	}
	retval = strToDouble(it->second.c_str());
	return retval;
	}

	bool XmlConfig::getBool(const char *key) {
	bool retval;
	XmlConfigMapIterator it = kv.find(key);
	if (kv.end() == it) {
	return false;
	}
	retval = strToBool(it->second.c_str());
	return retval;
	}

	bool XmlConfig::getBool(const char *key, bool def) {
	bool retval;
	XmlConfigMapIterator it = kv.find(key);
	if (kv.end() == it) {
	return def;
	}
	retval = strToBool(it->second.c_str());
	return retval;
	}

	int64_t XmlConfig::strToInt64(const char *str) {
	int64_t retval;
	char *end = nullptr;
	retval = strtoll(str, &end, 0);
	return retval;
	}

	int32_t XmlConfig::strToInt32(const char *str) {
	int32_t retval;
	char *end = nullptr;
	retval = strtoll(str, &end, 0);
	return retval;
	}

	bool XmlConfig::strToBool(const char *str) {
	bool retval = false;
	if (!strcasecmp(str, "true") \|\| !strcmp(str, "1")) {
	retval = true;
	} else if (!strcasecmp(str, "false") \|\| !strcmp(str, "0")) {
	retval = false;
	} else {
	return false;
	}
	return retval;
	}

	double XmlConfig::strToDouble(const char *str) {
	double retval;
	char *end = nullptr;
	retval = strtod(str, &end);
	return retval;
	}

	} // namespace test
	} // namespace hawq