control_client.hpp

Go to the documentation of this file.

#pragma once
 
#include <pulp/inspect/control_artifacts.hpp>
#include <pulp/inspect/control_protocol.hpp>
 
#include <chrono>
#include <cstddef>
#include <cstdint>
#include <optional>
#include <string>
#include <string_view>
 
namespace pulp::inspect {
 
struct ControlTransportDispatchResult {
    std::optional<std::string> encoded_response;
    std::string error_code;
    std::string explanation;
 
    bool succeeded() const {
        return encoded_response.has_value();
    }
};

class ControlClientTransport {
  public:
    virtual ~ControlClientTransport() = default;
 
    virtual ControlTransportDispatchResult dispatch(std::string_view encoded_envelope,
                                                    std::chrono::milliseconds timeout) = 0;
    virtual ControlArtifactReadResult read_artifact(std::string_view artifact_id,
                                                    std::uint64_t offset, std::size_t maximum_bytes,
                                                    std::chrono::milliseconds timeout) = 0;
};
 
template <typename Response> struct ControlDispatchResult {
    std::optional<Response> response;
    std::string error_code;
    std::string explanation;
 
    bool succeeded() const {
        return response.has_value();
    }
};
 
using ControlClientNegotiationResult = ControlDispatchResult<ControlNegotiationResult>;
using ControlClientReceiptResult = ControlDispatchResult<ControlReceiptEnvelope>;

class ControlClient {
  public:
    explicit ControlClient(ControlClientTransport& transport);
    ~ControlClient();
 
    ControlClient(const ControlClient&) = delete;
    ControlClient& operator=(const ControlClient&) = delete;
 
    ControlClientNegotiationResult
    negotiate(const ControlNegotiationOffer& offer,
              std::chrono::milliseconds timeout = std::chrono::seconds(3));
    ControlClientReceiptResult request(const ControlRequestEnvelope& request,
                                       std::chrono::milliseconds timeout = std::chrono::seconds(3));
    ControlClientReceiptResult cancel(const ControlCancelEnvelope& cancellation,
                                      std::chrono::milliseconds timeout = std::chrono::seconds(3));
    ControlArtifactReadResult
    read_artifact(std::string_view artifact_id, std::uint64_t offset, std::size_t maximum_bytes,
                  std::chrono::milliseconds timeout = std::chrono::seconds(3));
 
  private:
    struct DispatchResult {
        std::optional<ControlEnvelope> response;
        std::string error_code;
        std::string explanation;
    };
 
    DispatchResult dispatch(const ControlEnvelope& envelope, std::chrono::milliseconds timeout);
    ControlClientTransport* transport_ = nullptr;
};
 
} // namespace pulp::inspect