catalog.h

Go to the documentation of this file.

 
#pragma once
 
#include <neograph/graph/configuration_failure.h>
#include <neograph/graph/types.h>
#include <neograph/program/activation.h>
#include <neograph/program/admission.h>
#include <neograph/program/migration.h>
#include <neograph/program/module.h>
#include <neograph/program/store.h>
#include <neograph/tool_set.h>
 
#include <asio/awaitable.hpp>
 
#include <functional>
#include <cstddef>
#include <memory>
#include <optional>
#include <stdexcept>
#include <string>
#include <string_view>
#include <vector>
 
namespace neograph::program {
 
namespace detail {
class CatalogRuntimeAccess;
struct MaterializedProgram;
}
 
class ProgramStore;
class RecordedBindingSet;
struct RecordedCapabilityMaterialization;
struct ProgramEvent;
 
struct ProgramAdmission {
    std::string                    owner_scope;
    AdmissionProfile               profile;
    PolicySnapshot                 policy;
    std::vector<DependencyReceipt> dependency_receipts;
};
 
class NEOGRAPH_PROGRAM_API ProgramAdmissionError final : public std::runtime_error,
                                          public graph::ConfigurationFailure {
public:
    explicit ProgramAdmissionError(std::vector<Diagnostic> diagnostics);
 
    const std::vector<Diagnostic>& diagnostics() const noexcept;
 
private:
    std::vector<Diagnostic> diagnostics_;
};
 
class NEOGRAPH_PROGRAM_API EngineGenerationCache {
public:
    EngineGenerationCache();
    EngineGenerationCache(EngineGenerationCache&&) noexcept;
    EngineGenerationCache& operator=(EngineGenerationCache&&) noexcept;
    EngineGenerationCache(const EngineGenerationCache&)            = delete;
    EngineGenerationCache& operator=(const EngineGenerationCache&) = delete;
    ~EngineGenerationCache();
 
private:
    struct Impl;
    std::unique_ptr<Impl> impl_;
 
    friend class ProgramCatalog;
};
 
struct CatalogCapabilityBinding {
    graph::NodeContext                    node_context;
    ToolSet                               tools;
    std::vector<CapabilityBindingReceipt> receipts;
};
 
using CatalogCapabilityBinder =
    std::function<CatalogCapabilityBinding(const std::vector<ExecutableIdentity>&)>;
 
struct CatalogConfig {
    std::shared_ptr<ProgramStore>          program_store;
    RegistrySnapshot                       registry;
    std::shared_ptr<EngineGenerationCache> engines;
    std::string                            compiler_build_id;
    CatalogCapabilityBinder                capability_binder;
    std::size_t                            worker_count = 1;
    std::shared_ptr<const ModuleStore>     module_store;
    std::string                            host_identity;
    std::string                            materialization_context_identity;
    std::function<RecordedCapabilityMaterialization(const ProgramVersion&, const std::vector<ProgramEvent>&)>
        recorded_capability_binder;
    graph::FailureTextRedactor failure_text_redactor;
};
 
class NEOGRAPH_PROGRAM_API ProgramCatalog {
public:
    explicit ProgramCatalog(CatalogConfig config);
    ProgramCatalog(ProgramCatalog&&) noexcept;
    ProgramCatalog& operator=(ProgramCatalog&&) noexcept;
    ProgramCatalog(const ProgramCatalog&)            = delete;
    ProgramCatalog& operator=(const ProgramCatalog&) = delete;
    ~ProgramCatalog();
 
    ProgramVersion                admit(const ProgramBundle& bundle, ProgramAdmission admission);
    ProgramVersion                admit_composed(const ProgramBundle& bundle,
                                                 ProgramAdmission admission,
                                                 const ProgramComposition& composition);
    std::optional<ProgramVersion> find_version(std::string_view id) const;
    std::optional<ProgramVersion> find_version(std::string_view owner_scope,
                                               std::string_view id) const;
    std::optional<ProgramVersion> resolve_version(std::string_view owner_scope,
                                                  std::string_view id);
    std::optional<ProgramVersion> resolve_version_with_binding(
        std::string_view owner_scope, std::string_view id, CatalogCapabilityBinding binding);
 
    MigrationPlan plan_migration(std::string_view owner_scope,
                                 std::string_view source_version_id,
                                 std::string_view target_version_id) const;
    ProgramActivationResult activate(std::string_view owner_scope,
                                     std::string_view version_id,
                                     std::uint64_t expected_generation);
    ProgramActivationResult rollback(std::string_view owner_scope,
                                     std::string_view version_id,
                                     std::uint64_t expected_generation);
    std::optional<ProgramActivation>
    activation(std::string_view owner_scope) const;
    std::optional<ProgramActivationBinding>
    active_binding(std::string_view owner_scope) const;
    ProgramRetentionReport collect_retention(
        std::string_view owner_scope,
        const std::vector<std::string>& pinned_version_ids);
 
    asio::awaitable<ProgramVersion> admit_async(ProgramBundle bundle, ProgramAdmission admission);
    asio::awaitable<ProgramVersion> admit_composed_async(ProgramBundle bundle,
                                                         ProgramAdmission admission,
                                                         ProgramComposition composition);
    asio::awaitable<std::optional<ProgramVersion>> find_version_async(std::string id) const;
    asio::awaitable<std::optional<ProgramVersion>> find_version_async(std::string owner_scope,
                                                                      std::string id) const;
    asio::awaitable<std::optional<ProgramVersion>> resolve_version_async(std::string owner_scope,
                                                                         std::string id);
    asio::awaitable<std::optional<ProgramVersion>> resolve_version_with_binding_async(
        std::string owner_scope, std::string id, CatalogCapabilityBinding binding);
    asio::awaitable<MigrationPlan> plan_migration_async(std::string owner_scope,
                                                        std::string source_version_id,
                                                        std::string target_version_id) const;
    asio::awaitable<ProgramActivationResult> activate_async(std::string owner_scope,
                                                            std::string version_id,
                                                            std::uint64_t expected_generation);
    asio::awaitable<ProgramActivationResult> rollback_async(std::string owner_scope,
                                                            std::string version_id,
                                                            std::uint64_t expected_generation);
    asio::awaitable<std::optional<ProgramActivation>> activation_async(std::string owner_scope) const;
    asio::awaitable<std::optional<ProgramActivationBinding>> active_binding_async(
        std::string owner_scope) const;
    bool completes_inline() const noexcept;
    asio::awaitable<ProgramRetentionReport> collect_retention_async(
        std::string owner_scope, std::vector<std::string> pinned_version_ids);
 
private:
    // The bodies behind the public operations; each is awaited by the awaitable form and run to completion by the
    // synchronous one. Arguments are by value so that nothing dangles across a suspension.
    asio::awaitable<ProgramVersion> materialize_async(
        ProgramBundle bundle, ProgramAdmission admission,
        std::optional<CatalogCapabilityBinding> supplied_binding,
        std::optional<ProgramVersion> expected_version, bool publish,
        ExecutionGuarantee effective_execution_guarantee,
        std::shared_ptr<const detail::MaterializedProgram>* isolated_materialization = nullptr);
    asio::awaitable<std::optional<ProgramVersion>> resolve_version_impl_async(
        std::string owner_scope, std::string id,
        std::optional<CatalogCapabilityBinding> supplied_binding,
        std::shared_ptr<const detail::MaterializedProgram>* isolated_materialization = nullptr);
 
    struct Impl;
    std::unique_ptr<Impl> impl_;
 
    friend class detail::CatalogRuntimeAccess;
};
 
}  // namespace neograph::program