dpSpec.cpp

Go to the documentation of this file.

/**
 * @file
 * @ingroup daq_dpm_libmerge
 * @copyright ESO - European Southern Observatory
 */
#include <daq/dpSpec.hpp>
 
#include <fmt/format.h>
 
#include <daq/fits/json.hpp>
#include <iostream>
 
using Json = nlohmann::json;
using JsonPointer = nlohmann::json_pointer<Json>;
 
namespace daq {
 
template <class... Args>
DpSpecError MakeParseException(JsonPointer const& ptr, Args&&... args) {
    return DpSpecError(
        (fmt::format("({}) {}", ptr.to_string(), fmt::format(std::forward<Args>(args)...)))
            .c_str());
}
 
template <char const*>
DpSpecError MakeParseException(JsonPointer const& ptr, char const* str) {
    return DpSpecError(fmt::format("({}) {}", ptr.to_string(), str).c_str());
}
 
DpSpecError MakeValueMissingException(JsonPointer const& ptr) {
    return DpSpecError(fmt::format("({}) {}", ptr.to_string(), "mandatory value missing").c_str());
}
 
DpSpecError
MakeWrongTypeException(JsonPointer const& ptr, char const* expected_type, char const* actual_type) {
    return DpSpecError(
        fmt::format("({}) {}",
                    ptr.to_string(),
                    fmt::format("must be a {}, but is {}", expected_type, actual_type))
            .c_str());
}
 
DpSpecError MakeUnknownVariantException(JsonPointer const& ptr,
                                        char const* known_variants,
                                        char const* actual_variant) {
    return DpSpecError(
        fmt::format("({}) {}",
                    ptr.to_string(),
                    fmt::format("must be one of {}, but is '{}'", known_variants, actual_variant))
            .c_str());
}
 
template <class T>
T GetMember(Json const& json,
            char const* name,
            JsonPointer const& breadcrumb,
            bool allow_empty = true);
 
template <>
std::string GetMember<std::string>(Json const& json,
                                   char const* name,
                                   JsonPointer const& breadcrumb,
                                   bool allow_empty) {
    if (!json.contains(name)) {
        throw MakeValueMissingException(breadcrumb / name);
    }
    auto const& value_json = json[name];
    if (!value_json.is_string()) {
        throw MakeWrongTypeException(breadcrumb / name, "string", value_json.type_name());
    }
    auto value = value_json.get<std::string>();
    if (value.empty() && !allow_empty) {
        throw MakeParseException(breadcrumb / name, "empty string is invalid");
    }
    return value;
}
 
void AssertIsObject(Json const& json, JsonPointer const& breadcrumb) {
    if (!json.is_object()) {
        throw MakeWrongTypeException(breadcrumb, "object", json.type_name());
    }
}
 
void AssertIsArray(Json const& json, JsonPointer const& breadcrumb) {
    if (!json.is_array()) {
        throw MakeWrongTypeException(breadcrumb, "array", json.type_name());
    }
}
 
std::vector<std::string> ParseArrayOfString(Json const& json, JsonPointer const& breadcrumb) {
    AssertIsArray(json, breadcrumb);
    std::vector<std::string> result;
    auto index = 0u;
    for (auto const& value_json : json) {
        if (!value_json.is_string()) {
            throw MakeWrongTypeException(breadcrumb / index, "string", value_json.type_name());
        }
        auto value = value_json.get<std::string>();
        if (value.empty()) {
            throw MakeParseException(breadcrumb / index, "empty string is invalid");
        }
        result.emplace_back(std::move(value));
        index++;
    }
    return result;
}
 
DpSpec::Filter ParseFilter(Json const& json, JsonPointer const& breadcrumb) {
    AssertIsObject(json, breadcrumb);
    if (!json.contains("selectionPatterns")) {
        throw MakeValueMissingException(breadcrumb / "selectionPatterns");
    }
    DpSpec::Filter filter;
    filter.selection_patterns =
        ParseArrayOfString(json["selectionPatterns"], breadcrumb / "selectionPatterns");
    return filter;
}
 
DpSpec::Transform ParseTransform(Json const& json, JsonPointer const& breadcrumb) {
    AssertIsObject(json, breadcrumb);
    if (!json.contains("selectionPatterns")) {
        throw MakeValueMissingException(breadcrumb / "selectionPatterns");
    }
    DpSpec::Transform transform;
    transform.selection_patterns =
        ParseArrayOfString(json["selectionPatterns"], breadcrumb / "selectionPatterns");
    transform.regex = GetMember<std::string>(json, "regex", breadcrumb);
    transform.format = GetMember<std::string>(json, "format", breadcrumb);
    return transform;
}
 
DpSpec::KeywordRules ParseKeywordRules(Json const& json, JsonPointer const& breadcrumb) {
    AssertIsArray(json, breadcrumb);
    DpSpec::KeywordRules result;
    auto index = 0u;
    for (auto const& json_element : json) {
        auto type = GetMember<std::string>(json_element, "type", breadcrumb);
        if (type == "filter") {
            result.emplace_back(ParseFilter(json_element, breadcrumb));
        } else if (type == "transform") {
            result.emplace_back(ParseTransform(json_element, breadcrumb));
        } else {
            throw MakeUnknownVariantException(
                breadcrumb / "type", "'filter' or 'transform'", type.c_str());
        }
        index++;
    }
    return result;
}
 
DpSpec::SourceFitsKeywords
ParseSourceFitsKeywords(Json const& json, JsonPointer const& breadcrumb) {
    AssertIsObject(json, breadcrumb);
    DpSpec::SourceFitsKeywords obj;
    obj.source_name = GetMember<std::string>(json, "sourceName", breadcrumb);
    // Optional keywordRules
    if (json.contains("keywordRules")) {
        obj.keyword_rules = ParseKeywordRules(json["keywordRules"], breadcrumb / "keywordRules");
    }
    if (!json.contains("keywords")) {
        throw MakeValueMissingException(breadcrumb / "keywords");
    }
    try {
        auto keywords = fits::ParseJsonKeywords(json["keywords"], breadcrumb / "keywords");
        obj.keywords = std::move(keywords);
        return obj;
    } catch (std::exception const& err) {
        std::throw_with_nested(
            MakeParseException(breadcrumb / "keywords", "failed to parse keywords"));
    }
}
 
DpSpec::SourceFitsFile ParseSourceFitsFile(Json const& json, JsonPointer const& breadcrumb) {
    AssertIsObject(json, breadcrumb);
    DpSpec::SourceFitsFile obj;
    obj.source_name = GetMember<std::string>(json, "sourceName", breadcrumb);
    obj.origin = GetMember<std::string>(json, "origin", breadcrumb);
    // Optional keywordRules
    if (json.contains("keywordRules")) {
        obj.keyword_rules = ParseKeywordRules(json["keywordRules"], breadcrumb / "keywordRules");
    }
    return obj;
}
 
DpSpec::Target ParseTarget(Json const& json, JsonPointer const& breadcrumb) {
    AssertIsObject(json, breadcrumb);
    DpSpec::Target obj{};
    obj.file_id = GetMember<std::string>(json, "fileId", breadcrumb);
    if (json.contains("source")) {
        obj.source = ParseSourceFitsFile(json["source"], breadcrumb / "source");
    }
    if (json.contains("filePrefix")) {
        obj.file_prefix = GetMember<std::string>(json, "filePrefix", breadcrumb, true);
    }
    return obj;
}
 
DpSpec::SourceTypes ParseSource(Json const& json, JsonPointer const& breadcrumb) {
    AssertIsObject(json, breadcrumb);
    auto type = GetMember<std::string>(json, "type", breadcrumb);
    if (type == "fitsKeywords") {
        return ParseSourceFitsKeywords(json, breadcrumb);
    } else if (type == "fitsFile") {
        return ParseSourceFitsFile(json, breadcrumb);
    } else {
        throw MakeUnknownVariantException(
            breadcrumb / "type", "'fitsKeywords' or 'fitsFile'", type.c_str());
    }
}
 
DpSpec ParseDpSpec(Json const& json) {
    try {
        JsonPointer breadcrumb("");
        AssertIsObject(json, breadcrumb);
 
        DpSpec spec{};
        spec.id = GetMember<std::string>(json, "id", breadcrumb);
        if (!json.contains("target")) {
            throw MakeValueMissingException(breadcrumb / "target");
        }
        spec.target = ParseTarget(json["target"], breadcrumb / "target");
 
        if (json.contains("sources")) {
            auto const& json_sources = json["sources"];
            if (!json_sources.is_array()) {
                throw MakeWrongTypeException(
                    breadcrumb / "sources", "array", json_sources.type_name());
            }
 
            auto index = 0u;
            for (auto const& json_source : json_sources) {
                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(
                breadcrumb / "sources",
                "At least one source must be provided if '/target/source' is not used");
        }
        return spec;
    } catch (DpSpecError const&) {
        throw;
    } catch (...) {  // GCOVR_EXCL_START
        std::throw_with_nested(DpSpecError("Unknown parsing error"));
        // GCOVR_EXCL_STOP
    }
}
 
Origin ParseSourceOrigin(std::string const& origin_str) {
    Origin origin;
    // origin str may contain a 'user@' component which we don't care about
    auto start_pos = origin_str.find('@');
    if (start_pos == std::string::npos) {
        // no '@' found -> start at 0
        start_pos = 0u;
    } else {
        if (start_pos > origin_str.size()) {
            throw std::invalid_argument(
                fmt::format("Invalid format of origin string: '{}'", origin_str));
        }
        // skip '@' sign
        start_pos++;
    }
 
    auto pos = origin_str.find(':', start_pos);
    if (pos != std::string::npos) {
        // Split at 'pos'
        origin.host = origin_str.substr(start_pos, pos - start_pos);
        origin.path = origin_str.substr(pos + 1, std::string::npos);
    } else {
        origin.path = origin_str.substr(start_pos);
    }
    if (origin.path.empty()) {
        throw std::invalid_argument(
            fmt::format("Invalid format of origin string: '{}'", origin_str));
    }
    return origin;
}
 
std::string Origin::RsyncPath() const {
    if (host.empty()) {
        return path;
    }
    return (host + std::string(":") + path.native());
}
 
}  // namespace daq