rpc_context.h

Go to the documentation of this file.

// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the Apache 2.0 License.
#pragma once
 
#include "ccf/claims_digest.h"
#include "ccf/frame_format.h"
#include "ccf/http_consts.h"
#include "ccf/http_header_map.h"
#include "ccf/http_responder.h"
#include "ccf/odata_error.h"
#include "ccf/redirect.h"
#include "ccf/rest_verb.h"
#include "ccf/service/signed_req.h"
#include "ccf/tx_id.h"
 
#include <vector>
 
namespace ccf
{
  static constexpr size_t InvalidSessionId = std::numeric_limits<size_t>::max();
  using ListenInterfaceID = std::string;
 
  struct SessionContext
  {
    size_t client_session_id = InvalidSessionId;
 
    // Contains DER encoding of original caller
    std::vector<uint8_t> caller_cert = {};
    bool is_forwarding = false;
 
    // Only set for RPC sessions (i.e. non-forwarded and non-internal)
    std::optional<ListenInterfaceID> interface_id = std::nullopt;
 
    // Only set in the case of a forwarded RPC
    bool is_forwarded = false;
 
    // All requests on this session must occur within the same view. If the view
    // changes, the next request will receive an error response and the session
    // will be closed.
    std::optional<ccf::View> active_view = std::nullopt;
 
    SessionContext(
      size_t client_session_id_,
      const std::vector<uint8_t>& caller_cert_,
      const std::optional<ListenInterfaceID>& interface_id_ = std::nullopt) :
      client_session_id(client_session_id_),
      caller_cert(caller_cert_),
      interface_id(interface_id_)
    {}
 
    virtual ~SessionContext() = default;
  };
 
  using PathParams = std::map<std::string, std::string, std::less<>>;
 
  class RpcContext
  {
  public:
    virtual ~RpcContext() = default;
 
 
    virtual std::shared_ptr<SessionContext> get_session_context() const = 0;
 
    // Set user data that will be available in the post-local-commit handler.
    // This is useful to avoid the serialisation/deserialisation cost.
    virtual void set_user_data(std::shared_ptr<void> data) = 0;
    // Get the user data that was previously set.
    virtual void* get_user_data() const = 0;
 
    virtual const std::vector<uint8_t>& get_request_body() const = 0;
    virtual const std::string& get_request_query() const = 0;
    virtual const ccf::RESTVerb& get_request_verb() const = 0;
    virtual std::string get_request_path() const = 0;
    virtual std::string get_method() const = 0;
    virtual std::shared_ptr<ccf::http::HTTPResponder> get_responder() const = 0;
 
    virtual const PathParams& get_request_path_params() = 0;
 
    virtual const PathParams& get_decoded_request_path_params() = 0;
 
    virtual const http::HeaderMap& get_request_headers() const = 0;
 
    virtual std::optional<std::string> get_request_header(
      const std::string_view& name) const = 0;
 
    virtual const std::string& get_request_url() const = 0;
 
    virtual ccf::FrameFormat frame_format() const = 0;
 
 
    virtual void set_response_body(const std::vector<uint8_t>& body) = 0;
    virtual void set_response_body(std::vector<uint8_t>&& body) = 0;
    virtual void set_response_body(std::string&& body) = 0;
    virtual const std::vector<uint8_t>& get_response_body() const = 0;
 
    virtual void set_response_status(int status) = 0;
    virtual int get_response_status() const = 0;
 
    virtual void set_response_header(
      const std::string_view& name, const std::string_view& value) = 0;
    virtual void set_response_header(const std::string_view& name, size_t n)
    {
      set_response_header(name, std::to_string(n));
    }
    virtual void set_response_header(const http::HeaderKeyValue& kv)
    {
      set_response_header(kv.first, kv.second);
    }
    virtual void clear_response_headers() = 0;
 
    virtual void set_response_trailer(
      const std::string_view& name, const std::string_view& value) = 0;
    virtual void set_response_trailer(const std::string_view& name, size_t n)
    {
      set_response_trailer(name, std::to_string(n));
    }
    virtual void set_response_trailer(const http::HeaderKeyValue& kv)
    {
      set_response_trailer(kv.first, kv.second);
    }
 
    virtual void set_response_json(
      const nlohmann::json& body, http_status status) = 0;
 
    virtual void set_error(
      http_status status,
      const std::string& code,
      std::string&& msg,
      const std::vector<nlohmann::json>& details = {}) = 0;
 
    virtual void set_error(ccf::ErrorDetails&& error) = 0;
 
 
 
    virtual void set_apply_writes(bool apply) = 0;
 
    virtual void set_claims_digest(ccf::ClaimsDigest::Digest&& digest) = 0;
  };
}