secondary_config.cc

#include <fstream>
#include <iostream>
#include <unordered_map>

#include "logging/logging.h"
#include "secondary_config.h"

namespace Primary {

const char* const IPSecondariesConfig::Type = "IP";

SecondaryConfigParser::Configs SecondaryConfigParser::parse_config_file(const boost::filesystem::path& config_file) {
  if (!boost::filesystem::exists(config_file)) {
    throw std::invalid_argument("Specified config file doesn't exist: " + config_file.string());
  }

  auto cfg_file_ext = boost::filesystem::extension(config_file);
  std::unique_ptr<SecondaryConfigParser> cfg_parser;

  if (cfg_file_ext == ".json") {
    cfg_parser = std_::make_unique<JsonConfigParser>(config_file);
  } else {  // add your format of configuration file + implement SecondaryConfigParser specialization
    throw std::invalid_argument("Unsupported type of config format: " + cfg_file_ext);
  }

  return cfg_parser->parse();
}

/*
config file example

{
  "IP": {
                "secondaries_wait_port": 9040,
                "secondaries_wait_timeout": 20,
                "secondaries": [
                        {"addr": "127.0.0.1:9031"}
                        {"addr": "127.0.0.1:9032"}
                ]
  },
  "socketcan": {
                "common-key": "common-value",
                "secondaries": [
                        {"key": "value", "key1": "value1"},
                        {"key": "value", "key1": "value1"}
                ]
  }
}


*/

JsonConfigParser::JsonConfigParser(const boost::filesystem::path& config_file) {
  assert(boost::filesystem::exists(config_file));
  std::ifstream json_file_stream(config_file.string());
  std::string errs;

  if (!Json::parseFromStream(Json::CharReaderBuilder(), json_file_stream, &root_, &errs)) {
    throw std::invalid_argument("Failed to parse secondary config file: " + config_file.string() + ": " + errs);
  }
}

SecondaryConfigParser::Configs JsonConfigParser::parse() {
  Configs res_sec_cfg;

  for (auto it = root_.begin(); it != root_.end(); ++it) {
    std::string secondary_type = it.key().asString();

    if (sec_cfg_factory_registry_.find(secondary_type) == sec_cfg_factory_registry_.end()) {
      LOG_ERROR << "Unsupported type of sescondary config was found: `" << secondary_type
                << "`. Ignoring it and continuing with parsing of other secondary configs";
    } else {
      (sec_cfg_factory_registry_.at(secondary_type))(res_sec_cfg, *it);
    }
  }

  return res_sec_cfg;
}

static std::pair<std::string, uint16_t> getIPAndPort(const std::string& addr) {
  auto del_pos = addr.find_first_of(':');
  if (del_pos == std::string::npos) {
    throw std::invalid_argument("Incorrect address string, couldn't find port delimeter: " + addr);
  }
  std::string ip = addr.substr(0, del_pos);
  uint16_t port = static_cast<uint16_t>(std::stoul(addr.substr(del_pos + 1)));

  return std::make_pair(ip, port);
}

void JsonConfigParser::createIPSecondariesCfg(Configs& configs, const Json::Value& json_ip_sec_cfg) {
  auto resultant_cfg = std::make_shared<IPSecondariesConfig>(
      static_cast<uint16_t>(json_ip_sec_cfg[IPSecondariesConfig::PortField].asUInt()),
      json_ip_sec_cfg[IPSecondariesConfig::TimeoutField].asInt());
  auto secondaries = json_ip_sec_cfg[IPSecondariesConfig::SecondariesField];

  LOG_INFO << "Found IP secondaries config: " << *resultant_cfg;

  for (const auto& secondary : secondaries) {
    auto addr = getIPAndPort(secondary[IPSecondaryConfig::AddrField].asString());
    IPSecondaryConfig sec_cfg{addr.first, addr.second};

    LOG_INFO << "   found IP secondary config: " << sec_cfg;
    resultant_cfg->secondaries_cfg.push_back(sec_cfg);
  }

  configs.push_back(resultant_cfg);
}

void JsonConfigParser::createVirtualSecondariesCfg(Configs& configs, const Json::Value& json_virtual_sec_cfg) {
  for (const auto& json_config : json_virtual_sec_cfg) {
    auto virtual_config = std::make_shared<VirtualSecondaryConfig>(json_config);
    configs.push_back(virtual_config);
  }
}

}  // namespace Primary