artifact_provider.h

Go to the documentation of this file.

 
#pragma once
 
#include <neograph/api.h>
#include <neograph/graph/cancel.h>
#include <neograph/json.h>
 
#include <asio/awaitable.hpp>
 
#include <chrono>
#include <cstdint>
#include <functional>
#include <memory>
#include <optional>
#include <string>
#include <string_view>
#include <vector>
 
namespace neograph {
 
enum class ArtifactExecutionMode : std::uint8_t {
    OneShot,
    Stream,
    LongRunning,
};
 
NEOGRAPH_API std::string_view to_string(ArtifactExecutionMode mode) noexcept;
 
enum class ArtifactOperationStatus : std::uint8_t {
    Queued,
    Running,
    Succeeded,
    Failed,
    Cancelled,
    TimedOut,
};
 
NEOGRAPH_API std::string_view to_string(ArtifactOperationStatus status) noexcept;
 
struct NEOGRAPH_API Artifact {
    std::string   identity;
    std::string   uri;
    std::string   media_type;
    std::uint64_t size_bytes = 0;
    json          metadata = json::object();
 
    bool operator==(const Artifact&) const = default;
};
 
enum class ArtifactEventKind : std::uint8_t {
    Progress,
    Artifact,
    State,
};
 
NEOGRAPH_API std::string_view to_string(ArtifactEventKind kind) noexcept;
 
struct NEOGRAPH_API ArtifactEvent {
    ArtifactEventKind        kind = ArtifactEventKind::Progress;
    std::string              operation_id;
    std::uint64_t            sequence = 0;
    std::optional<Artifact>  artifact;
    json                     data = json::object();
 
    bool operator==(const ArtifactEvent&) const = default;
};
 
struct NEOGRAPH_API ArtifactPollPolicy {
    std::uint32_t             max_attempts = 60;
    std::chrono::milliseconds interval{1000};
 
    bool operator==(const ArtifactPollPolicy&) const = default;
};
 
struct NEOGRAPH_API ArtifactRequest {
    std::string                         operation;
    json                                input = json::object();
    std::string                         idempotency_key;
    ArtifactExecutionMode               mode = ArtifactExecutionMode::OneShot;
    ArtifactPollPolicy                  poll;
    std::shared_ptr<graph::CancelToken> cancel_token;
};
 
struct NEOGRAPH_API ArtifactOperation {
    std::string                   id;
    ArtifactOperationStatus       status = ArtifactOperationStatus::Queued;
    std::vector<Artifact>         artifacts;
    json                          output = json::object();
    std::string                   error_code;
    std::string                   error_message;
 
    [[nodiscard]] bool terminal() const noexcept;
    [[nodiscard]] bool succeeded() const noexcept;
    [[nodiscard]] bool failed() const noexcept;
};
 
using ArtifactEventCallback = std::function<void(const ArtifactEvent&)>;
 
NEOGRAPH_API void to_json(json& value, const Artifact& artifact);
NEOGRAPH_API void from_json(const json& value, Artifact& artifact);
 
class NEOGRAPH_API ArtifactProvider {
  public:
    virtual ~ArtifactProvider();
 
    ArtifactProvider(const ArtifactProvider&) = delete;
    ArtifactProvider& operator=(const ArtifactProvider&) = delete;
    ArtifactProvider(ArtifactProvider&&) = delete;
    ArtifactProvider& operator=(ArtifactProvider&&) = delete;
 
    ArtifactOperation execute(ArtifactRequest request,
                              ArtifactEventCallback on_event = {});
 
    asio::awaitable<ArtifactOperation>
    execute_async(ArtifactRequest request,
                  ArtifactEventCallback on_event = {});
 
    virtual std::string get_name() const = 0;
 
  protected:
    ArtifactProvider() = default;
 
    virtual asio::awaitable<ArtifactOperation>
    do_start(ArtifactRequest request, ArtifactEventCallback on_event) = 0;
 
    virtual asio::awaitable<ArtifactOperation>
    do_poll(ArtifactOperation operation) = 0;
 
  private:
    asio::awaitable<ArtifactOperation>
    execute_unbound(ArtifactRequest request, ArtifactEventCallback on_event);
};
 
} // namespace neograph