main.cpp

Go to the documentation of this file.

// 5G-MAG Reference Tools
// MBMS Middleware Process
//
// Copyright (C) 2021 Klaus Kühnhammer (Österreichische Rundfunksender GmbH & Co KG)
//
// Licensed under the License terms and conditions for use, reproduction, and
// distribution of 5G-MAG software (the “License”).  You may not use this file
// except in compliance with the License.  You may obtain a copy of the License at
// https://www.5g-mag.com/reference-tools.  Unless required by applicable law or
// agreed to in writing, software distributed under the License is distributed on
// an “AS IS” BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
// or implied.
// 
// See the License for the specific language governing permissions and limitations
// under the License.
//
 
#include <argp.h>
 
#include <cstdlib>
#include <string>
#include <filesystem>
#include <libconfig.h++>
#include <boost/asio.hpp>
 
#include "Version.h"
 
#include "spdlog/async.h"
#include "spdlog/spdlog.h"
#include "spdlog/sinks/syslog_sink.h"
 
#include "Middleware.h"
 
using libconfig::Config;
using libconfig::FileIOException;
using libconfig::ParseException;
 
using std::placeholders::_1;
using std::placeholders::_2;
using std::placeholders::_3;
 
static void print_version(FILE *stream, struct argp_state *state);
void (*argp_program_version_hook)(FILE *, struct argp_state *) = print_version;
const char *argp_program_bug_address = "5G-MAG Reference Tools <reference-tools@5g-mag.com>";
static char doc[] = "5G-MAG-RT MBMS Middleware Process";  // NOLINT
 
static struct argp_option options[] = {  // NOLINT
    {"config", 'c', "FILE", 0, "Configuration file (default: /etc/5gmag-rt.conf)", 0},
    {"interface", 'i', "IF", 0, "IP address of the interface to bind flute receivers to (default: 192.168.180.10)", 0},
    {"log-level", 'l', "LEVEL", 0,
     "Log verbosity: 0 = trace, 1 = debug, 2 = info, 3 = warn, 4 = error, 5 = "
     "critical, 6 = none. Default: 2.",
     0},
    {nullptr, 0, nullptr, 0, nullptr, 0}};
 
struct mw_arguments {
  const char *config_file = {};  
  const char *flute_interface = {};  
  unsigned log_level = 2;        
};
 
static auto parse_opt(int key, char *arg, struct argp_state *state) -> error_t {
  auto arguments = static_cast<struct mw_arguments *>(state->input);
  switch (key) {
    case 'c':
      arguments->config_file = arg;
      break;
    case 'i':
      arguments->flute_interface = arg;
      break;
    case 'l':
      arguments->log_level = static_cast<unsigned>(strtoul(arg, nullptr, 10));
      break;
    default:
      return ARGP_ERR_UNKNOWN;
  }
  return 0;
}
 
static struct argp argp = {options, parse_opt, nullptr, doc,
                           nullptr, nullptr,   nullptr};
 
void print_version(FILE *stream, struct argp_state * /*state*/) {
  fprintf(stream, "%s.%s.%s\n", std::to_string(VERSION_MAJOR).c_str(),
          std::to_string(VERSION_MINOR).c_str(),
          std::to_string(VERSION_PATCH).c_str());
}
 
 
 
static Config cfg;  
auto main(int argc, char **argv) -> int {
  struct mw_arguments arguments;
  /* Default values */
  arguments.config_file = "/etc/5gmag-rt.conf";
  arguments.flute_interface= "0.0.0.0";
 
  argp_parse(&argp, argc, argv, 0, nullptr, &arguments);
 
  // Read and parse the configuration file
  try {
    cfg.readFile(arguments.config_file);
  } catch(const FileIOException &fioex) {
    spdlog::error("I/O error while reading config file at {}. Exiting.", arguments.config_file);
    exit(1);
  } catch(const ParseException &pex) {
    spdlog::error("Config parse error at {}:{} - {}. Exiting.",
        pex.getFile(), pex.getLine(), pex.getError());
    exit(1);
  }
 
  // Set up logging
  std::string ident = "mw";
  auto syslog_logger = spdlog::syslog_logger_mt("syslog", ident, LOG_PID | LOG_PERROR | LOG_CONS );
 
  spdlog::set_level(
      static_cast<spdlog::level::level_enum>(arguments.log_level));
  spdlog::set_pattern("[%H:%M:%S.%f %z] [%^%l%$] [thr %t] %v");
 
  spdlog::set_default_logger(syslog_logger);
  spdlog::info("5g-mag-rt mw v{}.{}.{} starting up", VERSION_MAJOR, VERSION_MINOR, VERSION_PATCH);
 
  std::string uri = "http://0.0.0.0:3020/";
  cfg.lookupValue("mw.http_server.uri", uri);
 
  try {
    boost::asio::io_service io;
    MBMS_RT::Middleware mw(io, cfg, uri, arguments.flute_interface);
    io.run();
  } catch (const std::exception& ex) {
    spdlog::error("BUG ALERT: Unhandled exception in main: {}", ex.what());
  }
 
exit:
  return 0;
}