Options.cpp

Go to the documentation of this file.

/* 
 * Confdump-Agent - Dump static and runtime system configuration
 * Copyright (C) 2009-2012  Straton IT, SAS
 * 
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 3 as
 * published by the Free Software Foundation.
 * 
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include <iostream>
#include <vector>

#include "QFile"
#include "QTextStream"

#include "boost/foreach.hpp"
#include "boost/bind.hpp"
#include "boost/program_options.hpp"
#include "boost/program_options/cmdline.hpp"
namespace po = boost::program_options;
namespace pos = boost::program_options::command_line_style;

#include "Confdump/Options.hpp"
#include "Confdump/RuntimeError.hpp"
#include "Confdump/DumperFactory.hpp"

using std::vector;
using std::string;
using boost::bind;

namespace Confdump
{

Options::Options( int argc, char **argv, std::ostream &out )
{
    po::options_description gettingHelp( tr( "Getting help" ).toLocal8Bit().constData() );
    gettingHelp.add_options()
        ( "help,h", tr( "This information", "--help" ).toLocal8Bit().constData() )
        ( "help-tables",
            tr( "displays a list of tables that can be queried and exits"
                                " (can be combined with --output-file)" ).toLocal8Bit().constData() )
    ;

    po::options_description select( tr( "Configuration selection" ).toLocal8Bit().constData() );
    select.add_options()
        ( "table", po::value< vector<string> >()->notifier( bind( &Options::setTables, this, _1 ) ),
            tr( "tables to query (can be specified multiple times); format: [dumper.]table" ).toLocal8Bit().constData() )
        ( "tables-from", po::value< string >()->notifier( bind( &Options::readTablesFrom, this, _1 ) ),
            tr( "read a list of tables to query from this file" ).toLocal8Bit().constData() )
    ;

    po::options_description dumpers( tr( "Extra dumpers" ).toLocal8Bit().constData() );
    dumpers.add_options()
        ( "add-dumper", po::value< vector<string> >()->notifier( bind( &Options::setDumpers, this, _1 ) ),
            tr( "instanciate a new Dumper with a given alias (can be specified mutiple times); "
                "format: alias=Dumper" ).toLocal8Bit().constData() )
        ( "dumper-arg", po::value< vector<string> >()->notifier( bind( &Options::setDumperArgs, this, _1 ) ),
            tr( "set an option on an instanciated Dumper (can be specified mutiple times); "
                "format: alias.option=value" ).toLocal8Bit().constData() )
    ;

    po::options_description output( tr( "Output" ).toLocal8Bit().constData() );
    output.add_options()
        /*( "verbose,v", po::value< string >()->notifier( bind( &Options::setVerbosity, this, _1 ) )
                                            ->default_value( "info" )->implicit_value( "debug" ),
            tr( "sets verbosity to one of: trace, debug, info, warn, error" ).toLocal8Bit().constData() )*/
        ( "output-format", po::value< string >()->notifier( bind( &Options::setOutputFormat, this, _1 ) )
                                                ->default_value( "text" ),
            tr( "sets output format to one of: text, xml" ).toLocal8Bit().constData() )
        ( "output-file", po::value< string >()->notifier( bind( &Options::setOutputFile, this, _1 ) ),
            tr( "output to a file instead of standard output" ).toLocal8Bit().constData() )
    ;

    po::options_description allOptions( tr(
        "\n"
        CONFDUMP_VERSION " - Dump static and runtime system configuration\n"
        "Copyright (C) 2009-2012  Straton IT, SAS\n"
        "More information at http://confdump.sf.net/\n"
        "\n"
        "This program comes with ABSOLUTELY NO WARRANTY. This is free software, and you\n"
        "are welcome to redistribute it under the terms of the GPL version 3.\n"
        "\n"
        "Command-line options and arguments", "options description" ).toLocal8Bit().constData() );
    allOptions.add( gettingHelp ).add( select ).add( dumpers ).add( output );

    pos::style_t style = static_cast<pos::style_t> (
        pos::allow_long |           // --foo
        pos::long_allow_next |      // --foo bar
        pos::allow_short |          // -f
        pos::allow_dash_for_short | // -f
        pos::short_allow_next |     // -f bar
        pos::allow_sticky );        // -fF same as -f -F

    po::variables_map vm;
    po::store( po::parse_command_line( argc, argv, allOptions, style ), vm );
    po::notify( vm );    

    if ( vm.count( "help" ) )
    {
        operatingMode_ = HelpMode;
        out << allOptions << std::endl;
        #if CD_WIN32
        out << "WMI dumper options:\n";
        out << "  namespace (sets the WMI namespace to query, defaults to ROOT\\CIMv2)\n";
        out << "\n";
        out << "Win32 dumper options: (none)\n";
        #elif CD_UNIX
        //out << "Linux dumper options: none\n";
        #endif
        out << std::endl;
    }
    else if ( vm.count( "help-tables" ) )
    {
        operatingMode_ = HelpTablesMode;
    }
    else
    {
        operatingMode_ = NormalMode;
    }
}

