connection.hpp

#pragma once

#include <zk/config.hpp>

#include <chrono>
#include <iosfwd>
#include <memory>
#include <mutex>
#include <string>
#include <vector>

#include "buffer.hpp"
#include "forwards.hpp"
#include "future.hpp"
#include "string_view.hpp"

namespace zk
{


class connection
{
public:
    static std::shared_ptr<connection> connect(const connection_params&);

    static std::shared_ptr<connection> connect(string_view conn_string);

    virtual ~connection() noexcept;

    virtual void close() = 0;

    virtual future<get_result> get(string_view path) = 0;

    virtual future<watch_result> watch(string_view path) = 0;

    virtual future<get_children_result> get_children(string_view path) = 0;

    virtual future<watch_children_result> watch_children(string_view path) = 0;

    virtual future<exists_result> exists(string_view path) = 0;

    virtual future<watch_exists_result> watch_exists(string_view path) = 0;

    virtual future<create_result> create(string_view   path,
                                         const buffer& data,
                                         const acl&    rules,
                                         create_mode   mode
                                        ) = 0;

    virtual future<set_result> set(string_view path, const buffer& data, version check) = 0;

    virtual future<void> erase(string_view path, version check) = 0;

    virtual future<get_acl_result> get_acl(string_view path) const = 0;

    virtual future<void> set_acl(string_view path, const acl& rules, acl_version check) = 0;

    virtual future<multi_result> commit(multi_op&& txn) = 0;

    virtual future<void> load_fence() = 0;

    virtual zk::state state() const = 0;

    virtual future<zk::state> watch_state();

protected:
    virtual void on_session_event(zk::state new_state);

private:
    mutable std::mutex              _state_change_promises_protect;
    std::vector<promise<zk::state>> _state_change_promises;
};

class connection_params final
{
public:
    using host_list = std::vector<std::string>;

public:
    static constexpr std::chrono::milliseconds default_timeout = std::chrono::seconds(10);

public:
    connection_params() noexcept;

    ~connection_params() noexcept;

    static connection_params parse(string_view conn_string);

    const std::string& connection_schema() const { return _connection_schema; }
    std::string&       connection_schema()       { return _connection_schema; }

    const host_list& hosts() const { return _hosts; }
    host_list&       hosts()       { return _hosts; }

    const std::string& chroot() const { return _chroot; }
    std::string&       chroot()       { return _chroot; }

    bool  randomize_hosts() const { return _randomize_hosts; }
    bool& randomize_hosts()       { return _randomize_hosts; }

    bool  read_only() const { return _read_only; }
    bool& read_only()       { return _read_only; }

    std::chrono::milliseconds  timeout() const { return _timeout; }
    std::chrono::milliseconds& timeout()       { return _timeout; }

private:
    std::string               _connection_schema;
    host_list                 _hosts;
    std::string               _chroot;
    bool                      _randomize_hosts;
    bool                      _read_only;
    std::chrono::milliseconds _timeout;
};

bool operator==(const connection_params& lhs, const connection_params& rhs);
bool operator!=(const connection_params& lhs, const connection_params& rhs);

std::string to_string(const connection_params&);
std::ostream& operator<<(std::ostream&, const connection_params&);


}