common/cfg_yaml.cc

Go to the documentation of this file.

//
// cfg_yaml.cc - This subclass of the Config class for the consmgr
// package handles configuration files in YAML format.
// Information about YAML can be found at:
//      http://www.yaml.org/
// Multiple libraries could theoretically be used to support YAML
// format configuration files.  The first is Syck, and more information
// about Syck (aka LibSyck) can be found at:
//      http://www.whytheluckystiff.net/syck/
//
// ***** 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 *****

#ifdef  HAVE_YAML

#include <sstream>

extern "C" {
#include <stdio.h>
#include <string.h>
#include <sys/errno.h>
};

#include "cfg_yaml.h"
#include "consmgr.h"

//
// Constructor & Destructor
//

#if     YAML_USING_SYCK

YAML        *YAML::instance = NULL;
#endif  /* YAML_USING_SYCK */

YAML::YAML(const string &filename) : Config(filename)
#if YAML_USING_SYCK
    , parser(NULL), filep(NULL), index(162)
#endif
{
#if YAML_USING_SYCK
    // Ensure only one instance of this class can ever be constructed
    if (instance) {
        std::ostringstream      error;
        
        error << "Only one instance of class YAML may exist, and one "
              << "already exists at " << instance;
        throw ConfigException(error.str());
    }
#endif  /* YAML_USING_SYCK */
        
    int         pret;
    
    // Instantiate the parser mutex.
    pret = pthread_mutex_init(&mutex, NULL);
    PTHREAD_CHECK_AND_THROW(pret, "mutex_init(mutex)");

    // Lock said mutex
    pret = pthread_mutex_lock(&mutex);
    PTHREAD_CHECK_AND_THROW(pret, "mutex_lock(mutex)");

#if YAML_USING_SYCK
    // And, generate a parser
    parser = syck_new_parser();
    if (parser == NULL)
        throw ConfigException("Unable to generate a Parser from the Syck library.");

    // At this point, assume we're safe to consider ourselves constructed.
    YAML::instance = this;
    
    // XXX - This is probably a reasonable place to set up all of the
    // handlers needed by Syck...
    syck_parser_handler(parser, YAML::node_handler);
    syck_parser_error_handler(parser, YAML::error_handler);
    syck_parser_bad_anchor_handler(parser, bad_anchor_handler);
    
    // And, set up the file for input.  This needs to be done
    // with a FILE*.  No way to do that from an iostream, is there?
    filep = fopen(filename.c_str(), "r");
    // XXX - Again, perhaps there should be a "system error" type subclass
    // of ConfigException...
    if (filep == NULL)
        throw ConfigException("Unable to open input file '"+filename+"': "+string(strerror(errno)));
    syck_parser_file(parser, filep, NULL);
#endif

    // Unlock the mutex before returning
    pret = pthread_mutex_unlock(&mutex);
    PTHREAD_CHECK_AND_THROW(pret, "mutex_unlock(mutex)");
}

YAML::~YAML()
{
    int         pret;
    
    // Lock the mutex
    pret = pthread_mutex_lock(&mutex);
    PTHREAD_CHECK_AND_THROW(pret, "mutex_lock(mutex)");

#if YAML_USING_SYCK
    // Free the parser
    syck_free_parser(parser);
    parser = NULL;
#endif

    // Unlock and destroy the mutex
    pret = pthread_mutex_unlock(&mutex);
    PTHREAD_CHECK_AND_THROW(pret, "mutex_unlock(mutex)");
    pret = pthread_mutex_destroy(&mutex);
    PTHREAD_CHECK_AND_THROW(pret, "mutex_destroy(mutex)");
}

//
// Methods
//

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

    // Lock the mutex for the duration of the YAML parsing
    pret = pthread_mutex_lock(&mutex);
    PTHREAD_CHECK_AND_THROW(pret, "mutex_lock(mutex)");
    
    // Store the name of the entry we're looking for, other methods will
    // need to know.
    intended = name;
    
#if 0
    clog << "keys are:" << endl;
    for (std::vector<std::string>::const_iterator ki = config_keys.begin() ;
         ki != config_keys.end() ; ki++) {
        clog << "\t" << *ki << endl;
    }
#endif

    // Call syck_parse().  The mutex is locked, so all of the [static]
    // functions will run with the mutex locked.  When syck_parse() returns,
    // the "top" element is returned, but we don't care.  We should, however,
    // at this point check to see if the entry was loaded, and indicate that
    // to the caller, right?
    if (syck_parse(parser) == 0)
        throw ConfigUnfoundException(name);
    
    // Unlock the mutex, and return.  Should all be done now, right?
    pret = pthread_mutex_unlock(&mutex);
    PTHREAD_CHECK_AND_THROW(pret, "mutex_unlock(mutex)");

    return;
}

#if YAML_USING_SYCK
//
// [Static] wrapper functions that are passed into the Syck library
// functions as callbacks.
//

SYMID
YAML::node_handler(SyckParser *p, SyckNode *n)
{
    return YAML::instance->import_node(n);
}

