clientLib.hpp

Go to the documentation of this file.

 
#ifndef RTCTK_CLIENT_CLIENTLIB_HPP
#define RTCTK_CLIENT_CLIENTLIB_HPP
 
#include "rtctk/componentFramework/logger.hpp"
#include "rtctk/componentFramework/serviceDiscovery.hpp"
#include "rtctk/componentFramework/commandRequestor.hpp"
#include "rtctk/componentFramework/stateSubscriber.hpp"
 
#include <boost/program_options.hpp>
 
#include <iostream>
#include <chrono>
#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;
    LogConfigure();
    MakeLogger("client", log4cplus::INFO_LOG_LEVEL, false, false);
    SetDefaultLogger("client");
 
    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.Get(ServiceDiscovery::PUB_SUB_ENDPOINT);
            LOG4CPLUS_DEBUG(GetLogger(), "Subscribe URI is '" << subscribe_uri << "'.");
 
            StateSubscriber subscriber(subscribe_uri,
                [](const double timestamp, const string& name, const string& state) {
                    LOG4CPLUS_INFO(GetLogger(), name << " changed state to: " << state);
                });
 
            while(true) { this_thread::sleep_for(seconds(1)); }
 
        }else {
 
            Uri request_uri  = serv_disc.Get(ServiceDiscovery::REQ_REP_ENDPOINT);
            LOG4CPLUS_DEBUG(GetLogger(), "Request URI is '" << request_uri << "'.");
 
            CommandRequestorType requestor(request_uri, timeout);
            auto reply = requestor.SendCommandSync(cmd, cmd_arg);
            cout << reply << endl;
        }
    } catch (elt::mal::TimeoutException const& e) {
        LOG4CPLUS_ERROR(GetLogger(),  "Request timed out.");
        return EXIT_FAILURE;
    } catch (std::exception const& e) {
        LOG4CPLUS_FATAL(GetLogger(),  e.what());
        return EXIT_FAILURE;
    } catch (...) {
        LOG4CPLUS_FATAL(GetLogger(),  "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 rtctk::componentFramework::GetLogger;
    using elt::mal::Uri;
 
    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");
    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>(), "service discovery endpoint");
 
    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(GetLogger(), "Component identity is '" << vm["cid"].as<string>() << "'.");
        }else{
            LOG4CPLUS_FATAL(GetLogger(), "Component identity not specified !");
            exit(EXIT_FAILURE);
        }
        if (vm.count("cmd")) {
            LOG4CPLUS_DEBUG(GetLogger(), "Command is '" << vm["cmd"].as<string>() << "'.");
        }else{
            LOG4CPLUS_FATAL(GetLogger(), "Command name not specified !");
            exit(EXIT_FAILURE);
        }
        if (vm.count("cmd_arg")) {
            LOG4CPLUS_DEBUG(GetLogger(), "Command Arg is '" << vm["cmd_arg"].as<string>() << "'.");
        }
        if (vm.count("sde")) {
            LOG4CPLUS_DEBUG(GetLogger(), "Service Discovery Endpoint is '" << vm["sde"].as<Uri>() << "'.");
        }else{
            LOG4CPLUS_FATAL(GetLogger(), "Service Discovery Endpoint not specified !");
            exit(EXIT_FAILURE);
        }
        if (vm.count("timeout")) {
            LOG4CPLUS_DEBUG(GetLogger(), "Request reply timeout is " << vm["timeout"].as<double>()
                            << "s.");
        }
 
        return vm;
 
    } catch (bpo::error& e) {
        LOG4CPLUS_FATAL(GetLogger(), e.what() << endl << endl );
        LOG4CPLUS_INFO(GetLogger(), opts_desc << endl );
        exit(EXIT_FAILURE);
    }
}
 
 
} // closing namespace
 
#endif