PDUConfigurator.cpp

/*
 * PDUConfigurator.cpp
 *
 *  Created on: 24.02.2018
 *      Author: Micha Mueller
 */

#include "PDUConfigurator.h"

#include <iostream>
#include <sstream>

#include <boost/foreach.hpp>
#include <boost/property_tree/info_parser.hpp>
#include <boost/algorithm/string.hpp>

using namespace std;

PDUConfigurator::PDUConfigurator() {
	// TODO Auto-generated constructor stub

}

PDUConfigurator::~PDUConfigurator() {
	for (auto s : _sensors) {
		delete s;
	}
}

bool PDUConfigurator::readConfig(std::string cfgPath) {
	boost::property_tree::iptree cfg;
	boost::property_tree::read_info(cfgPath, cfg);

	//read global variables (if present overwrite those from global.conf)
	boost::optional<boost::property_tree::iptree&> globalVals = cfg.get_child_optional("global");
	if (globalVals) {
		BOOST_FOREACH(boost::property_tree::iptree::value_type &global, cfg.get_child("global")) {
			if(boost::iequals(global.first, "mqttprefix")) {
				_mqttPrefix = global.second.data();
				if (_mqttPrefix[_mqttPrefix.length()-1] != '/') {
					_mqttPrefix.append("/");
				}
				LOG(debug) << "  Using own MQTT-Prefix " << _mqttPrefix;
			} else if (boost::iequals(global.first, "cacheInterval")) {
				_cacheInterval = stoul(global.second.data());
				LOG(debug) << "  Using own caching interval " << _cacheInterval << " [s]";
				_cacheInterval *= 1000;
			} else {
				LOG(error) << "  Value \"" << global.first << "\" not recognized. Omitting...";
			}
		}
	}

	//read template sensors
	BOOST_FOREACH(boost::property_tree::iptree::value_type &sensor, cfg.get_child("SensorTemplate")) {
		if (boost::iequals(sensor.first, "sensor")) {
			LOG(debug) << "Template Sensor \"" << sensor.second.data() << "\"";
			if (!sensor.second.empty()) {
				PDUSensor pduSensor(sensor.second.data());
				if(readSensor(pduSensor, sensor.second)) {
					_templateSensors.insert(sensorMap_t::value_type(pduSensor.getName(), pduSensor));
				} else {
					LOG(warning) << "Template sensor \"" << sensor.second.data() << "\" has bad values! Ignoring...";
				}
			}
		}
	}

	//read one pdu at a time
	BOOST_FOREACH(boost::property_tree::iptree::value_type &pdu, cfg.get_child("pdus")) {
		if (boost::iequals(pdu.first, "pdu")) {
			LOG(debug) << "PDU \"" << pdu.second.data() << "\"";
			if (!pdu.second.empty()) {
				//create PDU at end of list
				_pdus.push_back(PDUUnit());
				PDUUnit& pduUnit = _pdus.back();

				//read PDU-values
				BOOST_FOREACH(boost::property_tree::iptree::value_type &val, pdu.second) {
					if (boost::iequals(val.first, "TTL")) {
						pduUnit.setTTL(stoull(val.second.data()));
						LOG(debug) << "  TTL	" << pduUnit.getTTL();
					} else if (boost::iequals(val.first, "host")) {
						std::string host = val.second.data();
						size_t pos = host.find(':');
						if (pos != string::npos) {
							pduUnit.setHost(host);
						} else {
							pduUnit.setHost(host + ":443");
						}
						LOG(debug) << "  Host	" << pduUnit.getHost();
					} else if (boost::iequals(val.first, "request")) {
						pduUnit.setRequest(val.second.data());
						LOG(debug) << "  Request:	\n" << pduUnit.getRequest();
					} else if (boost::iequals(val.first, "sensors")) {
						BOOST_FOREACH(boost::property_tree::iptree::value_type &sensor, val.second) {
							LOG(debug) << "Sensor \"" << sensor.second.data() << "\"";
							if (!sensor.second.empty()) {
								PDUSensor* pduSensor = new PDUSensor(sensor.second.data());

								//first check if default sensor is given
								boost::optional<boost::property_tree::iptree&> defaultC = sensor.second.get_child_optional("default");
								if(defaultC) {
									LOG(debug) << "  Using \"" << defaultC.get().data() << "\" as default.";
									sensorMap_t::iterator it = _templateSensors.find(defaultC.get().data());
									if(it != _templateSensors.end()) {
										*pduSensor = it->second;
										pduSensor->setName(sensor.second.data());
									} else {
										LOG(warning) << "  Template sensor \"" << defaultC.get().data() << "\" not found! Using standard values.";
									}
								}

								//read remaining values
								if(readSensor(*pduSensor, sensor.second)) {
									//set pointer to corresponding pdu
									pduSensor->setPdu(&pduUnit);
									_sensors.push_back(pduSensor);
								} else {
									LOG(warning) << "  Sensor \"" << sensor.second.data() << "\" has bad values! Ignoring...";
								}
							}
						}
					}
				}
			}
		}
	}
	return true;
}