void
YAML::error_handler(SyckParser *p, char *str)
{
    throw ConfigParseException(p->linect + 1, string(str));
}

SyckNode *
YAML::bad_anchor_handler(SyckParser *p, char *anchor)
{
clog << "In bad_anchor_handler, anchor: " << anchor << endl;
return(NULL);
}

//
// Member functions that are doing most of the work...
//

SYMID
YAML::import_node(SyckNode *n)
{
#ifdef  CONFIGURATION_DEBUGGING
    clog << "Importing node, kind: ";
#endif  /* CONFIGURATION_DEBUGGING */
    switch (n->kind) {
      case syck_map_kind:
#ifdef  CONFIGURATION_DEBUGGING
        clog << "map (style: " << ((n->data.pairs->style == map_inline) ? "inline" : "none")
             << "), " << n->data.pairs->idx << " elements (capacity " << n->data.pairs->capa << ")";
        for (short i = 0 ; i < syck_map_count(n) ; i++) {
            string key = scalars[n->data.pairs->keys[i]];
            string val;
            if (scalars.find(n->data.pairs->values[i]) == scalars.end()) {
                std::ostringstream foo;
                foo << "(SYMID " << n->data.pairs->values[i]
                    << "; not a scalar)";
                val = foo.str();
            } else
                val = scalars[n->data.pairs->values[i]];
            clog << endl << "       " << key << ": " << val;
        }
#endif  /* CONFIGURATION_DEBUGGING */
        // If it's a map whose value is a map, then the key should
        // be the name of the configuration component, and the value
        // is the map of parameters for that component.
        // XXX - this is limiting.  At the moment *all* config parameters
        // must be string values, rather than maps.  That may be a problem
        // later.
        for (short i = 0 ; i < syck_map_count(n) ; i++) {
            string      key = scalars[syck_map_read(n, map_key, i)];
            // If the value is a map, check the key against the element
            // name we're looking for.  If the value *isn't* a map, then
            // it clearly isn't a top-level key.
            if (maps.find(syck_map_read(n, map_value, i)) != maps.end()) {
#ifdef  CONFIGURATION_DEBUGGING
                clog << endl << "Got an element name: '" << key << "', ";
#endif  /* CONFIGURATION_DEBUGGING */
                if (key == intended) {
                    load_from_map(syck_map_read(n, map_value, i));
#ifdef  CONFIGURATION_DEBUGGING
                    clog << "loaded the values from the map!" << endl;
                } else {
                    clog << "don't want it.";
#endif  /* CONFIGURATION_DEBUGGING */
                }
            }
        }

        // Okay, assign this map a SYMID, then hold on to it?
        {
            SyckNode    *mapnode = syck_new_map(0,0);
            syck_map_empty(mapnode);
            syck_map_update(mapnode, n);
            
            n->id = index++;
            maps.insert(std::pair<SYMID,SyckNode*>(n->id,mapnode));
        }
        break;
      case syck_seq_kind:
#ifdef  CONFIGURATION_DEBUGGING
        clog << "seq (style: " << ((n->data.list->style == seq_inline) ? "inline" : "none")
             << "), " << syck_seq_count(n) << " elements (capacity " << n->data.list->capa << ")";
#endif  /* CONFIGURATION_DEBUGGING */
        break;
      case syck_str_kind:
#ifdef  CONFIGURATION_DEBUGGING
        clog << "str (" << n->type_id << ", '" << n->data.str->ptr << "' (" << n->data.str->len << " bytes))";
#endif  /* CONFIGURATION_DEBUGGING */
        n->id = index++;
        scalars.insert(std::pair<SYMID,string>(n->id, string(n->data.str->ptr)));
        break;
    }
#ifdef  CONFIGURATION_DEBUGGING
    clog << endl;
#endif  /* CONFIGURATION_DEBUGGING */
    return(n->id);
}

// Load all of the SyckNode map entries into the std::map that is us.
void
YAML::load_from_map(SYMID mapid)
{
#ifdef  CONFIGURATION_DEBUGGING
    clog << "Loading from map at SYMID " << mapid << endl;
#endif  /* CONFIGURATION_DEBUGGING */

    SyckNode    *n = maps[mapid];
    
    // XXX - Should we load only the elements we expect?  Should we
    // complain if we don't see the nodes we want/need?  There's
    // no structure here to do that right now...
    
#ifdef  CONFIGURATION_DEBUGGING
    clog << "See a map with " << syck_map_count(n) << " elements:" << endl;
#endif  /* CONFIGURATION_DEBUGGING */
    // For each element of the map, load it into ourselves.
    for (short i = 0 ; i < syck_map_count(n) ; i++) {
        string  key = scalars[syck_map_read(n, map_key, i)];
        string  value = scalars[syck_map_read(n, map_value, i)];
#ifdef  CONFIGURATION_DEBUGGING
        clog << "\t" << key << "\t:\t" << value << endl;
#endif  /* CONFIGURATION_DEBUGGING */
        this->insert(std::pair<string,string>(key,value));
    }
    return;
}
#endif

#endif  /* HAVE_YAML */

---