couchbase 3.0.0.alpha.5 → 3.0.0.beta.1

data/bin/jenkins/test-with-cbdyncluster

@@ -1,58 +0,0 @@
-#!/usr/bin/env bash
-
-#    Copyright 2020 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.
-
-set -x
-set -e
-
-cbdyncluster info
-cbdyncluster ps -a
-
-CB_VERSION=${CB_VERSION:-6.5.1}
-CB_RUBY_VERSION=${CB_RUBY_VERSION:-2.7.1}
-
-CLUSTER_ID=$(cbdyncluster allocate --num-nodes=3 --server-version=${CB_VERSION})
-SERVICES="kv,index,n1ql,fts"
-cbdyncluster setup ${CLUSTER_ID} \
-    --bucket=default \
-    --enable-developer-preview \
-    --storage-mode=plasma \
-    --node=${SERVICES} \
-    --node=${SERVICES} \
-    --node=${SERVICES}
-sleep 30
-
-source /usr/local/share/chruby/chruby.sh
-chruby ruby-${CB_RUBY_VERSION}
-
-export COUCHBASE_BACKEND_LOG_LEVEL=debug
-# CB_TEST_NAME=test_exists_allows_to_check_document_existence
-
-if [ ! -z $CB_TEST_NAME ]
-then
-  export TESTOPTS="--name='/^${CB_TEST_NAME}$/'"
-fi
-export TEST_SERVER_VERSION=${CB_VERSION}
-export TEST_DEVELOPER_PREVIEW=yes
-export TEST_CONNECTION_STRING=$(cbdyncluster connstr ${CLUSTER_ID})
-set +e
-
-bundle exec rake test
-STATUS=$?
-set -e
-
-cbdyncluster rm ${CLUSTER_ID}
-
-exit ${STATUS}

data/bin/setup

@@ -1,24 +0,0 @@
-#!/usr/bin/env bash
-
-#    Copyright 2020 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.
-
-PROJECT_ROOT="$( cd "$(dirname "$0"/..)" >/dev/null 2>&1 ; pwd -P )"
-
-set -euo pipefail
-IFS=$'\n\t'
-set -vx
-git submodule update --init
-bundle config set --local path ${PROJECT_ROOT}/vendor/bundle
-bundle install

data/ext/couchbase/configuration_monitor.hxx

@@ -1,93 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
- *     Copyright 2020 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 <functional>
-
-#include <asio.hpp>
-
-#include <configuration.hxx>
-
-namespace couchbase
-{
-class configuration_monitor
-{
-  public:
-    using listener_type = std::function<void(const configuration& conf)>;
-
-    explicit configuration_monitor(asio::io_context& ctx)
-      : strand_(ctx.get_executor())
-    {
-    }
-
-    void post(configuration&& conf)
-    {
-        asio::post(asio::bind_executor(strand_, [this, conf = std::move(conf)]() {
-            for (auto& listener : listeners_) {
-                listener.second(conf);
-            }
-        }));
-    }
-
-    void post(const std::string& bucket_name, configuration&& conf)
-    {
-        auto& listeners = bucket_listeners_[bucket_name];
-        if (listeners.empty()) {
-            return;
-        }
-        asio::post(asio::bind_executor(strand_, [&listeners, conf = std::move(conf)]() {
-            for (auto& listener : listeners) {
-                listener.second(conf);
-            }
-        }));
-    }
-
-    std::size_t subscribe(listener_type&& listener)
-    {
-        auto token = next_token_++;
-        listeners_[token] = listener;
-        return token;
-    }
-
-    std::size_t subscribe(const std::string& bucket_name, listener_type&& listener)
-    {
-        auto token = next_token_++;
-        bucket_listeners_[bucket_name][token] = listener;
-        return token;
-    }
-
-    void unsubscribe(size_t token)
-    {
-        listeners_.erase(token);
-    }
-
-    void unsubscribe(const std::string& bucket_name, size_t token)
-    {
-        auto b = bucket_listeners_.find(bucket_name);
-        if (b != bucket_listeners_.end()) {
-            b->second.erase(token);
-        }
-    }
-
-  private:
-    asio::strand<asio::io_context::executor_type> strand_;
-    std::map<size_t, listener_type> listeners_;
-    std::map<std::string, std::map<size_t, listener_type>> bucket_listeners_;
-    std::size_t next_token_{ 0 };
-};
-} // namespace couchbase

