clientLib.hpp

Go to the documentation of this file.

 
#ifndef RTCTK_CLIENT_CLIENTLIB_HPP
#define RTCTK_CLIENT_CLIENTLIB_HPP
 
#include <rtctk/componentFramework/commandRequestor.hpp>
#include <rtctk/componentFramework/logger.hpp>
#include <rtctk/componentFramework/serviceDiscovery.hpp>
#include <rtctk/componentFramework/stateSubscriber.hpp>
 
#include <boost/program_options.hpp>
 
#include <chrono>
#include <iostream>
#include <thread>
 
namespace rtctk::client {
 
boost::program_options::variables_map ParseOptions(int argc, char* argv[]);
 
template <typename CommandRequestorType = rtctk::componentFramework::CommandRequestor>
int RunClient(int argc, char** argv) {
    static_assert(
        std::is_base_of_v<rtctk::componentFramework::CommandRequestor, CommandRequestorType>,
        "'CommandRequestorType must extend 'rtctk::componentFramework::CommandRequestor'");
    using namespace std;
    using namespace rtctk::componentFramework;
    using elt::mal::Uri;
    using std::chrono::duration;
    using std::chrono::duration_cast;
    using std::chrono::milliseconds;
    using std::chrono::seconds;
 
    LogInitializer initializer;
    LogConfigureTool("rtctkClient");
    auto& logger = GetLogger("rtctk");
 
    auto args = ParseOptions(argc, argv);
    string cid = args["cid"].as<string>();
    string cmd = args["cmd"].as<string>();
    string cmd_arg = args["cmd_arg"].as<string>();
    Uri sde = args["sde"].as<Uri>();
    ServiceDiscovery serv_disc(sde, cid);
 
    std::optional<milliseconds> timeout;
    if (args.count("timeout")) {
        timeout = duration_cast<milliseconds>(duration<double>(args["timeout"].as<double>()));
    }
 
    try {
        if (cmd == "Listen") {
            Uri subscribe_uri = serv_disc.GetPubSubEndpoint();
            LOG4CPLUS_DEBUG(logger, "Subscribe URI is '" << subscribe_uri << "'.");
 
            StateSubscriber subscriber(subscribe_uri,
                                       [&](const taiclock::TaiClock::time_point timestamp,
                                           const string& name,
                                           const string& state) {
                                           LOG4CPLUS_INFO(logger,
                                                          name << " changed state to: " << state);
                                       });
 
            while (true) {
                this_thread::sleep_for(seconds(1));
            }
 
        } else {
            Uri request_uri = serv_disc.GetReqRepEndpoint();
            LOG4CPLUS_DEBUG(logger, "Request URI is '" << request_uri << "'.");
 
            CommandRequestorType requestor(request_uri, timeout);
            auto reply = requestor.SendCommandSync(cmd, cmd_arg);
            cout << reply << endl;
        }
    } catch (const elt::mal::TimeoutException& e) {
        LOG4CPLUS_ERROR(logger, "Request timed out.");
        return EXIT_FAILURE;
    } catch (const std::exception& e) {
        LOG4CPLUS_FATAL(logger, e.what());
        return EXIT_FAILURE;
    } catch (...) {
        LOG4CPLUS_FATAL(logger, "Unknown exception");
        return EXIT_FAILURE;
    }
 
    return EXIT_SUCCESS;
}
 
boost::program_options::variables_map ParseOptions(int argc, char* argv[]) {
    using namespace std;
    namespace bpo = boost::program_options;
    using elt::mal::Uri;
    using rtctk::componentFramework::GetLogger;
    auto& logger = GetLogger("rtctk");
 
    bpo::positional_options_description pos_opts_desc;
    pos_opts_desc.add("cid", 1);
    pos_opts_desc.add("cmd", 1);
    pos_opts_desc.add("cmd_arg", -1);
 
    bpo::options_description opts_desc("Options");
    // clang-format off
    opts_desc.add_options()
        ("help,h", "Print help messages")
        ("timeout,t", bpo::value<double>()->default_value(30.0), "timeout [sec]")
        ("cid,i", bpo::value<string>(), "component identity")
        ("cmd,c", bpo::value<string>(), "command name")
        ("cmd_arg,a", bpo::value<string>()->default_value(""), "command arguments")
        ("sde,s", bpo::value<Uri>()->default_value(Uri("consul://localhost:8500")),
                                        "service discovery endpoint");
    // clang-format on
 
    try {
        bpo::variables_map vm;
 
        bpo::store(
            bpo::command_line_parser(argc, argv).options(opts_desc).positional(pos_opts_desc).run(),
            vm);
 
        bpo::notify(vm);
 
        if (vm.count("help")) {
            cout << opts_desc << endl;
            exit(EXIT_SUCCESS);
        }
        if (vm.count("cid")) {
            LOG4CPLUS_DEBUG(logger, "Component identity is '" << vm["cid"].as<string>() << "'.");
        } else {
            LOG4CPLUS_FATAL(logger, "Component identity not specified !");
            exit(EXIT_FAILURE);
        }
        if (vm.count("cmd")) {
            LOG4CPLUS_DEBUG(logger, "Command is '" << vm["cmd"].as<string>() << "'.");
        } else {
            LOG4CPLUS_FATAL(logger, "Command name not specified !");
            exit(EXIT_FAILURE);
        }
        if (vm.count("cmd_arg")) {
            LOG4CPLUS_DEBUG(logger, "Command Arg is '" << vm["cmd_arg"].as<string>() << "'.");
        }
        if (vm.count("sde")) {
            LOG4CPLUS_DEBUG(logger,
                            "Service Discovery Endpoint is '" << vm["sde"].as<Uri>() << "'.");
        } else {
            LOG4CPLUS_FATAL(logger, "Service Discovery Endpoint not specified !");
            exit(EXIT_FAILURE);
        }
        if (vm.count("timeout")) {
            LOG4CPLUS_DEBUG(logger,
                            "Request reply timeout is " << vm["timeout"].as<double>() << "s.");
        }
 
        return vm;
 
    } catch (bpo::error& e) {
        LOG4CPLUS_FATAL(logger, e.what() << endl << endl);
        LOG4CPLUS_INFO(logger, opts_desc << endl);
        exit(EXIT_FAILURE);
    }
}
 
}  // namespace rtctk::client
 
#endif  // RTCTK_CLIENT_CLIENTLIB_HPP