request.h

Go to the documentation of this file.

#ifndef FASTLY_HTTP_REQUEST_H
#define FASTLY_HTTP_REQUEST_H
 
#include <algorithm>
#include <fastly/backend.h>
#include <fastly/detail/access_bridge_internals.h>
#include <fastly/error.h>
#include <fastly/http/body.h>
#include <fastly/http/header.h>
#include <fastly/http/http.h>
#include <fastly/http/response.h>
#include <fastly/sdk-sys.h>
#include <iostream>
#include <iterator>
#include <optional>
#include <string>
#include <string_view>
#include <utility>
#include <variant>
#include <vector>
 
namespace fastly::backend {
class Backend;
}
 
namespace fastly::http {
 
class Body;
class StreamingBody;
class Response;
class Request;
 
namespace request {

class PendingRequest {
  friend detail::AccessBridgeInternals;
  friend Request;
  friend std::pair<fastly::expected<Response>, std::vector<PendingRequest>>
  select(std::vector<PendingRequest> &reqs);

  std::variant<PendingRequest, fastly::expected<Response>> poll();

  fastly::expected<Response> wait();

  Request cloned_sent_req();
 
private:
  auto &inner() { return req; }
  rust::Box<fastly::sys::http::request::PendingRequest> req;
 
  PendingRequest(rust::Box<fastly::sys::http::request::PendingRequest> r)
      : req(std::move(r)) {};
};

std::pair<fastly::expected<Response>, std::vector<PendingRequest>>
select(std::vector<PendingRequest> &reqs);
 
} // namespace request

class Request {
  friend request::PendingRequest;
  friend Response;
  friend detail::AccessBridgeInternals;
 
public:
  Request(Method method, std::string_view url);

  static Request get(std::string_view url);

  static Request head(std::string_view url);

  static Request post(std::string_view url);

  static Request put(std::string_view url);

  static Request delete_(std::string_view url);

  static Request connect(std::string_view url);

  static Request options(std::string_view url);

  static Request trace(std::string_view url);

  static Request patch(std::string_view url);

  static Request from_client();

  bool is_from_client();

  Request clone_without_body();

  Request clone_with_body();

  fastly::expected<Response> send(fastly::backend::Backend &backend);
  fastly::expected<Response> send(std::string_view backend_name);

  fastly::expected<request::PendingRequest>
  send_async(fastly::backend::Backend &backend);
  fastly::expected<request::PendingRequest>
  send_async(std::string_view backend_name);

  fastly::expected<std::pair<StreamingBody, request::PendingRequest>>
  send_async_streaming(fastly::backend::Backend &backend);
  fastly::expected<std::pair<StreamingBody, request::PendingRequest>>
  send_async_streaming(std::string_view backend_name);

  Request with_body(Body body) &&;

  bool has_body();

  Body take_body();

  void set_body(Body body);

  void append_body(Body &body);

  std::vector<uint8_t> into_body_bytes();

  std::string into_body_string();

  Body into_body();

  fastly::expected<Request> with_body_text_plain(std::string_view body) &&;

  fastly::expected<void> set_body_text_plain(std::string_view body);

  fastly::expected<Request> with_body_text_html(std::string_view body) &&;

  fastly::expected<void> set_body_text_html(std::string_view body);

  std::string take_body_string();

  Request with_body_octet_stream(std::vector<uint8_t> body) &&;

  void set_body_octet_stream(std::vector<uint8_t> body);

  std::vector<uint8_t> take_body_bytes();
 
  // ChunksIter read_body_chunks(size_t chunk_size);

  std::optional<std::string> get_content_type();

  Request with_content_type(std::string_view mime) &&;

  void set_content_type(std::string_view mime);

  std::optional<size_t> get_content_length();

  fastly::expected<bool> contains_header(std::string_view name);

  fastly::expected<Request> with_header(std::string_view name,
                                        std::string_view value) &&;

  fastly::expected<Request> with_set_header(std::string_view name,
                                            std::string_view value) &&;