data/ext/couchbase/operations/command.hxx

@@ -1,163 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
- *     Copyright 2020 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 <io/mcbp_session.hxx>
-#include <io/http_session.hxx>
-#include <protocol/cmd_get_collection_id.hxx>
-
-namespace couchbase::operations
-{
-
-template<typename Request>
-struct command : public std::enable_shared_from_this<command<Request>> {
-    using encoded_request_type = typename Request::encoded_request_type;
-    using encoded_response_type = typename Request::encoded_response_type;
-    asio::steady_timer deadline;
-    asio::steady_timer retry_backoff;
-    Request request;
-    encoded_request_type encoded;
-
-    command(asio::io_context& ctx, Request&& req)
-      : deadline(ctx)
-      , retry_backoff(ctx)
-      , request(req)
-    {
-    }
-
-    template<typename Handler>
-    void request_collection_id(std::shared_ptr<io::mcbp_session> session, Handler&& handler)
-    {
-        protocol::client_request<protocol::get_collection_id_request_body> req;
-        req.opaque(session->next_opaque());
-        req.body().collection_path(request.id.collection);
-        session->write_and_subscribe(req.opaque(),
-                                     req.data(session->supports_feature(protocol::hello_feature::snappy)),
-                                     [self = this->shared_from_this(), session, handler = std::forward<Handler>(handler)](
-                                       std::error_code ec, io::mcbp_message&& msg) mutable {
-                                         if (ec == std::make_error_code(error::common_errc::collection_not_found)) {
-                                             if (self->request.id.collection_uid) {
-                                                 return self->handle_unknown_collection(session, std::forward<Handler>(handler));
-                                             }
-                                             return handler(make_response(ec, self->request, {}));
-                                         }
-                                         if (ec) {
-                                             return handler(make_response(ec, self->request, {}));
-                                         }
-                                         protocol::client_response<protocol::get_collection_id_response_body> resp(msg);
-                                         session->update_collection_uid(self->request.id.collection, resp.body().collection_uid());
-                                         self->request.id.collection_uid = resp.body().collection_uid();
-                                         return self->send_to(session, std::forward<Handler>(handler));
-                                     });
-    }
-
-    template<typename Handler>
-    void handle_unknown_collection(std::shared_ptr<io::mcbp_session> session, Handler&& handler)
-    {
-        auto backoff = std::chrono::milliseconds(500);
-        if (std::chrono::steady_clock::now() + backoff > deadline.expiry()) {
-            return handler(make_response(std::make_error_code(error::common_errc::ambiguous_timeout), request, {}));
-        }
-        retry_backoff.expires_after(backoff);
-        retry_backoff.async_wait(
-          [self = this->shared_from_this(), session, handler = std::forward<Handler>(handler)](std::error_code ec) mutable {
-              if (ec == asio::error::operation_aborted) {
-                  return handler(make_response(std::make_error_code(error::common_errc::ambiguous_timeout), self->request, {}));
-              }
-              self->request_collection_id(session, std::forward<Handler>(handler));
-          });
-    }
-
-    template<typename Handler>
-    void send_to(std::shared_ptr<io::mcbp_session> session, Handler&& handler)
-    {
-        auto opaque = session->next_opaque();
-        request.opaque = opaque;
-        if (!request.id.collection_uid) {
-            if (session->supports_feature(protocol::hello_feature::collections)) {
-                auto collection_id = session->get_collection_uid(request.id.collection);
-                if (collection_id) {
-                    request.id.collection_uid = *collection_id;
-                } else {
-                    return request_collection_id(session, std::forward<Handler>(handler));
-                }
-            } else {
-                if (!request.id.collection.empty() && request.id.collection != "_default._default") {
-                    return handler(make_response(std::make_error_code(error::common_errc::unsupported_operation), request, {}));
-                }
-            }
-        }
-        request.encode_to(encoded);
-        session->write_and_subscribe(
-          request.opaque,
-          encoded.data(session->supports_feature(protocol::hello_feature::snappy)),
-          [self = this->shared_from_this(), session, handler = std::forward<Handler>(handler)](std::error_code ec,
-                                                                                               io::mcbp_message&& msg) mutable {
-              if (ec == asio::error::operation_aborted) {
-                  return handler(make_response(std::make_error_code(error::common_errc::ambiguous_timeout), self->request, {}));
-              }
-              self->deadline.cancel();
-              self->retry_backoff.cancel();
-              encoded_response_type resp(msg);
-              if (resp.status() == protocol::status::unknown_collection) {
-                  return self->handle_unknown_collection(session, std::forward<Handler>(handler));
-              }
-              handler(make_response(ec, self->request, resp));
-          });
-        deadline.expires_after(request.timeout);
-        deadline.async_wait([session, opaque](std::error_code ec) {
-            if (ec == asio::error::operation_aborted) {
-                return;
-            }
-            session->cancel(opaque, asio::error::operation_aborted);
-        });
-    }
-
-    template<typename Handler>
-    void send_to(std::shared_ptr<io::http_session> session, Handler&& handler)
-    {
-        request.encode_to(encoded);
-        spdlog::trace("{} HTTP request: {}, method={}, path={}{:a}",
-                      session->log_prefix(),
-                      encoded.type,
-                      encoded.method,
-                      encoded.path,
-                      spdlog::to_hex(encoded.body));
-        session->write_and_subscribe(encoded,
-                                     [self = this->shared_from_this(), session, handler = std::forward<Handler>(handler)](
-                                       std::error_code ec, io::http_response&& msg) mutable {
-                                         encoded_response_type resp(msg);
-                                         self->deadline.cancel();
-                                         spdlog::trace("{} HTTP response: {}, status={}{:a}",
-                                                       session->log_prefix(),
-                                                       self->request.type,
-                                                       resp.status_code,
-                                                       spdlog::to_hex(resp.body));
-                                         handler(make_response(ec, self->request, resp));
-                                     });
-        deadline.expires_after(request.timeout);
-        deadline.async_wait([session](std::error_code ec) {
-            if (ec == asio::error::operation_aborted) {
-                return;
-            }
-            session->stop();
-        });
-    }
-};
-
-} // namespace couchbase::operations

