main.cpp

Go to the documentation of this file.

/**
 * @file
 * @ingroup daq_dpm_merge
 * @copyright ESO - European Southern Observatory
 */
#include <filesystem>
#include <fstream>
#include <iostream>
 
#include <boost/program_options.hpp>
#include <fmt/format.h>
#include <log4cplus/configurator.h>
#include <log4cplus/fileappender.h>
#include <log4cplus/logger.h>
#include <log4cplus/loggingmacros.h>
#include <nlohmann/json.hpp>
 
#include <daq/error/report.hpp>
#include <daq/json/dpSpec.hpp>
 
#include "entrypoint.hpp"
#include "sources.hpp"
 
namespace error {
/**
 * Error codes
 */
enum {
    /** Invalid program arguments */
    InvalidProgramArgument = 1,
 
    /** @name DpSpec errors */
    ///@{
    /** Data product specification file not found */
    DpSpecNotFound = 100,
    /** Invalid Data Product Specification JSON  */
    DpSpecInvalidJson = 101,
    /** Invalid Data Product Specification */
    DpSpecInvalid = 102,
    ///@}
 
    /** @name Source errors */
    ///@{
    SourceNotFound = 111,
    ///@}
 
    Unknown = 255,
};
}  // namespace error
 
struct ExitWithErrorCode {
    ExitWithErrorCode(int code) : m_code(code) {
    }
    int GetCode() const {
        return m_code;
    }
 
private:
    int m_code;
};
 
static std::pair<std::string, std::string> CustomParser(std::string const& element) {
    if (element == "-") {
        return std::make_pair("specification-file", "-");
    }
    return {};
}
 
static auto Resolve(std::filesystem::path const& path, std::filesystem::path const& root)
    -> std::filesystem::path {
    if (path.is_relative()) {
        return root / path;
    } else {
        return path;
    }
}
 
static void LogArgs(int argc, char** argv) {
    std::stringstream ss;
    std::for_each(argv, argv + argc, [&](char* arg) {
        if (arg > argv[0]) {
            ss << " " << arg;
        } else {
            ss << arg;
        }
    });
 
    LOG4CPLUS_INFO("daq.dpmmerge",
                   "Started in " << std::filesystem::current_path() << " as: " << ss.str());
}
 
static void InitFileAppender(std::filesystem::path const& path) {
    // Note that PropertyConfigurator::configure() will reset configuration so we avoid doing that.
    using log4cplus::FileAppender;
    using log4cplus::PatternLayout;
    auto appender = log4cplus::SharedAppenderPtr(
        new FileAppender(path.string(), std::ios_base::out | std::ios_base::app));
    appender->setLayout(std::make_unique<PatternLayout>("%D{%Y-%m-%dT%H:%M:%S.%q+0000} %-5p %m%n"));
    log4cplus::Logger::getRoot().addAppender(appender);
}
 