  fastly::expected<std::optional<HeaderValue>>
  get_header(std::string_view name);

  fastly::expected<HeaderValuesRange> get_header_all(std::string_view name);
  fastly::expected<HeadersRange> get_headers();
  fastly::expected<HeaderNamesRange> get_header_names();

  fastly::expected<void> set_header(std::string_view name,
                                    std::string_view value);

  fastly::expected<void> append_header(std::string_view name,
                                       std::string_view value);

  fastly::expected<std::optional<std::string>>
  remove_header(std::string_view name);

  Request with_method(Method method) &&;

  Method get_method();

  void set_method(Method method);

  fastly::expected<Request> with_url(std::string_view url) &&;

  std::string get_url();

  fastly::expected<void> set_url(std::string_view url);

  std::string get_path();

  fastly::expected<Request> with_path(std::string_view path) &&;

  fastly::expected<void> set_path(std::string_view path);

  std::optional<std::string> get_query_string();

  std::optional<std::string> get_query_parameter(std::string_view param);

  fastly::expected<Request> with_query_string(std::string_view query) &&;

  fastly::expected<void> set_query_string(std::string_view query);

  void remove_query();

  Request with_version(Version version) &&;

  Version get_version();

  void set_version(Version version);

  Request with_pass(bool pass) &&;

  void set_pass(bool pass);

  Request with_ttl(uint32_t ttl) &&;

  void set_ttl(uint32_t ttl);

  Request with_stale_while_revalidate(uint32_t swr) &&;

  void set_stale_while_revalidate(uint32_t swr);

  Request with_pci(bool pci) &&;

  void set_pci(bool pci);

  fastly::expected<Request> with_surrogate_key(std::string_view sk) &&;

  fastly::expected<void> set_surrogate_key(std::string_view sk);
 
  std::optional<std::string> get_client_ip_addr();
  std::optional<std::string> get_server_ip_addr();
 
  std::optional<OriginalHeaderNamesRange> get_original_header_names();
  std::optional<uint32_t> get_original_header_count();

  std::optional<bool> get_client_ddos_detected();
 
  // std::optional<std::vector<uint8_t>> get_tls_client_hello();
  // std::optional<std::array<uint8_t, 16>> get_tls_ja3_md5();
  // std::optional<std::string> get_tls_ja4();
  // std::optional<std::string> get_tls_raw_client_certificate();
  // std::optional<std::vector<uint8_t>>
  // get_tls_raw_client_certificate_bytes();
  // // TODO(@zkat): needs additional type
  // // std::optional<ClientCertVerifyResult>
  // get_tls_client_cert_verify_result(); std::optional<std::string>
  // get_tls_cipher_openssl_name(); std::optional<std::vector<uint8_t>>
  // get_tls_cipher_openssl_name_bytes(); std::optional<std::vector<uint8_t>>
  // get_tls_protocol_bytes();

  void set_auto_decompress_gzip(bool gzip);

  Request with_auto_decompress_gzip(bool gzip) &&;
 
  // TODO(@zkat): needs enum
  // void set_framing_headers_mode(FramingHeadersMode mode);
  // Request *set_framing_headers_mode(FramingHeadersMode mode);

  bool fastly_key_is_valid();
 
  // void handoff_websocket(fastly::backend::Backend backend);
  // void handoff_fanout(fastly::backend::Backend backend);
  // Request *on_behalf_of(std::string_view service);

  void set_cache_key(std::string_view key);

  void set_cache_key(std::vector<uint8_t> key);

  Request with_cache_key(std::string_view key) &&;

  Request with_cache_key(std::vector<uint8_t> key) &&;

  bool is_cacheable();
 
private:
  auto &inner() { return req; }
  Request(rust::Box<fastly::sys::http::Request> r) : req(std::move(r)) {};
  rust::Box<fastly::sys::http::Request> req;
};
 
} // namespace fastly::http
 
namespace fastly {
using fastly::http::Request;
}
 
#endif