Client.h

#pragma once

#include <chrono>
#include <functional>
#include <map>
#include <memory>
#include <string>
#include <utility>

#include "logdevice/include/AsyncReader.h"
#include "logdevice/include/ClientFactory.h"
#include "logdevice/include/ClientSettings.h"
#include "logdevice/include/ClusterAttributes.h"
#include "logdevice/include/ConfigSubscriptionHandle.h"
#include "logdevice/include/Err.h"
#include "logdevice/include/LogHeadAttributes.h"
#include "logdevice/include/LogTailAttributes.h"
#include "logdevice/include/LogsConfigTypes.h"
#include "logdevice/include/Reader.h"
#include "logdevice/include/Record.h"
#include "logdevice/include/types.h"

namespace facebook { namespace logdevice {

// Enum which is used to determine accuracy of findTime or findKey in order to
// get best accuracy-speed trade off for each specific use case. See
// findTimeSync() or findKeySync() for documentation about each accuracy mode.
enum class FindKeyAccuracy { STRICT, APPROXIMATE };

// Struct which is used to provide the result of findKey. See findKey() for
// documentation about the returned values.
struct FindKeyResult {
  Status status;
  lsn_t lo;
  lsn_t hi;
};

// Enum which is used to determine accuracy of dataSize -- only approximate
// mode is currently supported.
enum class DataSizeAccuracy { APPROXIMATE, COUNT };

typedef std::function<void(Status st, const DataRecord& r)> append_callback_t;

typedef std::function<void(Status, lsn_t result)> find_time_callback_t;

typedef std::function<void(FindKeyResult result)> find_key_callback_t;

typedef std::function<void(Status, uint64_t result)> byte_offset_callback_t;

typedef std::function<void(Status)> trim_callback_t;

typedef std::function<void(Status status, bool empty)> is_empty_callback_t;

typedef std::function<void(Status status, size_t size)> data_size_callback_t;

typedef std::function<void(Status status, lsn_t)> get_tail_lsn_callback_t;

typedef std::function<void(Status status, std::pair<logid_t, logid_t>)>
    get_log_range_by_name_callback_t;

typedef std::function<void(Status status, std::map<std::string, logid_range_t>)>
    get_log_ranges_by_namespace_callback_t;

typedef std::function<void()> config_update_callback_t;

typedef std::function<void(Status status, std::unique_ptr<client::LogGroup>)>
    get_log_group_callback_t;

typedef std::function<void(Status status,
                           std::unique_ptr<client::LogGroup>,
                           const std::string& failure_reason)>
    make_log_group_callback_t;

typedef std::function<void(Status status,
                           std::unique_ptr<client::LogAttributes>)>
    get_log_attributes_callback_t;

typedef std::function<void(Status status, std::unique_ptr<client::Directory>)>
    get_directory_callback_t;

typedef std::function<void(Status status,
                           std::unique_ptr<client::Directory>,
                           const std::string& failure_reason)>
    make_directory_callback_t;

typedef std::function<
    void(Status, uint64_t version, const std::string& failure_reason)>
    logsconfig_status_callback_t;

typedef std::function<void(Status status, std::unique_ptr<LogTailAttributes>)>
    get_tail_attributes_callback_t;

typedef std::function<void(Status status, std::unique_ptr<LogHeadAttributes>)>
    get_head_attributes_callback_t;

class Client {
 public:
  virtual ~Client() = default;

  virtual lsn_t
  appendSync(logid_t logid,
             std::string payload,
             AppendAttributes attrs = AppendAttributes(),
             std::chrono::milliseconds* timestamp = nullptr) noexcept = 0;

  virtual lsn_t
  appendSync(logid_t logid,
             PayloadGroup&& payload_group,
             AppendAttributes attrs = AppendAttributes(),
             std::chrono::milliseconds* timestamp = nullptr) noexcept = 0;

  virtual lsn_t
  appendSync(logid_t logid,
             const Payload& payload,
             AppendAttributes attrs = AppendAttributes(),
             std::chrono::milliseconds* timestamp = nullptr) noexcept = 0;

