dpSpec.cpp

Go to the documentation of this file.

/**
 * @file
 * @ingroup daq_dpm_libmerge
 * @copyright ESO - European Southern Observatory
 */
#include <daq/json/dpSpec.hpp>
#include <iostream>
 
#include <fmt/format.h>
 
#include <daq/fits/json.hpp>
 
#include "internalParseUtils.hpp"
 
using Json = nlohmann::json;
using JsonPointer = nlohmann::json_pointer<Json>;
 
namespace daq::json {
 
DpSpec::Target ParseTarget(Json const& json, JsonPointer const& breadcrumb) {
    AssertIsObject<DpSpecError>(json, breadcrumb);
    DpSpec::Target obj{};
    obj.file_id = JsonObject<DpSpecError, std::string>::Get(json, "fileId", breadcrumb);
    if (json.contains("source")) {
        obj.source = ParseFitsFileSource(json["source"], breadcrumb / "source");
    }
    if (json.contains("filePrefix")) {
        obj.file_prefix =
            JsonObject<DpSpecError, std::string>::Get(json, "filePrefix", breadcrumb, true);
    }
    return obj;
}
 
DpSpec::SourceTypes ParseSource(Json const& json, JsonPointer const& breadcrumb) {
    AssertIsObject<DpSpecError>(json, breadcrumb);
    auto type = JsonObject<DpSpecError, std::string>::Get(json, "type", breadcrumb);
    if (type == "fitsKeywords") {
        return ParseFitsKeywordsSource(json, breadcrumb);
    } else if (type == "fitsFile") {
        return ParseFitsFileSource(json, breadcrumb);
    } else {
        throw MakeUnknownVariantException<DpSpecError>(
            breadcrumb / "type", "'fitsKeywords' or 'fitsFile'", type.c_str());
    }
}
 
DpSpec ParseDpSpec(Json const& json) {
    try {
        JsonPointer breadcrumb("");
        AssertIsObject<DpSpecError>(json, breadcrumb);
 
        DpSpec spec{};
        spec.id = JsonObject<DpSpecError, std::string>::Get(json, "id", breadcrumb);
        if (!json.contains("target")) {
            throw MakeValueMissingException<DpSpecError>(breadcrumb / "target");
        }
        spec.target = ParseTarget(json["target"], breadcrumb / "target");
 
        if (json.contains("sources")) {
            auto const& json_sources = json["sources"];
            AssertIsArray<DpSpecError>(json_sources, breadcrumb / "sources");
 
            auto index = 0u;
            for (auto const& json_source : json_sources) {
                // cppcheck-suppress zerodiv
                spec.sources.emplace_back(ParseSource(json_source, breadcrumb / "sources" / index));
                index++;
            }
        }
        // Check that there's at least one source
        if (!spec.target.source && spec.sources.empty()) {
            throw MakeParseException<DpSpecError>(
                breadcrumb / "sources",
                "At least one source must be provided if '/target/source' is not used");
        }
        if (json.contains("receivers")) {
            spec.receivers = ParseReceiverList(json["receivers"], breadcrumb / "receivers");
        }
        return spec;
    } catch (DpSpecError const&) {
        throw;
    } catch (SchemaError const& e) {
        std::throw_with_nested(DpSpecError("Schema error"));
    } catch (...) {  // GCOVR_EXCL_START
        std::throw_with_nested(DpSpecError("Unknown parsing error"));
        // GCOVR_EXCL_STOP
    }
}
 
Location ParseSourceLocation(std::string const& location_str) {
    Location location;
    // location str may contain a 'user@' component which we don't care about
    auto start_pos = location_str.find('@');
    if (start_pos == std::string::npos) {
        // no '@' found -> start at 0
        start_pos = 0u;
    } else {
        if (start_pos > location_str.size()) {
            throw std::invalid_argument(
                fmt::format("Invalid format of location string: '{}'", location_str));
        }
        // skip '@' sign
        start_pos++;
    }
 
    auto pos = location_str.find(':', start_pos);
    if (pos != std::string::npos) {
        // Split at 'pos'
        location.host = location_str.substr(start_pos, pos - start_pos);
        location.path = location_str.substr(pos + 1, std::string::npos);
    } else {
        location.path = location_str.substr(start_pos);
    }
    if (location.path.empty()) {
        throw std::invalid_argument(
            fmt::format("Invalid format of location string: '{}'", location_str));
    }
    return location;
}
 
std::string Location::RsyncPath() const {
    if (host.empty()) {
        return path;
    }
    return (host + std::string(":") + path.native());
}
 
// NOLINTNEXTLINE
void to_json(nlohmann::json& j, DpSpec const& s) {
    j = Json{
        {"id", s.id}, {"sources", s.sources}, {"target", s.target}, {"receivers", s.receivers}};
}
 
// NOLINTNEXTLINE
void to_json(nlohmann::json& j, DpSpec::Target const& s) {
    j = Json{{"fileId", s.file_id}, {"filePrefix", s.file_prefix}};
    if (s.source.has_value()) {
        j["source"] = *s.source;
    }
}
 
// NOLINTNEXTLINE
void to_json(nlohmann::json& j, DpSpec::SourceTypes const& s) {
    std::visit([&](auto const& val) { j = Json(val); }, s);
}
 
}  // namespace daq::json