SysfsConfigurator.cpp

/*
 * SysfsConfigurator.cpp
 *
 *  Created on: 18.11.2017
 *      Author: Micha Mueller
 */

#include "SysfsConfigurator.h"

#include <iostream>

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

using namespace std;

SysfsConfigurator::SysfsConfigurator() {}

SysfsConfigurator::~SysfsConfigurator() {}

bool SysfsConfigurator::readConfig(std::string cfgPath) {
	Configurator::readConfig(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(warning) << "  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()) {
				SysfsSensor sysfsSensor(sensor.second.data());
				readSensor(sysfsSensor, sensor.second);
				_templateSensors.insert(sensorMap_t::value_type(sysfsSensor.getName(), sysfsSensor));
			}
		}
	}

	//read one sensor at a time
	BOOST_FOREACH(boost::property_tree::iptree::value_type &sensor, cfg.get_child("sensors")) {
		if (boost::iequals(sensor.first, "sensor")) {
			LOG(debug) << "Sensor \"" << sensor.second.data() << "\"";
			if (!sensor.second.empty()) {
				SysfsSensor* sysfsSensor = new SysfsSensor(sensor.second.data());

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

void SysfsConfigurator::readSensor(SysfsSensor& sensor, boost::property_tree::iptree& config) {
	BOOST_FOREACH(boost::property_tree::iptree::value_type &s, config) {
		if (boost::iequals(s.first, ("path"))) {
			sensor.setPath(s.second.data());
		} else if (boost::iequals(s.first, "interval")) {
			sensor.setInterval(stoull(s.second.data()));
		} else if (boost::iequals(s.first, "mqttsuffix")) {
			sensor.setMqtt(_mqttPrefix + s.second.data());
		} else if (boost::iequals(s.first, "minValues")) {
			sensor.setMinValues(stoull(s.second.data()));
		} else if (boost::iequals(s.first, "filter")) {
			sensor.setFilter(true);
			string input = s.second.data();

			//check if input has sed format of "s/.../.../" for substitution
			regex checkSubstitute("s([^\\\\]{1})([\\S|\\s]*)\\1([\\S|\\s]*)\\1");
			smatch matchResults;

			if(regex_match(input, matchResults, checkSubstitute)) {
				//input has substitute format
				LOG(debug) << "  Init Regex with: " << matchResults[2].str();
				LOG(debug) << "  Substitution:	" << matchResults[3].str();
				sensor.setRegex(regex(matchResults[2].str(), regex_constants::extended));
				sensor.setSubstitution(matchResults[3].str());
			} else {
				//input is only a regex
				LOG(debug) << "  Init Regex with " << input;
				sensor.setRegex(regex(input, regex_constants::extended));
				sensor.setSubstitution("&");
			}
		} else if (boost::iequals(s.first, "default")) {
			//avoid unnecessary "Value not recognized" message
		} else {
			LOG(warning) << "  Value \"" << s.first << "\" not recognized. Omitting...";
		}
	}

	sensor.setCacheInterval(_cacheInterval);

	LOG(debug) << "  Path    : " << sensor.getPath();
	LOG(debug) << "  MQTT    : " << sensor.getMqtt();
	LOG(debug) << "  Interval: " << sensor.getInterval();
	LOG(debug) << "  minValues:" << sensor.getMinValues();
	if (sensor.hasFilter()) {
		//regex cannot be converted back to string
		LOG(debug) << "  Using regular expression to filter data";
	}
	return;
}