  virtual int append(logid_t logid,
                     std::string payload,
                     append_callback_t cb,
                     AppendAttributes attrs = AppendAttributes()) noexcept = 0;

  virtual int append(logid_t logid,
                     PayloadGroup&& payload_group,
                     append_callback_t cb,
                     AppendAttributes attrs = AppendAttributes()) noexcept = 0;

  virtual int append(logid_t logid,
                     const Payload& payload,
                     append_callback_t cb,
                     AppendAttributes attrs = AppendAttributes()) noexcept = 0;

  virtual std::unique_ptr<Reader>
  createReader(size_t max_logs, ssize_t buffer_size = -1) noexcept = 0;

  virtual std::unique_ptr<AsyncReader>
  createAsyncReader(ssize_t buffer_size = -1) noexcept = 0;

  virtual void setTimeout(std::chrono::milliseconds timeout) noexcept = 0;

  virtual int trimSync(logid_t logid, lsn_t lsn) noexcept = 0;

  virtual int trim(logid_t logid, lsn_t lsn, trim_callback_t cb) noexcept = 0;

  virtual void addWriteToken(std::string) noexcept = 0;

  virtual lsn_t
  findTimeSync(logid_t logid,
               std::chrono::milliseconds timestamp,
               Status* status_out = nullptr,
               FindKeyAccuracy accuracy = FindKeyAccuracy::STRICT) noexcept = 0;

  virtual FindKeyResult
  findKeySync(logid_t logid,
              std::string key,
              FindKeyAccuracy accuracy = FindKeyAccuracy::STRICT) noexcept = 0;

  virtual int
  findTime(logid_t logid,
           std::chrono::milliseconds timestamp,
           find_time_callback_t cb,
           FindKeyAccuracy accuracy = FindKeyAccuracy::STRICT) noexcept = 0;

  virtual int
  findKey(logid_t logid,
          std::string key,
          find_key_callback_t cb,
          FindKeyAccuracy accuracy = FindKeyAccuracy::STRICT) noexcept = 0;

  virtual int isLogEmptySync(logid_t logid, bool* empty) noexcept = 0;

  virtual int isLogEmpty(logid_t logid, is_empty_callback_t cb) noexcept = 0;

  virtual int dataSizeSync(logid_t logid,
                           std::chrono::milliseconds start,
                           std::chrono::milliseconds end,
                           DataSizeAccuracy accuracy,
                           size_t* size) noexcept = 0;
  virtual int dataSize(logid_t logid,
                       std::chrono::milliseconds start,
                       std::chrono::milliseconds end,
                       DataSizeAccuracy accuracy,
                       data_size_callback_t cb) noexcept = 0;

  virtual lsn_t getTailLSNSync(logid_t logid) noexcept = 0;

  virtual int getTailLSN(logid_t logid,
                         get_tail_lsn_callback_t cb) noexcept = 0;

  virtual std::unique_ptr<LogTailAttributes>
  getTailAttributesSync(logid_t logid) noexcept = 0;

  virtual int getTailAttributes(logid_t logid,
                                get_tail_attributes_callback_t cb) noexcept = 0;

  virtual std::unique_ptr<LogHeadAttributes>
  getHeadAttributesSync(logid_t logid) noexcept = 0;

  virtual int getHeadAttributes(logid_t logid,
                                get_head_attributes_callback_t cb) noexcept = 0;
  virtual logid_range_t getLogRangeByName(const std::string& name) noexcept = 0;

  virtual void
  getLogRangeByName(const std::string& name,
                    get_log_range_by_name_callback_t cb) noexcept = 0;

  virtual std::string getLogNamespaceDelimiter() noexcept = 0;

  virtual std::map<std::string, logid_range_t>
  getLogRangesByNamespace(const std::string& ns) noexcept = 0;

  virtual void getLogRangesByNamespace(
      const std::string& ns,
      get_log_ranges_by_namespace_callback_t cb) noexcept = 0;

  virtual std::unique_ptr<client::LogGroup>
  getLogGroupSync(const std::string& path) noexcept = 0;

  virtual void getLogGroup(const std::string& path,
                           get_log_group_callback_t cb) noexcept = 0;

