invocation.h

Go to the documentation of this file.

 
#pragma once
 
#include <neograph/api.h>
#include <neograph/graph/execution.h>
 
#include <asio/awaitable.hpp>
 
#include <atomic>
#include <cstdint>
#include <exception>
#include <memory>
#include <optional>
#include <string>
#include <string_view>
 
namespace neograph::graph {
 
enum class InvocationStatus : std::uint8_t {
    Completed   = 0,
    Interrupted = 1,
    MaxSteps    = 2,
    Cancelled   = 3,
    Error       = 4,
    SafePoint   = 5,
};
 
NEOGRAPH_API std::string_view to_string(InvocationStatus status) noexcept;
 
struct RunInvocationRequest {
    RunConfig          config;
    RunMetadata        metadata;
    RunResources       resources;
    GraphStreamCallback on_event;
};
 
struct InvocationResult {
    InvocationStatus status = InvocationStatus::Error;
    std::optional<RunResult> run_result;
    std::string error;
    std::optional<FailureVerdict> failure;
 
    bool succeeded() const noexcept {
        return status == InvocationStatus::Completed ||
               status == InvocationStatus::Interrupted ||
               status == InvocationStatus::MaxSteps ||
               status == InvocationStatus::SafePoint;
    }
    bool cancelled() const noexcept { return status == InvocationStatus::Cancelled; }
};
 
class NEOGRAPH_API RunInvocation final {
public:
    RunInvocation(GraphExecution execution, RunInvocationRequest request);
    RunInvocation(std::shared_ptr<GraphEngine> engine, RunInvocationRequest request);
 
    RunInvocation(const RunInvocation&) = delete;
    RunInvocation& operator=(const RunInvocation&) = delete;
    RunInvocation(RunInvocation&&) = delete;
    RunInvocation& operator=(RunInvocation&&) = delete;
    ~RunInvocation() = default;
 
    const RunInvocationRequest& request() const noexcept { return request_; }
    std::shared_ptr<CancelToken> cancel_token() const noexcept { return token_; }
    void cancel() noexcept { token_->cancel(); }
 
    InvocationResult run();
    asio::awaitable<InvocationResult> run_async();
 
    InvocationResult resume(json resume_value = {});
    asio::awaitable<InvocationResult> resume_async(json resume_value = {});
 
    InvocationResult resume_from(std::string checkpoint_id,
                                 json resume_value = {});
    asio::awaitable<InvocationResult> resume_from_async(
        std::string checkpoint_id, json resume_value = {});
 
private:
    GraphExecution execution_;
    RunInvocationRequest request_;
    std::shared_ptr<CancelToken> token_;
    std::atomic_bool started_{false};
 
    void validate_request() const;
    bool try_start() noexcept;
    InvocationResult failure(std::string message) const;
    static InvocationResult classify(RunResult result);
    static InvocationResult classify_exception(std::exception_ptr error,
                                               bool cancelled);
};
 
}  // namespace neograph::graph