Options::~Options()
{
}

void Options::setVerbosity( const std::string &value )
{
    QString level( QString::fromLocal8Bit( value.c_str() ).toLower() );
    if ( level == "trace" )
        logLevel_ = Trace;
    else if ( level == "debug" )
        logLevel_ = Debug;
    else if ( level == "info" || level == "information" )
        logLevel_ = Info;
    else if ( level == "warn" || level == "warning" )
        logLevel_ = Warning;
    else if ( level == "error" )
        logLevel_ = Error;
    else
        throw RuntimeError( tr( "Unknown verbosity level: '%1'" ).arg( level ) );
}

void Options::setOutputFormat( const std::string &value )
{
    QString format( QString::fromLocal8Bit( value.c_str() ).toLower() );
    if ( format == "text" )
        outputFormat_ = TextFormat;
    else if ( format == "xml" )
        outputFormat_ = XmlFormat;
    else
        throw RuntimeError( tr( "Unknown output format: '%1'" ).arg( format ) );
}

void Options::setOutputFile( const std::string &value )
{
    outputFile_ = QString::fromLocal8Bit( value.c_str() );
}

namespace
{

Options::TableList::value_type parseTable( QString qualifiedTable )
{
        if ( qualifiedTable.count( '.' ) == 1 )
        {
                QString alias = qualifiedTable.section( '.', 0, 0 );
                QString table = qualifiedTable.section( '.', -1, -1 );
                return std::make_pair( alias, table );
        }
        else
        {
                return std::make_pair( "main", qualifiedTable );
        }
}

}

void Options::setTables( const std::vector< std::string > &raw_tables )
{
    TableList tables;
    BOOST_FOREACH( const std::string &raw_table, raw_tables )
    {
        QString qualifiedTable = QString::fromLocal8Bit( raw_table.c_str() );
        tables << parseTable( qualifiedTable );
    }
    tables_ = tables;
}

void Options::setDumpers( const std::vector< std::string > &raw_dumpers )
{
    BOOST_FOREACH( const std::string &raw_dumper, raw_dumpers )
    {
        QString dumper = QString::fromLocal8Bit( raw_dumper.c_str() );
        QString alias = dumper.section( '=', 0, 0 ).toLower();
        QString implementation = dumper.section( '=', 1, -1 ).toLower();
        if ( alias.isEmpty() || implementation.isEmpty() )
            throw RuntimeError( "Invalid --add-dumper argument (must be alias=Dumper)" );
        dumperAliases_[alias] = implementation;
    }
}

void Options::setDumperArgs( const std::vector< std::string > &raw_args )
{
    BOOST_FOREACH( const std::string &raw_arg, raw_args )
    {
        QString arg = QString::fromLocal8Bit( raw_arg.c_str() );   // alias.key=value
        QString qualifiedKey = arg.section( '=', 0, 0 ).toLower(); // alias.key
        std::pair<QString, QString> key = parseTable( qualifiedKey );
        QString value = arg.section( '=', 1, -1 );
        if ( key.first.isEmpty() || key.second.isEmpty() || value.isEmpty() )
            throw RuntimeError( "Invalid --dumper-arg argument (must be alias.key=value)" );
        dumperArguments_[key.first][key.second] = value;
    }
}

std::map< QString, DumperSpecification > Options::dumperSpecifications() const
{
    // Merge dumperAliases_ + dumperArguments_
    std::map< QString, DumperSpecification > specifications;

    BOOST_FOREACH( DumperAliases::value_type dumper, dumperAliases_ )
    {
        DumperSpecification spec;
        QString alias = dumper.first;
        spec.name = dumper.second;
        spec.parameters = dumperArguments_[alias];
        specifications[alias] = spec;
    }

    // Check for unused arguments
    BOOST_FOREACH( DumperArguments::value_type args, dumperArguments_ )
    {
        QString alias = args.first;
        if ( specifications.find( alias ) == specifications.end() )
            throw RuntimeError( "Undefined alias used in --dumper-arg: " + alias );
    }

    return specifications;
}

void Options::readTablesFrom( const std::string &fileName8b )
{
    QString fileName( QString::fromLocal8Bit( fileName8b.c_str() ) );
    QFile file( fileName );
    if ( !file.open( QIODevice::ReadOnly | QIODevice::Text ) )
        throw RuntimeError( "Couldn't open "+fileName+" for reading: "+file.error() );

    QTextStream in( &file );
    while ( !in.atEnd() )
    {
        QString line = in.readLine();
        if ( !line.isEmpty() && line[0] != '#' )
            tables_ << parseTable( line );
    }
}

Options::TableList Options::tables() const
{
    return tables_;
}

}