configuration.cpp

//================================================================================
// Name        : configuration.cpp
// Author      : Alessio Netti
// Contact     : info@dcdb.it
// Copyright   : Leibniz Supercomputing Centre
// Description : Class responsible for reading collectagent specific configuration.
//================================================================================

//================================================================================
// This file is part of DCDB (DataCenter DataBase)
// Copyright (C) 2018-2019 Leibniz Supercomputing Centre
//
// This program 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
// of the License, or (at your option) any later version.
//
// This program 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 Street, Fifth Floor, Boston, MA  02110-1301, USA.
//================================================================================

#include "configuration.h"

bool Configuration::readAdditionalValues(boost::property_tree::iptree::value_type &global) {
    // ----- READING ADDITIONAL GLOBAL SETTINGS -----
    if (boost::iequals(global.first, "mqttListenAddress")) {
        mqttListenHost = parseNetworkHost(global.second.data());
        mqttListenPort = parseNetworkPort(global.second.data());
        if(mqttListenPort=="") mqttListenPort = string(DEFAULT_LISTENPORT);
    } else if (boost::iequals(global.first, "cleaningInterval")) {
        cleaningInterval = stoul(global.second.data());
    } else if (boost::iequals(global.first, "messageThreads")) {
        messageThreads = stoul(global.second.data());
    } else if (boost::iequals(global.first, "messageSlots")) {
        messageSlots = stoul(global.second.data());
    } else {
        return false;
    }
    return true;
}

void Configuration::readAdditionalBlocks(boost::property_tree::iptree& cfg) {
    // ----- READING CASSANDRA SETTINGS -----
    if(cfg.find("cassandra") != cfg.not_found()) {
        BOOST_FOREACH(boost::property_tree::iptree::value_type & global, cfg.get_child("cassandra")) {
            if (boost::iequals(global.first, "address")) {
                cassandraSettings.host = parseNetworkHost(global.second.data());
                cassandraSettings.port = parseNetworkPort(global.second.data());
                if(cassandraSettings.port=="") cassandraSettings.port = string(DEFAULT_CASSANDRAPORT);
            } else if (boost::iequals(global.first, "username")) {
                cassandraSettings.username = global.second.data();
            } else if (boost::iequals(global.first, "password")) {
                cassandraSettings.password = global.second.data();
            } else if (boost::iequals(global.first, "ttl")) {
                cassandraSettings.ttl = stoul(global.second.data());
            } else if (boost::iequals(global.first, "numThreadsIo")) {
                cassandraSettings.numThreadsIo = stoul(global.second.data());
            } else if (boost::iequals(global.first, "queueSizeIo")) {
                cassandraSettings.queueSizeIo = stoul(global.second.data());
            } else if (boost::iequals(global.first, "coreConnPerHost")) {
                cassandraSettings.coreConnPerHost = stoul(global.second.data());
            } else if (boost::iequals(global.first, "debugLog")) {
                cassandraSettings.debugLog = to_bool(global.second.data());
            } else {
                LOG(warning) << "  Value \"" << global.first << "\" not recognized. Omitting";
            }
        }
    }
}

DCDB::PublicSensor Configuration::metadataToPublicSensor(const SensorMetadata& sm) {
    DCDB::PublicSensor ps;
    if(sm.getPublicName())
        ps.name = *sm.getPublicName();
    if(sm.getIsVirtual())
        ps.is_virtual = *sm.getIsVirtual();
    if(sm.getPattern())
        ps.pattern = *sm.getPattern();
    if(sm.getUnit())
        ps.unit = *sm.getUnit();
    if(sm.getScale())
        ps.scaling_factor = *sm.getScale();
    if(sm.getTTL())
        ps.ttl = *sm.getTTL();
    if(sm.getInterval())
        ps.interval = *sm.getInterval();
    if(sm.getOperations())
        ps.operations = *sm.getOperations();
    uint64_t sensorMask = 0;
    if(sm.getIntegrable() && *sm.getIntegrable())
        sensorMask = sensorMask | INTEGRABLE;
    if(sm.getMonotonic() && *sm.getMonotonic())
        sensorMask = sensorMask | MONOTONIC;
    ps.sensor_mask = sensorMask;
    return ps;
}

SensorMetadata Configuration::publicSensorToMetadata(const DCDB::PublicSensor& ps) {
    SensorMetadata sm;
    sm.setPublicName(ps.name);
    sm.setIsVirtual(ps.is_virtual);
    
    // Stripping whitespace from the sensor pattern in the SID
    string stripPattern = ps.pattern;
    boost::algorithm::trim(stripPattern);
    sm.setPattern(stripPattern);
    
    sm.setUnit(ps.unit);
    sm.setScale(ps.scaling_factor);
    sm.setTTL(ps.ttl);
    sm.setInterval(ps.interval);
    sm.setOperations(ps.operations);
    sm.setIntegrable(ps.sensor_mask & INTEGRABLE);
    sm.setMonotonic(ps.sensor_mask & MONOTONIC);
    return sm;
}