compiler.h

Go to the documentation of this file.

 
#pragma once
 
#include <neograph/api.h>
#include <neograph/graph/loader.h>
#include <neograph/graph/scheduler.h>
#include <neograph/graph/types.h>
 
#include <map>
#include <memory>
#include <optional>
#include <set>
#include <string>
#include <vector>
 
namespace neograph::graph {
 
inline constexpr int TOPOLOGY_SCHEMA_VERSION = 1;
 
class GraphRegistry;
struct NEOGRAPH_API CompilerDiagnostic {
    std::string code;
    std::string json_pointer;
    std::string message;
    json        witness;
};
 
class GraphNode;
 
struct ChannelDef {
    std::string name;
    ReducerType type         = ReducerType::OVERWRITE;
    std::string reducer_name = "overwrite";
    json        initial_value;
    bool has_initial = false;
    ChannelRetentionPolicy   retention = ChannelRetentionPolicy::Unbounded;
    std::uint64_t             retention_limit = 0;
    ChannelPersistencePolicy persistence = ChannelPersistencePolicy::Checkpoint;
};
 
inline constexpr int kMinAttemptTimeoutMs = 100;
inline constexpr int kMaxAttemptTimeoutMs = 3'600'000;
 
struct NodeRetryPolicySpec {
    std::optional<int>       max_retries;         
    std::optional<int>       initial_delay_ms;    
    std::optional<double>    backoff_multiplier;  
    std::optional<int>       max_delay_ms;        
    std::vector<std::string> non_retryable;       
    std::optional<int>       max_visits;          
    std::optional<bool>      error_text;
    std::optional<int>       attempt_timeout_ms;
 
    bool empty() const noexcept {
        return !max_retries && !initial_delay_ms && !backoff_multiplier && !max_delay_ms &&
               non_retryable.empty() && !max_visits && !error_text && !attempt_timeout_ms;
    }
    bool operator==(const NodeRetryPolicySpec&) const = default;
};
 
struct FailureEdge {
    std::string                from;
    std::string                to;
    std::optional<std::string> error_channel;
 
    bool operator==(const FailureEdge&) const = default;
};
 
struct FailureExit {
    std::string code;
 
    bool operator==(const FailureExit&) const = default;
};
 
struct NEOGRAPH_API TopologySpec {
    std::string                  name;
    std::vector<ChannelDef>      channel_defs;
    std::vector<Edge>            edges;
    std::vector<ConditionalEdge> conditional_edges;
    BarrierSpecs                 barrier_specs;
    JoinSpecs                    join_specs;
    std::set<std::string>        interrupt_before;
    std::set<std::string>        interrupt_after;
    std::optional<RetryPolicy>   retry_policy;
    int                          schema_version = 0;
    std::map<std::string, json>  node_defs;
    json                         metadata;
    std::map<std::string, NodeRetryPolicySpec> node_retry_policies;
    std::vector<FailureEdge>                   failure_edges;
    std::map<std::string, FailureExit>         failure_exits;
 
    json to_json() const;
};
struct NEOGRAPH_API ParseReport {
    std::optional<TopologySpec>     topology;
    std::vector<CompilerDiagnostic> diagnostics;
 
    bool        has_errors() const noexcept;
    std::string summary() const;
};
 
struct NEOGRAPH_API RoundTripReport {
    std::vector<CompilerDiagnostic> diagnostics;
 
    bool        has_errors() const noexcept;
    std::string summary() const;
};
 
struct CompiledGraph {
    std::string                                       name;
    std::vector<ChannelDef>                           channel_defs;
    ToolSet                                         tools;
    std::map<std::string, std::unique_ptr<GraphNode>> nodes;
    std::vector<Edge>                                 edges;
    std::vector<ConditionalEdge>                      conditional_edges;
    BarrierSpecs                                      barrier_specs;
    JoinSpecs                                         join_specs;
    std::set<std::string>                             interrupt_before;
    std::set<std::string>                             interrupt_after;
    std::optional<RetryPolicy> retry_policy;
 
    int schema_version = 0;
 
    json metadata;
 
    std::map<std::string, NodeRetryPolicySpec> node_retry_policies;
    std::vector<FailureEdge>                   failure_edges;
    std::map<std::string, FailureExit>         failure_exits;
 
    std::map<std::string, json> node_defs;
 
    NEOGRAPH_API json to_json() const;
 
    NEOGRAPH_API TopologySpec topology() const;
};
 
class NEOGRAPH_API GraphCompiler {
public:
    static TopologySpec parse(const json& definition);
 
    static TopologySpec parse(const json& definition, const GraphRegistry& registry);
 
    static TopologySpec parse_local(const json& definition, const GraphRegistry& registry);
    static ParseReport parse_report(const json& definition, const GraphRegistry& registry);
 
    static ParseReport parse_local_report(const json& definition, const GraphRegistry& registry);
 
    static CompiledGraph link(TopologySpec topology, const NodeContext& default_context);
 
    static CompiledGraph link(TopologySpec         topology,
                              const NodeContext&   default_context,
                              const GraphRegistry& registry);
 
    static CompiledGraph link_local(TopologySpec         topology,
                                    const NodeContext&   default_context,
                                    const GraphRegistry& registry);
 
    static CompiledGraph compile(const json& definition, const NodeContext& default_context);
 
    static CompiledGraph compile(const json&          definition,
                                 const NodeContext&   default_context,
                                 const GraphRegistry& registry);
 
    static CompiledGraph compile_local(const json&          definition,
                                       const NodeContext&   default_context,
                                       const GraphRegistry& registry);
 
    static json canon(const json& definition);
 
    static json upgrade_to_latest(const json& definition);
 
    static void verify_roundtrip(const json& definition, const CompiledGraph& cg);
 
    static void verify_roundtrip(const json& definition, const TopologySpec& topology);
 
    static RoundTripReport verify_roundtrip_report(const json&         definition,
                                                   const TopologySpec& topology);
};
 
}  // namespace neograph::graph