migration.h

Go to the documentation of this file.

 
#pragma once
 
#include <neograph/api.h>
#include <neograph/program/version.h>
 
#include <cstdint>
#include <memory>
#include <optional>
#include <string>
#include <string_view>
#include <vector>
 
namespace neograph::program {
 
enum class StoredArtifactClassification : std::uint8_t {
    Translated,
    DrainOnly,
    Rejected,
};
 
enum class StoredArtifactKind : std::uint8_t {
    LegacyCoreDefinition,
    LegacyProgramVersion,
};
 
struct StoredArtifactClassificationRule {
    StoredArtifactClassification classification = StoredArtifactClassification::Rejected;
    bool                        allows_new_publication = false;
    bool                        allows_new_run         = false;
    bool                        requires_legacy_runtime = false;
    std::string                 diagnostic_code;
    StoredArtifactKind           kind = StoredArtifactKind::LegacyCoreDefinition;
 
    bool operator==(const StoredArtifactClassificationRule&) const = default;
};
 
NEOGRAPH_PROGRAM_API void to_json(json& value, const StoredArtifactClassificationRule& rule);
NEOGRAPH_PROGRAM_API void from_json(const json& value, StoredArtifactClassificationRule& rule);
NEOGRAPH_PROGRAM_API std::string_view to_string(
    StoredArtifactClassification classification) noexcept;
NEOGRAPH_PROGRAM_API StoredArtifactClassification stored_artifact_classification_from_string(
    std::string_view value);
NEOGRAPH_PROGRAM_API std::string_view to_string(StoredArtifactKind kind) noexcept;
NEOGRAPH_PROGRAM_API StoredArtifactKind stored_artifact_kind_from_string(std::string_view value);
 
enum class MigrationCompatibility : std::uint8_t {
    NewRunsOnly,
    ForkCompatible,
    DrainOnly,
    OperatorReconciliation,
    Blocked,
 
    // Source-compatible names retained for callers of the early P4 API.  A
    // mismatch is fail-closed and therefore maps to Blocked.
    Compatible             = ForkCompatible,
    OwnerMismatch           = 5,
    CompilerMismatch        = 6,
    RegistryMismatch        = 7,
    MaterializationMismatch = 8,
};
 
enum class MigrationDimension : std::uint8_t {
    Channels,
    Continuation,
    PendingInput,
    PendingEffect,
    Retry,
    Cancellation,
    Interrupt,
    Budget,
    Authority,
    Checkpoint,
    Journal,
    Effects,
    Caches,
    Output,
    Compiler,
    Registry,
    Materialization,
    Contract,
    Recovery,
    Schema,
    Reducers,
    Barriers,
    PendingWork,
    PendingEvents,
    Subscriptions,
    Resume,
    NodeLocal,
    Reconciliation,
    TerminalOutput,
    CheckpointLineage,
};
 
struct MigrationDiagnostic {
    MigrationDimension dimension = MigrationDimension::Continuation;
    std::string        code;
    std::string        message;
    json               source = json::object();
    json               target = json::object();
 
    bool operator==(const MigrationDiagnostic&) const;
};
 
struct MigrationMapping {
    MigrationDimension dimension = MigrationDimension::Continuation;
    std::string        rule;
    json               source = json::object();
    json               target = json::object();
 
    bool operator==(const MigrationMapping&) const;
};
 
using MigrationCompatibilityDiagnostic = MigrationDiagnostic;
using MigrationCompatibilityClass = MigrationCompatibility;
using MigrationAspect = MigrationDimension;
 
struct MigrationPlanData {
    std::string              source_version_id;
    std::string              target_version_id;
    std::string              owner_scope;
    MigrationCompatibility   compatibility = MigrationCompatibility::Compatible;
    std::vector<std::string> blockers;
    std::vector<MigrationDiagnostic> diagnostics;
    std::vector<MigrationMapping>    mappings;
};
class NEOGRAPH_PROGRAM_API MigrationPlan final {
public:
    static constexpr std::uint32_t STORAGE_SCHEMA_VERSION = 2;
    static constexpr std::uint32_t PREVIOUS_STORAGE_SCHEMA_VERSION = 1;
    static constexpr std::uint32_t LEGACY_STORAGE_SCHEMA_VERSION = 0;
    static MigrationPlan create(MigrationPlanData data);
    static MigrationPlan between(const ProgramVersion& source, const ProgramVersion& target);
    static MigrationPlan between(const ProgramVersion& source,
                                 const ProgramBundle&  source_bundle,
                                 const ProgramVersion& target,
                                 const ProgramBundle&  target_bundle);
    static MigrationPlan parse(std::string_view stored_bytes);
 
    const std::string& source_version_id() const noexcept;
    const std::string& target_version_id() const noexcept;
    const std::string& owner_scope() const noexcept;
    MigrationCompatibility compatibility() const noexcept;
    const std::vector<std::string>& blockers() const noexcept;
    const std::vector<MigrationDiagnostic>& diagnostics() const noexcept;
    const std::vector<MigrationMapping>& mappings() const noexcept;
    bool is_compatible() const noexcept;
    bool semantically_matches(const MigrationPlan& expected) const noexcept;
    const std::string& id() const noexcept;
    std::string serialize_canonical() const;
 
private:
    struct Impl;
    explicit MigrationPlan(std::shared_ptr<const Impl> impl);
    std::shared_ptr<const Impl> impl_;
};
 
NEOGRAPH_PROGRAM_API std::string_view to_string(MigrationCompatibility compatibility) noexcept;
NEOGRAPH_PROGRAM_API MigrationCompatibility migration_compatibility_from_string(std::string_view value);
NEOGRAPH_PROGRAM_API std::string_view to_string(MigrationDimension dimension) noexcept;
NEOGRAPH_PROGRAM_API MigrationDimension migration_dimension_from_string(std::string_view value);
 
}  // namespace neograph::program