int main(int argc, char** argv) {
    log4cplus::initialize();
    // note: last arg configures so default console appender logs to stderr
    log4cplus::BasicConfigurator config(log4cplus::Logger::getDefaultHierarchy(), true);
    config.configure();
 
    namespace po = boost::program_options;
 
    auto logger = log4cplus::Logger::getInstance("daq.dpmmerge");
 
    const std::string synopsis("daqDpmMerge [options] <specification-file>");
 
    po::positional_options_description positional;
    positional.add("specification-file", 1);
 
    std::string spec_file;
    po::options_description options(synopsis);
    // clang-format off
    options.add_options()
        ("help,h",
         "produce help message (also use this option for each command to get relevant help)")
        ("version",
         "print version")
        ("root",
         po::value<std::string>(),
         "specifies root directory from which relative source file paths in specification-file will"
         " be resolved as well as the default output directory. If not specified it will use the "
         "root of the specification-file file or if "
         "specification-file is not a regular file it will use current working directory.")
        ("outfile,o",
         po::value<std::string>(),
         "FITS output file name, e.g. `-o myfits.fits`. By default the output name will be "
         "derived using the specification-file `fileId` property: `<fileId>.fits`. "
         "Relative paths are relative the root directory.")
        ("resolver",
         po::value<std::string>(),
         "specifies optional FITS source resolver which resolves location of input FITS files "
         "to their location on this host. If specification references FITS files this must be "
         "provided.")
        ("json",
         "output status messages to standard out in JSON format")
        ("logfile,l",
         po::value<std::string>(),
         "Write log output, in addition to the console, to the specified file.")
        ("dry-run",
         "skips operations with visible side-effects, useful for validating inputs")
          ;
    po::options_description hidden("Hidden options");
    hidden.add_options()
        ("specification-file", po::value<std::string>(&spec_file), "input file")
    ;
    // clang-format on
 
    po::options_description all("All");
    all.add(options).add(hidden);
 
    po::variables_map vm;
    try {
        auto parsed = po::command_line_parser(argc, argv)
                          .options(all)
                          .positional(positional)
                          .extra_parser(CustomParser)
                          .run();
        po::store(parsed, vm);
        if (vm.count("help")) {
            std::cerr << options << '\n';
            return 0;
        }
        if (vm.count("version")) {
            std::cerr << "daqDpmMerge " << VERSION
#if defined(DEBUG)
                      << " (debug build)"
#endif
                      << '\n';
            return 0;
        }
        // Both positional and hidden option --specification-file ends up in "specification-file"
        // in vm variables_map.
        if (!vm.count("specification-file")) {
            std::cerr << "argument error: specification-file not provided\n";
            return error::InvalidProgramArgument;
        } else {
            spec_file = vm["specification-file"].as<std::string>();
        }
 
        // Determine root path
        auto root_arg = vm.count("root") ? vm["root"].as<std::string>() : std::string();
        auto root_path = std::filesystem::path();
        if (!root_arg.empty()) {
            // If explicitly specified, use that argument.
            root_path =
                std::filesystem::path(root_arg, std::filesystem::path::format::native_format);
            if (!std::filesystem::is_directory(root_path)) {
                std::cerr << "argument error: --root argument \"" << root_arg
                          << "\" is not a valid directory\n";
                return error::InvalidProgramArgument;
            }
        } else if (std::filesystem::is_regular_file(spec_file)) {
            // For regular files we fall back to using the directory containing the input file
            root_path = std::filesystem::path(spec_file).parent_path();
        } else {
            // As a last fallback we use current working directory.
            root_path = std::filesystem::current_path();
        }
 
        auto log_file = vm.count("logfile") ? vm["logfile"].as<std::string>() : std::string();
        if (!log_file.empty()) {
            // Configure logger to file
            auto log_path = Resolve(std::filesystem::path(log_file), root_path);
            InitFileAppender(log_path);
        }
 
        // Optional output filename
        std::optional<std::filesystem::path> out_path;
        if (vm.count("outfile")) {
            auto out = Resolve(std::filesystem::path(vm["outfile"].as<std::string>()), root_path);
            ;
            if (std::filesystem::exists(out)) {
                std::cerr << "argument error: --outfile argument " << out << " exists\n";
                return error::InvalidProgramArgument;
            }
            out_path = out;
        }
 
        // Optional source resolver
        daq::dpm::SourceResolver resolver;
        if (vm.count("resolver")) {
            auto resolver_path =
                Resolve(std::filesystem::path(vm["resolver"].as<std::string>()), root_path);
            if (!std::filesystem::exists(resolver_path)) {
                std::cerr << "argument error: --resolver argument " << resolver_path
                          << " not found\n";
                return error::InvalidProgramArgument;
            }
            std::ifstream file(resolver_path);
            if (file.fail()) {
                std::cerr << "error: failed to open specification with path '" << resolver_path
                          << '\n';
                return error::InvalidProgramArgument;
            }
            auto json = nlohmann::json::parse(file);
            resolver.SetMapping(json.get<daq::dpm::SourceResolver::Mapping>());
        }
 
        // Load JSON
        nlohmann::json json_spec;
        if (spec_file == "-") {
            // Read from stdin
            json_spec = nlohmann::json::parse(std::cin);
        } else {
            // Read from file
            std::ifstream file(spec_file);
            if (file.fail()) {
                std::cerr << "error: failed to open specification with path '" << spec_file << '\n';
                return error::DpSpecNotFound;
            }
            json_spec = nlohmann::json::parse(file);
        }
 
        auto use_json = vm.count("json");
        auto dry_run = vm.count("dry-run");
        // At this point we have the parsed specification and all arguments.
        // So let's merge...
        try {
            auto dp_spec = daq::json::ParseDpSpec(json_spec);
            LogArgs(argc, argv);
            return daq::dpm::merge::Entrypoint(
                root_path, out_path, dp_spec, resolver, dry_run, use_json);
        } catch (daq::dpm::SourceNotFound const& e) {
            std::throw_with_nested(ExitWithErrorCode(error::SourceNotFound));
        } catch (daq::dpm::merge::SourceNotFoundError const& e) {
            std::throw_with_nested(ExitWithErrorCode(error::SourceNotFound));
        } catch (daq::json::DpSpecError const&) {
            std::throw_with_nested(daq::json::DpSpecError(
                fmt::format("Failed to parse Data Product Specification '{}'", spec_file)));
        }
    } catch (ExitWithErrorCode const& e) {
        daq::error::ReportNestedExceptions(std::cerr);
        return e.GetCode();
    } catch (po::error const& e) {
        daq::error::ReportNestedExceptions(std::cerr, e);
        return error::InvalidProgramArgument;
    } catch (nlohmann::json::parse_error const& e) {
        std::cerr << "error: json parsing failed: " << e.what() << '\n';
        return error::DpSpecInvalidJson;
    } catch (nlohmann::json::exception const& e) {
        std::cerr << "error: json error: " << e.what() << '\n';
        return error::DpSpecInvalidJson;
    } catch (daq::json::DpSpecError const& e) {
        daq::error::ReportNestedExceptions(std::cerr, e);
        return error::DpSpecInvalid;
    } catch (std::exception const& e) {
        daq::error::ReportNestedExceptions(std::cerr, e);
    }
    return error::Unknown;
}