common/cfg_libconfig.cc

Go to the documentation of this file.

//
// cfg_libconfig.cc - This subclass of the Config class for the consmgr
// package uses the libconfig library, if available, to provide access
// to configuration files of that format.  More information on libconfig,
// as well as sources to the libconfig library, can be found at:
//   http://www.hyperrealm.com/libconfig/
//
// ***** BEGIN LICENSE BLOCK *****
// Version: MPL 1.1/GPL 2.0/LGPL 2.1
// 
// The contents of this file are subject to the Mozilla Public License
// Version 1.1 (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.mozilla.org/MPL/
// 
// Software distributed under the License is distributed on an "AS IS"
// basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
// the License for the specific language governing rights and limitations
// under the License.
// 
// The Original Code is the consmgr network/serial-line monitoring package.
// 
// The Initial Developer of the Original Code is Chris P. Ross.
// Portions created by the Initial Developer are Copyright (C) 2000-2008
// the Initial Developer.  All Rights Reserved.
// 
// Contributor(s):
// 
// Alternatively, the contents of this file may be used under the terms of
// either the GNU General Public License Version 2 or later (the "GPL"), or
// the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
// in which case the provisions of the GPL or the LGPL are applicable instead
// of those above. If you wish to allow use of your version of this file only
// under the terms of either the GPL or the LGPL, and not to allow others to
// use your version of this file under the terms of the MPL, indicate your
// decision by deleting the provisions above and replace them with the notice
// and other provisions required by the GPL or the LGPL. If you do not delete
// the provisions above, a recipient may use your version of this file under
// the terms of any one of the MPL, the GPL or the LGPL.
// 
// ***** END LICENSE BLOCK *****

#if     HAVE_LIBCONFIG

#include <sstream>

#include "cfg_libconfig.h"
#include "consmgr.h"

//
// Constructor & Destructor
//

LibConfig::LibConfig(const string &filename) : Config(filename)
{
    int         pret;
    
    // Instantiate the libconfig object mutex.
    pret = pthread_mutex_init(&mutex, NULL);
    PTHREAD_CHECK_AND_THROW(pret, "mutex_init(mutex)");

    // Lock the mutex, while we mess with the libconfig goo.
    pret = pthread_mutex_lock(&mutex);
    PTHREAD_CHECK_AND_THROW(pret, "mutex_lock(mutex)");

    try {
        config.readFile(filename.c_str());
    // readFile can throw ParseException or FileIOException
    } catch (libconfig::ParseException &pe) {
        // Unlock the mutex, and return.
        pret = pthread_mutex_unlock(&mutex);
        throw (ConfigParseException(pe.getLine(), pe.getError()));
    } catch (libconfig::FileIOException &pe)  {
        // Unlock the mutex, and return.
        pret = pthread_mutex_unlock(&mutex);
        // XXX - Perhaps we should have some sort of system-level subclass
        // of ConfigException for errors like this?
        throw (ConfigException("File I/O error reading libconfig configuration file " + filename));
    } catch (...) {
        clog << "Got a non-libconfig exception, re-throwing" << endl;
        throw (ConfigException("Unknown exception parsing Libconfig config file"));
    }

    // Unlock the mutex and return
    pret = pthread_mutex_unlock(&mutex);
    PTHREAD_CHECK_AND_THROW(pret, "mutex_unlock(mutex)");

    this->filename = filename;

    return;
}

LibConfig::~LibConfig(void)
{
    int         pret;
    
    pret = pthread_mutex_destroy(&mutex);
    PTHREAD_CHECK_AND_THROW(pret, "mutex_destroy(mutex)");

    return;
}

//
// Methods
//

void
LibConfig::load_entry(const string &name)
{    
    int         pret;

    // Lock the mutex, while we mess with the libconfig goo.
    pret = pthread_mutex_lock(&mutex);
    PTHREAD_CHECK_AND_THROW(pret, "mutex_lock(mutex)");

    if (!config.exists(name))
        throw ConfigUnfoundException(name);

    // This should never throw an exception, right?  Since exists was true?
    libconfig::Setting  &entry = config.lookup(name);
    
    // Okay, load any configuration matching the parameter keys we expect
    // from the entry into the std::map<>.
    for (std::vector<string>::const_iterator ki = Config::config_keys.begin() ;
         ki < Config::config_keys.end() ; ki++) {
        std::string     key = *ki;
        std::string     value;

        if (entry.exists(key)) {
            // At the moment, we have no typing in the Config class.  So, if
            // libconfig tells us it's a number, convert it to a string.
            if (entry[key].isNumber()) {
                std::ostringstream strval;

                strval << (unsigned int)entry[key];
                value = strval.str();
            } else
                entry.lookupValue(key, value);

            clog << "Loaded '" << key << "' (value '" << value << "') into the map" << endl;
            this->insert(std::pair<string,string>(key, value));
        }
        // XXX - Warn about an unfound key?
    }

    // And, we're done, so unlock the mutex
    pret = pthread_mutex_unlock(&mutex);
    PTHREAD_CHECK_AND_THROW(pret, "mutex_unlock(mutex)");

    return;
}
#endif  /* HAVE_LIBCONFIG */

---