configurator.h

Go to the documentation of this file.

// Copyright 2018-2025:
//   GobySoft, LLC (2013-)
//   Community contributors (see AUTHORS file)
// File authors:
//   Toby Schneider <toby@gobysoft.org>
//
//
// This file is part of the Goby Underwater Autonomy Project Libraries
// ("The Goby Libraries").
//
// The Goby Libraries are free software: you can redistribute them and/or modify
// them under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation, either version 2.1 of the License, or
// (at your option) any later version.
//
// The Goby Libraries are distributed in the hope that they will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with Goby.  If not, see <http://www.gnu.org/licenses/>.
 
#ifndef GOBY_MIDDLEWARE_APPLICATION_CONFIGURATOR_H
#define GOBY_MIDDLEWARE_APPLICATION_CONFIGURATOR_H
 
#include "goby/middleware/application/configuration_reader.h"
#include "goby/middleware/protobuf/app_config.pb.h"
 
namespace goby
{
namespace middleware
{
template <typename Config> class ConfiguratorInterface
{
  public:
    const Config& cfg() const { return cfg_; }
 
    virtual const protobuf::AppConfig& app_configuration() const { return app_configuration_; }
 
    virtual void validate() const {}
 
    virtual void handle_config_error(middleware::ConfigException& e) const
    {
        std::cerr << "Invalid configuration: " << e.what() << std::endl;
    }
 
    virtual std::string str() const = 0;
 
  protected:
    Config& mutable_cfg() { return cfg_; }
 
    virtual protobuf::AppConfig& mutable_app_configuration() { return app_configuration_; }
 
  private:
    Config cfg_;
    protobuf::AppConfig app_configuration_;
};
 
template <typename Config> class ProtobufConfigurator : public ConfiguratorInterface<Config>
{
  public:
    ProtobufConfigurator(int argc, char* argv[]);
 
    const protobuf::AppConfig& app_configuration() const override { return this->cfg().app(); }
 
  protected:
    virtual void validate() const override
    {
        middleware::ConfigReader::check_required_cfg(this->cfg(), this->cfg().app().binary());
    }
 
  private:
    virtual std::string str() const override { return this->cfg().DebugString(); }
 
    void handle_config_error(middleware::ConfigException& e) const override
    {
        if (tool_has_help_action())
        {
            std::cerr << "Invalid command: " << e.what() << std::endl;
        }
        else
        {
            std::cerr << "Invalid configuration: use --help and/or --example_config for more help: "
                      << e.what() << std::endl;
        }
    }
 
    protobuf::AppConfig& mutable_app_configuration() override
    {
        return *this->mutable_cfg().mutable_app();
    }
 
    void merge_app_base_cfg(protobuf::AppConfig* base_cfg,
                            const boost::program_options::variables_map& var_map);
 
    bool tool_has_help_action() const
    {
        return Config::descriptor()
            ->options()
            .GetExtension(goby::msg)
            .cfg()
            .tool()
            .has_help_action();
    }
};
 
template <typename Config>
ProtobufConfigurator<Config>::ProtobufConfigurator(int argc, char* argv[])
{
    //
    // read the configuration
    //
    Config& cfg = this->mutable_cfg();
 
    boost::program_options::variables_map var_map;
    try
    {
        std::string application_name;
        std::string binary_name;
 
        // we will check it later in validate()
        bool check_required_cfg = false;
        boost::program_options::options_description od{"All options"};
        int read_argc = middleware::ConfigReader::read_cfg(
            argc, argv, &cfg, &application_name, &binary_name, &od, &var_map, check_required_cfg);
 
        // extra command line parameters for tool mode
        for (int a = read_argc; a < argc; ++a)
            cfg.mutable_app()->mutable_tool_cfg()->add_extra_cli_param(argv[a]);
 
        // overwrite the app.name setting if it isn't set or if -a is set to change the application name. Otherwise, use it
        if (!cfg.app().has_name() || application_name != binary_name)
            cfg.mutable_app()->set_name(application_name);
 
        cfg.mutable_app()->set_binary(binary_name);
        // incorporate some parts of the AppBaseConfig that are middleware
        // with gobyd (e.g. Verbosity)
        merge_app_base_cfg(cfg.mutable_app(), var_map);
    }
    catch (middleware::ConfigException& e)
    {
        handle_config_error(e);
 
        // allow default action to take place (usually "help")
        if (!tool_has_help_action())
            throw;
    }
 
    // TODO: convert to C++ struct app3 configuration format
    this->mutable_app_configuration() = *cfg.mutable_app();
}
 
template <typename Config>
void ProtobufConfigurator<Config>::merge_app_base_cfg(
    goby::middleware::protobuf::AppConfig* base_cfg,
    const boost::program_options::variables_map& var_map)
{
    if (var_map.count("ncurses"))
    {
        base_cfg->mutable_glog_config()->set_show_gui(true);
    }
 
    if (var_map.count("verbose"))
    {
        switch (var_map["verbose"].as<std::size_t>())
        {
            case 0: break;
            case 1:
                base_cfg->mutable_glog_config()->set_tty_verbosity(
                    util::protobuf::GLogConfig::VERBOSE);
                break;
            case 2:
                base_cfg->mutable_glog_config()->set_tty_verbosity(
                    util::protobuf::GLogConfig::DEBUG1);
                break;
            case 3:
                base_cfg->mutable_glog_config()->set_tty_verbosity(
                    util::protobuf::GLogConfig::DEBUG2);
                break;
            default:
            case 4:
                base_cfg->mutable_glog_config()->set_tty_verbosity(
                    util::protobuf::GLogConfig::DEBUG3);
                break;
        }
    }
 
    if (var_map.count("glog_file_verbose"))
    {
        switch (var_map["glog_file_verbose"].as<std::size_t>())
        {
            case 0: break;
 
            case 1:
                base_cfg->mutable_glog_config()->mutable_file_log()->set_verbosity(
                    util::protobuf::GLogConfig::VERBOSE);
                break;
            case 2:
                base_cfg->mutable_glog_config()->mutable_file_log()->set_verbosity(
                    util::protobuf::GLogConfig::DEBUG1);
                break;
            case 3:
                base_cfg->mutable_glog_config()->mutable_file_log()->set_verbosity(
                    util::protobuf::GLogConfig::DEBUG2);
                break;
            default:
            case 4:
                base_cfg->mutable_glog_config()->mutable_file_log()->set_verbosity(
                    util::protobuf::GLogConfig::DEBUG3);
                break;
        }
    }
 
    if (var_map.count("glog_file_dir"))
    {
        base_cfg->mutable_glog_config()->mutable_file_log()->set_file_dir(
            var_map["glog_file_dir"].as<std::string>());
    }
}
 
} // namespace middleware
} // namespace goby
 
#endif