data/rbi/couchbase.rbi

@@ -1,79 +0,0 @@
-#    Copyright 2020 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.
-
-# typed: strict
-module Couchbase
-  class Cluster
-    sig {params().returns(UserManager)}
-    def users
-      UserManager.new(@io)
-    end
-
-    sig {params().returns(BucketManager)}
-    def buckets
-      BucketManager.new(@io)
-    end
-
-    sig {params().returns(QueryIndexManager)}
-    def query_indexes
-      QueryIndexManager.new(@io)
-    end
-
-    sig {params().returns(AnalyticsIndexManager)}
-    def analytics_indexes
-      AnalyticsIndexManager.new(@io)
-    end
-
-    sig {params().returns(SearchIndexManager)}
-    def search_indexes
-      SearchIndexManager.new(@io)
-    end
-  end
-
-  class UserManager
-    sig {params(io: Backend::IoCore).void}
-    def initialize(io)
-    end
-  end
-
-  class BucketManager
-    sig {params(io: Backend::IoCore).void}
-    def initialize(io)
-    end
-  end
-
-  class QueryIndexManager
-    sig {params(io: Backend::IoCore).void}
-    def initialize(io)
-    end
-  end
-
-  class AnalyticsIndexManager
-    sig {params(io: Backend::IoCore).void}
-    def initialize(io)
-    end
-  end
-
-  class SearchIndexManager
-    sig {params(io: Backend::IoCore).void}
-    def initialize(io)
-    end
-  end
-
-  # private
-  module Backend
-    class IoCore
-    end
-  end
-end