simple.h

Go to the documentation of this file.

#ifndef FASTLY_CACHE_SIMPLE_H
#define FASTLY_CACHE_SIMPLE_H
 
#include <chrono>
#include <fastly/cache/core.h>
#include <fastly/expected.h>
#include <fastly/http/body.h>
#include <functional>
#include <optional>
#include <span>
#include <string>
#include <string_view>
#include <type_traits>
#include <vector>
 
namespace fastly::cache::simple {
class CacheError {
public:
  enum Code {
    LimitExceeded,
    InvalidOperation,
    Unsupported,
    Io,
    Purge,
    GetOrSet,
    Other,
  };
 
  CacheError(Code code) : code_(code) {}
  Code code() const { return code_; }
 
private:
  Code code_;
};

class CacheEntry {
public:
  CacheEntry(http::Body val, std::chrono::nanoseconds ttl)
      : value_(std::move(val)), ttl_(ttl) {}
 
  http::Body &value() { return value_; }
  const http::Body &value() const { return value_; }
  std::chrono::nanoseconds ttl() const { return ttl_; }
 
private:
  http::Body value_;
  std::chrono::nanoseconds ttl_;
};

class PurgeOptions {
public:
  enum Scope {
    Pop,
    Global,
  };

  static PurgeOptions pop_scope() { return PurgeOptions(Scope::Pop); }

  static PurgeOptions global_scope() { return PurgeOptions(Scope::Global); }
 
  Scope scope() const { return scope_; }
 
private:
  explicit PurgeOptions(Scope s) : scope_(s) {}
  Scope scope_;
};
 
namespace detail {
std::string surrogate_key_for_cache_key(std::span<const std::uint8_t> key,
                                        PurgeOptions::Scope scope);
 
fastly::cache::simple::CacheError
from_core_error(const fastly::cache::core::CacheError &err);
} // namespace detail

tl::expected<std::optional<http::Body>, CacheError>
get(std::span<const std::uint8_t> key);

inline tl::expected<std::optional<http::Body>, CacheError>
get(std::string_view key) {
  return get(std::span(reinterpret_cast<const std::uint8_t *>(key.data()),
                       key.size()));
}

tl::expected<http::Body, CacheError>
get_or_set(std::span<const std::uint8_t> key, http::Body value,
           std::chrono::nanoseconds ttl);

inline tl::expected<http::Body, CacheError>
get_or_set(std::string_view key, http::Body value,
           std::chrono::nanoseconds ttl) {
  return get_or_set(
      std::span(reinterpret_cast<const std::uint8_t *>(key.data()), key.size()),
      std::move(value), ttl);
}

template <class F>
tl::expected<std::optional<http::Body>, CacheError>
get_or_set_with(std::span<const std::uint8_t> key, F make_entry)
  requires std::invocable<F> &&
           std::same_as<std::invoke_result_t<F>, std::optional<CacheEntry>>
{
  auto lookup_result = core::Transaction::lookup(key).execute();
  if (!lookup_result.has_value()) {
    return tl::unexpected(detail::from_core_error(lookup_result.error()));
  }
 
  auto &lookup_tx = lookup_result.value();
 
  if (!lookup_tx.must_insert_or_update()) {
    if (auto found = lookup_tx.found()) {
      auto stream_result = found->to_stream();
      if (!stream_result.has_value()) {
        return tl::unexpected(detail::from_core_error(stream_result.error()));
      }
      return std::optional<http::Body>(std::move(stream_result.value()));
    } else {
      return tl::unexpected(CacheError(CacheError::Code::InvalidOperation));
    }
  }
 
  // Run the user-provided closure to produce the entry
  auto entry = make_entry();
  if (!entry.has_value()) {
    return tl::unexpected(CacheError(CacheError::Code::GetOrSet));
  }
 
  // Create surrogate keys for both POP and global purging
  std::vector<std::string> surrogate_keys = {
      detail::surrogate_key_for_cache_key(key, PurgeOptions::Scope::Pop),
      detail::surrogate_key_for_cache_key(key, PurgeOptions::Scope::Global),
  };
 
  auto insert_result = std::move(lookup_tx)
                           .insert(entry->ttl())
                           .surrogate_keys(surrogate_keys)
                           .execute_and_stream_back();
 
  if (!insert_result.has_value()) {
    return tl::unexpected(detail::from_core_error(insert_result.error()));
  }
 
  auto [insert_body, found] = std::move(insert_result.value());
 
  insert_body.append(std::move(entry->value()));
  auto finish_result = insert_body.finish();
  if (!finish_result.has_value()) {
    return tl::unexpected(CacheError(CacheError::Code::Other));
  }
 
  auto stream_result = found.to_stream();
  if (!stream_result.has_value()) {
    return tl::unexpected(detail::from_core_error(stream_result.error()));
  }
 
  return std::optional<http::Body>(std::move(stream_result.value()));
}

template <class F>
tl::expected<std::optional<http::Body>, CacheError>
get_or_set_with(std::string_view key, F make_entry) {
  return get_or_set_with(
      std::span(reinterpret_cast<const std::uint8_t *>(key.data()), key.size()),
      std::move(make_entry));
}

tl::expected<void, CacheError> purge(std::span<const std::uint8_t> key);

inline tl::expected<void, CacheError> purge(std::string_view key) {
  return purge(std::span(reinterpret_cast<const std::uint8_t *>(key.data()),
                         key.size()));
}

tl::expected<void, CacheError>
purge_with_opts(std::span<const std::uint8_t> key, const PurgeOptions &opts);

inline tl::expected<void, CacheError>
purge_with_opts(std::string_view key, const PurgeOptions &opts) {
  return purge_with_opts(
      std::span(reinterpret_cast<const std::uint8_t *>(key.data()), key.size()),
      opts);
}
 
} // namespace fastly::cache::simple
 
#endif // FASTLY_CACHE_SIMPLE_H