cluster.hxx

/*
 *     Copyright 2021 Couchbase, Inc.
 *
 *   Licensed under the Apache License, Version 2.0 (the "License");
 *   you may not use this file except in compliance with the License.
 *   You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 *   Unless required by applicable law or agreed to in writing, software
 *   distributed under the License is distributed on an "AS IS" BASIS,
 *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *   See the License for the specific language governing permissions and
 *   limitations under the License.
 */

#pragma once

#include <chrono>
#include <list>
#include <memory>
#include <mutex>
#include <string>

#include <boost/optional.hpp>
#include <couchbase/client/bucket.hxx>
#include <couchbase/support.hxx>
/*
 * @file
 * Provides cluster-level operations for Couchbase Transactions Client
 */
namespace couchbase
{
class bucket;

template<typename T>
class pool;

struct instance_pool_event_counter;

static const size_t DEFAULT_CLUSTER_MAX_INSTANCES = 4;
static const size_t DEFAULT_BUCKET_MAX_INSTANCES = 4;

class cluster_options
{
  private:
    size_t max_instances_;
    size_t max_bucket_instances_;
    boost::optional<std::chrono::microseconds> kv_timeout_;
    instance_pool_event_counter* event_counter_;

  public:
    cluster_options()
      : max_instances_(DEFAULT_CLUSTER_MAX_INSTANCES)
      , max_bucket_instances_(DEFAULT_BUCKET_MAX_INSTANCES)
      , event_counter_(nullptr)
    {
    }

    CB_NODISCARD size_t max_instances() const
    {
        return max_instances_;
    }
    cluster_options& max_instances(size_t max)
    {
        max_instances_ = max;
        return *this;
    }
    CB_NODISCARD size_t max_bucket_instances() const
    {
        return max_bucket_instances_;
    }
    cluster_options& max_bucket_instances(size_t max)
    {
        max_bucket_instances_ = max;
        return *this;
    }
    CB_NODISCARD boost::optional<std::chrono::microseconds> kv_timeout() const
    {
        return kv_timeout_;
    }
    template<typename T>
    cluster_options& kv_timeout(T duration)
    {
        kv_timeout_ = std::chrono::duration_cast<std::chrono::microseconds>(duration);
        return *this;
    }

    CB_NODISCARD instance_pool_event_counter* event_counter() const
    {
        return event_counter_;
    }
    cluster_options& event_counter(instance_pool_event_counter* counter)
    {
        event_counter_ = counter;
        return *this;
    }
};

class cluster
{
  private:
    lcb_st* lcb_;
    std::string cluster_address_;
    std::string user_name_;
    std::string password_;
    std::mutex mutex_;
    size_t max_bucket_instances_;
    std::list<std::shared_ptr<class bucket>> open_buckets_;
    std::unique_ptr<pool<lcb_st*>> instance_pool_;
    instance_pool_event_counter* event_counter_;
    boost::optional<std::chrono::microseconds> kv_timeout_;

  public:
    explicit cluster(std::string cluster_address,
                     std::string user_name,
                     std::string password,
                     const cluster_options& opts = cluster_options());
    cluster(const cluster& cluster);

    ~cluster();
    CB_NODISCARD std::list<std::string> buckets();
    CB_NODISCARD std::shared_ptr<class bucket> bucket(const std::string& name);
    CB_NODISCARD const std::string cluster_address() const
    {
        return cluster_address_;
    }

    CB_NODISCARD size_t max_instances() const;

    CB_NODISCARD size_t instances() const;

    CB_NODISCARD size_t available_instances() const;

    CB_NODISCARD std::chrono::microseconds default_kv_timeout() const;

    CB_NODISCARD bool operator==(const couchbase::cluster& other) const;
};
} // namespace couchbase