bool PDUConfigurator::readSensor(PDUSensor& sensor, boost::property_tree::iptree& config) {
	BOOST_FOREACH(boost::property_tree::iptree::value_type &val, config) {
		if (boost::iequals(val.first, "interval")) {
			sensor.setInterval(stoull(val.second.data()));
		} else if (boost::iequals(val.first, "mqttsuffix")) {
			sensor.setMqtt(_mqttPrefix + val.second.data());
		} else if (boost::iequals(val.first, "minValues")) {
			sensor.setMinValues(stoull(val.second.data()));
		} else if (boost::iequals(val.first, "path")) {
			parsePathString(sensor, val.second.data());
		} else if (boost::iequals(val.first, "default")) {
			//avoid unnecessary "Value not recognized" message
		} else {
			LOG(warning) << "  Value \"" << val.first << "\" not recognized. Omitting...";
		}
	}
	sensor.setCacheInterval(_cacheInterval);

	LOG(debug) << "  MQTT     : " << sensor.getMqtt();
	LOG(debug) << "  Interval : " << sensor.getInterval();
	LOG(debug) << "  minValues: " << sensor.getMinValues();

	return true;
}

void PDUConfigurator::parsePathString(PDUSensor& sensor, const std::string& pathString) {
	LOG(debug) << "  Using " << pathString << " as XML search path";

	std::vector<std::string> subStrings;

	std::stringstream pathStream(pathString);
	std::string item;
	//split into parts if a attribute (indicated by '(' ')') was defined
	while (std::getline(pathStream, item, ')')) {
		subStrings.push_back(item);
	}

	for (auto subStr : subStrings) {
		//extract the attributes from the path-parts
		if (subStr.find('(') != std::string::npos) { //attribute specified
			std::stringstream pathWithAttributesSStream(subStr);

			//split into path and attributes string
			std::string subPath, attributeString;
			std::getline(pathWithAttributesSStream, subPath, '(');
			std::getline(pathWithAttributesSStream, attributeString);

			if (subPath.front() == '.') {
				subPath.erase(0, 1);
			}

			//now further split the attributes string as multiple attributes could be defined
			std::vector<std::string> attributes;
			std::stringstream attributeStream(attributeString);
			while (std::getline(attributeStream, item, ',')) {
				attributes.push_back(item);
			}
			attributesVector_t attrs;
			for (auto att : attributes) {
				//part attributes into name and value
				if (att.find('=') != std::string::npos) {
					std::stringstream attStream(att);

					std::string attName, attVal;
					std::getline(attStream, attName, '=');
					std::getline(attStream, attVal);

					attrs.push_back(std::make_pair(attName, attVal));
					LOG(debug) << "  Attribute: " << attName << "=" << attVal;
				} else { //should not happen. If it does the path was malformed
					LOG(error) << "  Could not parse XML-path!";
					return;
				}
			}
			//split of the last child in the path. Required to iterate over multiple nodes which only differ in the attributes with BOOST_FOREACH
			auto index = subPath.find_last_of('.');
			if (index != std::string::npos) {
				std::string subPathChild(subPath.substr(++index));
				subPath.erase(--index);
				sensor._xmlPath.push_back(std::make_tuple(subPath, subPathChild, attrs));
				LOG(debug) << "  Subpath: " << subPath << " ; Child: " << subPathChild;
			} else {//the path contained only one node
				sensor._xmlPath.push_back(std::make_tuple("", subPath, attrs));
				LOG(debug) << "  Child: " << subPath;
			}
		} else { //no attributes specified. Last (sub)path
			if (subStr.front() == '.') {
				subStr.erase(0, 1);
			}
			sensor._xmlPath.push_back(std::make_tuple(subStr, "", attributesVector_t()));
			LOG(debug) << "  (Sub)path: " << subStr;
			break;
		}
	}
}