  virtual std::unique_ptr<client::LogGroup>
  getLogGroupByIdSync(const logid_t logid) noexcept = 0;

  virtual void getLogGroupById(const logid_t logid,
                               get_log_group_callback_t cb) noexcept = 0;

  virtual int makeDirectory(const std::string& path,
                            bool mk_intermediate_dirs,
                            const client::LogAttributes& attrs,
                            make_directory_callback_t cb) noexcept = 0;

  virtual std::unique_ptr<client::Directory> makeDirectorySync(
      const std::string& path,
      bool mk_intermediate_dirs = false,
      const client::LogAttributes& attrs = client::LogAttributes(),
      std::string* failure_reason = nullptr) noexcept = 0;

  virtual int removeDirectory(const std::string& path,
                              bool recursive,
                              logsconfig_status_callback_t) noexcept = 0;

  virtual bool removeDirectorySync(const std::string& path,
                                   bool recursive = false,
                                   uint64_t* version = nullptr) noexcept = 0;

  virtual bool removeLogGroupSync(const std::string& path,
                                  uint64_t* version = nullptr) noexcept = 0;

  virtual int removeLogGroup(const std::string& path,
                             logsconfig_status_callback_t cb) noexcept = 0;

  virtual int rename(const std::string& from_path,
                     const std::string& to_path,
                     logsconfig_status_callback_t cb) noexcept = 0;

  virtual bool renameSync(const std::string& from_path,
                          const std::string& to_path,
                          uint64_t* version = nullptr,
                          std::string* failure_reason = nullptr) noexcept = 0;

  virtual int makeLogGroup(const std::string& path,
                           const logid_range_t& range,
                           const client::LogAttributes& attrs,
                           bool mk_intermediate_dirs,
                           make_log_group_callback_t cb) noexcept = 0;
  virtual std::unique_ptr<client::LogGroup>
  makeLogGroupSync(const std::string& path,
                   const logid_range_t& range,
                   const client::LogAttributes& attrs = client::LogAttributes(),
                   bool mk_intermediate_dirs = false,
                   std::string* failure_reason = nullptr) noexcept = 0;

  virtual int setAttributes(const std::string& path,
                            const client::LogAttributes& attrs,
                            logsconfig_status_callback_t cb) noexcept = 0;

  virtual bool
  setAttributesSync(const std::string& path,
                    const client::LogAttributes& attrs,
                    uint64_t* version = nullptr,
                    std::string* failure_reason = nullptr) noexcept = 0;

  virtual int setLogGroupRange(const std::string& path,
                               const logid_range_t& range,
                               logsconfig_status_callback_t) noexcept = 0;

  virtual bool
  setLogGroupRangeSync(const std::string& path,
                       const logid_range_t& range,
                       uint64_t* version = nullptr,
                       std::string* failure_reason = nullptr) noexcept = 0;

  virtual int getDirectory(const std::string& path,
                           get_directory_callback_t) noexcept = 0;

  virtual std::unique_ptr<client::Directory>
  getDirectorySync(const std::string& path) noexcept = 0;

  virtual bool syncLogsConfigVersion(uint64_t version) noexcept = 0;

  virtual ConfigSubscriptionHandle
  notifyOnLogsConfigVersion(uint64_t version,
                            std::function<void()>) noexcept = 0;

  virtual std::unique_ptr<ClusterAttributes>
  getClusterAttributes() noexcept = 0;

  virtual ConfigSubscriptionHandle
      subscribeToConfigUpdates(config_update_callback_t) noexcept = 0;

  virtual size_t getMaxPayloadSize() noexcept = 0;

  virtual ClientSettings& settings() = 0;

  virtual std::string getAllReadStreamsDebugInfo() noexcept = 0;

  virtual void publishEvent(Severity sev,
                            std::string name_space,
                            std::string type,
                            std::string data = "",
                            std::string context = "") noexcept = 0;

 protected:
  Client() = default;

 private:
  Client(const Client&) = delete;            // non-copyable
  Client& operator=(const Client&) = delete; // non-assignable
};

}} // namespace facebook::logdevice