couchbase 3.5.6 → 3.6.0

data/ext/couchbase/couchbase/transactions/transaction_get_multi_mode.hxx

@@ -0,0 +1,47 @@
+/*
+ *     Copyright 2021-Present 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 <cstdint>
+
+namespace couchbase::transactions
+{
+/**
+ * Strategy to deal with potential read skews while reading multiple documents.
+ *
+ * Essentially when a transaction reads document X and then Y, and another
+ * transaction commits a change to Y inbetween those reads - read skew has
+ * occurred.
+ */
+enum class transaction_get_multi_mode : std::uint8_t {
+  /**
+   * Some time-bounded effort will be made to detect and avoid read skew.
+   */
+  prioritise_latency,
+
+  /**
+   * No read skew detection should be attempted. Once the documents are fetched, they will be
+   * returned immediately.
+   */
+  disable_read_skew_detection,
+
+  /**
+   * Great effort will be made to detect and avoid read skew.
+   */
+  prioritise_read_skew_detection,
+};
+
+} // namespace couchbase::transactions

data/ext/couchbase/couchbase/transactions/transaction_get_multi_options.hxx

@@ -0,0 +1,44 @@
+/*
+ *     Copyright 2021-Present 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 <couchbase/transactions/transaction_get_multi_mode.hxx>
+
+namespace couchbase
+{
+namespace core::transactions
+{
+class attempt_context_impl;
+} // namespace core::transactions
+
+namespace transactions
+{
+class transaction_get_multi_options
+{
+public:
+  auto mode(transaction_get_multi_mode mode) -> transaction_get_multi_options&
+  {
+    mode_ = mode;
+    return *this;
+  }
+
+private:
+  friend class core::transactions::attempt_context_impl;
+
+  transaction_get_multi_mode mode_{ transaction_get_multi_mode::prioritise_latency };
+};
+} // namespace transactions
+} // namespace couchbase

data/ext/couchbase/couchbase/transactions/transaction_get_multi_replicas_from_preferred_server_group_mode.hxx

@@ -0,0 +1,46 @@
+/*
+ *     Copyright 2021-Present 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 <cstdint>
+
+namespace couchbase::transactions
+{
+/**
+ * Strategy to deal with potential read skews while reading multiple documents.
+ *
+ * Essentially when a transaction reads document X and then Y, and another
+ * transaction commits a change to Y inbetween those reads - read skew has
+ * occurred.
+ */
+enum class transaction_get_multi_replicas_from_preferred_server_group_mode : std::uint8_t {
+  /**
+   * Some time-bounded effort will be made to detect and avoid read skew.
+   */
+  prioritise_latency,
+
+  /**
+   * No read skew detection should be attempted. Once the documents are fetched, they will be
+   * returned immediately.
+   */
+  disable_read_skew_detection,
+
+  /**
+   * Great effort will be made to detect and avoid read skew.
+   */
+  prioritise_read_skew_detection,
+};
+} // namespace couchbase::transactions

data/ext/couchbase/couchbase/transactions/transaction_get_multi_replicas_from_preferred_server_group_options.hxx

@@ -0,0 +1,48 @@
+/*
+ *     Copyright 2021-Present 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 <couchbase/transactions/transaction_get_multi_replicas_from_preferred_server_group_mode.hxx>
+
+namespace couchbase
+{
+namespace core::transactions
+{
+class attempt_context_impl;
+} // namespace core::transactions
+
+namespace transactions
+{
+class transaction_get_multi_replicas_from_preferred_server_group_options
+{
+public:
+  auto mode(transaction_get_multi_replicas_from_preferred_server_group_mode mode)
+    -> transaction_get_multi_replicas_from_preferred_server_group_options&
+  {
+    mode_ = mode;
+    return *this;
+  }
+
+private:
+  friend class core::transactions::attempt_context_impl;
+
+  transaction_get_multi_replicas_from_preferred_server_group_mode mode_{
+    transaction_get_multi_replicas_from_preferred_server_group_mode::prioritise_latency
+  };
+};
+
+} // namespace transactions
+} // namespace couchbase

data/ext/couchbase/couchbase/transactions/transaction_get_multi_replicas_from_preferred_server_group_result.hxx

@@ -0,0 +1,109 @@
+/*
+ *     Copyright 2021-Present 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 "couchbase/error_codes.hxx"
+#include <couchbase/codec/default_json_transcoder.hxx>
+
+#include <optional>
+#include <stdexcept>
+#include <system_error>
+#include <vector>
+
+namespace couchbase
+{
+namespace core::transactions
+{
+class attempt_context_impl;
+} // namespace core::transactions
+
+namespace transactions
+{
+class transaction_get_multi_replicas_from_preferred_server_group_result
+{
+public:
+  transaction_get_multi_replicas_from_preferred_server_group_result(
+    const transaction_get_multi_replicas_from_preferred_server_group_result&) = default;
+  ~transaction_get_multi_replicas_from_preferred_server_group_result() = default;
+  transaction_get_multi_replicas_from_preferred_server_group_result(
+    transaction_get_multi_replicas_from_preferred_server_group_result&&) = default;
+  auto operator=(const transaction_get_multi_replicas_from_preferred_server_group_result&)
+    -> transaction_get_multi_replicas_from_preferred_server_group_result& = default;
+  auto operator=(transaction_get_multi_replicas_from_preferred_server_group_result&&)
+    -> transaction_get_multi_replicas_from_preferred_server_group_result& = default;
+
+  /**
+   * Content of the document.
+   *
+   * @return content of the document.
+   */
+  template<typename Document,
+           typename Transcoder = codec::default_json_transcoder,
+           std::enable_if_t<!codec::is_transcoder_v<Document>, bool> = true,
+           std::enable_if_t<codec::is_transcoder_v<Transcoder>, bool> = true>
+  [[nodiscard]] auto content_as(std::size_t spec_index) const -> Document
+  {
+    if (spec_index >= content_.size()) {
+      throw std::invalid_argument("spec index " + std::to_string(spec_index) + " is not valid");
+    }
+    if (const auto& content = content_[spec_index]; content.has_value()) {
+      return Transcoder::template decode<Document>(content.value());
+    }
+    throw std::system_error(errc::key_value::document_not_found,
+                            "document was not found for index " + std::to_string(spec_index));
+  }
+
+  /**
+   * Content of the document.
+   *
+   * @return content of the document.
+   */
+  template<typename Transcoder, std::enable_if_t<codec::is_transcoder_v<Transcoder>, bool> = true>
+  [[nodiscard]] auto content_as(std::size_t spec_index) const -> typename Transcoder::document_type
+  {
+    if (spec_index >= content_.size()) {
+      throw std::invalid_argument("spec index " + std::to_string(spec_index) + " is not valid");
+    }
+    if (const auto& content = content_[spec_index]; content.has_value()) {
+      return Transcoder::decode(content.value());
+    }
+    throw std::system_error(errc::key_value::document_not_found,
+                            "document was not found for index " + std::to_string(spec_index));
+  }
+
+  /**
+   * Check if spec returned any content
+   *
+   * @return the id of this document.
+   */
+  [[nodiscard]] auto exists(std::size_t spec_index) const -> bool
+  {
+    return spec_index >= content_.size() && content_[spec_index].has_value();
+  }
+
+private:
+  friend core::transactions::attempt_context_impl;
+
+  explicit transaction_get_multi_replicas_from_preferred_server_group_result(
+    std::vector<std::optional<codec::encoded_value>> content)
+    : content_{ std::move(content) }
+  {
+  }
+
+  std::vector<std::optional<codec::encoded_value>> content_;
+};
+} // namespace transactions
+} // namespace couchbase

data/ext/couchbase/couchbase/transactions/transaction_get_multi_replicas_from_preferred_server_group_spec.hxx

@@ -0,0 +1,47 @@
+/*
+ *     Copyright 2021-Present 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 <string>
+
+namespace couchbase
+{
+class collection;
+namespace core::transactions
+{
+class attempt_context_impl;
+} // namespace core::transactions
+
+namespace transactions
+{
+class transaction_get_multi_replicas_from_preferred_server_group_spec
+{
+public:
+  transaction_get_multi_replicas_from_preferred_server_group_spec(
+    const couchbase::collection& collection,
+    std::string id);
+
+private:
+  friend class core::transactions::attempt_context_impl;
+
+  std::string bucket_;
+  std::string scope_;
+  std::string collection_;
+  std::string id_;
+};
+
+} // namespace transactions
+} // namespace couchbase

data/ext/couchbase/couchbase/transactions/transaction_get_multi_result.hxx

@@ -0,0 +1,102 @@
+/*
+ *     Copyright 2021-Present 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 <couchbase/codec/default_json_transcoder.hxx>
+
+#include <optional>
+#include <vector>
+
+namespace couchbase
+{
+namespace core::transactions
+{
+class attempt_context_impl;
+} // namespace core::transactions
+
+namespace transactions
+{
+class transaction_get_multi_result
+{
+public:
+  transaction_get_multi_result() = default;
+  ~transaction_get_multi_result() = default;
+  transaction_get_multi_result(const transaction_get_multi_result&) = default;
+  transaction_get_multi_result(transaction_get_multi_result&&) = default;
+  auto operator=(const transaction_get_multi_result&) -> transaction_get_multi_result& = default;
+  auto operator=(transaction_get_multi_result&&) -> transaction_get_multi_result& = default;
+
+  /**
+   * Content of the document.
+   *
+   * @return content of the document.
+   */
+  template<typename Document,
+           typename Transcoder = codec::default_json_transcoder,
+           std::enable_if_t<!codec::is_transcoder_v<Document>, bool> = true,
+           std::enable_if_t<codec::is_transcoder_v<Transcoder>, bool> = true>
+  [[nodiscard]] auto content_as(std::size_t spec_index) const -> Document
+  {
+    if (spec_index >= content_.size()) {
+      throw std::invalid_argument("spec index " + std::to_string(spec_index) + " is not valid");
+    }
+    if (const auto& content = content_[spec_index]; content.has_value()) {
+      return Transcoder::template decode<Document>(content.value());
+    }
+    throw std::system_error(errc::key_value::document_not_found,
+                            "document was not found for index " + std::to_string(spec_index));
+  }
+
+  /**
+   * Content of the document.
+   *
+   * @return content of the document.
+   */
+  template<typename Transcoder, std::enable_if_t<codec::is_transcoder_v<Transcoder>, bool> = true>
+  [[nodiscard]] auto content_as(std::size_t spec_index) const -> typename Transcoder::document_type
+  {
+    if (spec_index >= content_.size()) {
+      throw std::invalid_argument("spec index " + std::to_string(spec_index) + " is not valid");
+    }
+    if (const auto& content = content_[spec_index]; content.has_value()) {
+      return Transcoder::decode(content_[spec_index]);
+    }
+    throw std::system_error(errc::key_value::document_not_found,
+                            "document was not found for index " + std::to_string(spec_index));
+  }
+
+  /**
+   * Check if spec returned any content
+   *
+   * @return the id of this document.
+   */
+  [[nodiscard]] auto exists(std::size_t spec_index) const -> bool
+  {
+    return spec_index >= content_.size() && content_[spec_index].has_value();
+  }
+
+private:
+  friend core::transactions::attempt_context_impl;
+
+  explicit transaction_get_multi_result(std::vector<std::optional<codec::encoded_value>> content)
+    : content_{ std::move(content) }
+  {
+  }
+
+  std::vector<std::optional<codec::encoded_value>> content_;
+};
+} // namespace transactions
+} // namespace couchbase

data/ext/couchbase/couchbase/transactions/transaction_get_multi_spec.hxx

@@ -0,0 +1,45 @@
+/*
+ *     Copyright 2021-Present 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 <string>
+
+namespace couchbase
+{
+class collection;
+namespace core::transactions
+{
+class attempt_context_impl;
+} // namespace core::transactions
+
+namespace transactions
+{
+class transaction_get_multi_spec
+{
+public:
+  transaction_get_multi_spec(const couchbase::collection& collection, std::string id);
+
+private:
+  friend class core::transactions::attempt_context_impl;
+
+  std::string bucket_;
+  std::string scope_;
+  std::string collection_;
+  std::string id_;
+};
+
+} // namespace transactions
+} // namespace couchbase

data/ext/extconf.rb

@@ -93,6 +93,12 @@ cmake_flags = [
   "-DCOUCHBASE_CXX_CLIENT_INSTALL=OFF",
 ]
 
+if version.start_with?("4")
+  # snappy requires CMake 3.1
+  cmake_flags << "-DCMAKE_POLICY_VERSION_MINIMUM=3.5"
+end
+
+
 extconf_include = File.expand_path("cache/extconf_include.rb", __dir__)
 if File.exist?(extconf_include)
   puts "-- include extra cmake options from #{extconf_include}"

data/ext/rcb_buckets.cxx

@@ -232,6 +232,17 @@ cb_generate_bucket_settings(VALUE bucket,
     }
   }
 
+  if (VALUE num_vbuckets = rb_hash_aref(bucket, rb_id2sym(rb_intern("num_vbuckets")));
+      !NIL_P(num_vbuckets)) {
+    if (TYPE(num_vbuckets) == T_FIXNUM) {
+      entry.num_vbuckets = FIX2UINT(num_vbuckets);
+    } else {
+      throw ruby_exception(
+        rb_eArgError,
+        rb_sprintf("num vbuckets must be an Integer, given %+" PRIsVALUE, num_vbuckets));
+    }
+  }
+
   if (is_create) {
     if (VALUE conflict_resolution_type =
           rb_hash_aref(bucket, rb_id2sym(rb_intern("conflict_resolution_type")));
@@ -506,6 +517,18 @@ cb_extract_bucket_settings(const core::management::cluster::bucket_settings& ent
         break;
     }
   }
+  switch (entry.storage_backend) {
+    case core::management::cluster::bucket_storage_backend::couchstore:
+      rb_hash_aset(
+        bucket, rb_id2sym(rb_intern("storage_backend")), rb_id2sym(rb_intern("couchstore")));
+      break;
+    case core::management::cluster::bucket_storage_backend::magma:
+      rb_hash_aset(bucket, rb_id2sym(rb_intern("storage_backend")), rb_id2sym(rb_intern("magma")));
+      break;
+    case core::management::cluster::bucket_storage_backend::unknown:
+      rb_hash_aset(bucket, rb_id2sym(rb_intern("storage_backend")), Qnil);
+      break;
+  }
   if (entry.history_retention_collection_default.has_value()) {
     rb_hash_aset(bucket,
                  rb_id2sym(rb_intern("history_retention_collection_default")),
@@ -518,6 +541,9 @@ cb_extract_bucket_settings(const core::management::cluster::bucket_settings& ent
     rb_hash_aset(
       bucket, rb_id2sym(rb_intern("history_retention_duration")), ULONG2NUM(val.value()));
   }
+  if (const auto& val = entry.num_vbuckets; val.has_value()) {
+    rb_hash_aset(bucket, rb_id2sym(rb_intern("num_vbuckets")), USHORT2NUM(val.value()));
+  }
 
   VALUE capabilities = rb_ary_new_capa(static_cast<long>(entry.capabilities.size()));
   for (const auto& capa : entry.capabilities) {

data/lib/active_support/cache/couchbase_store.rb

@@ -316,7 +316,7 @@ module ActiveSupport
           @couchbase_options[:connection_string],
           ::Couchbase::Options::Cluster(authenticator: ::Couchbase::PasswordAuthenticator.new(
             @couchbase_options[:username], @couchbase_options[:password]
-          ))
+          )),
         )
       end
 

data/lib/couchbase/cluster.rb

@@ -391,7 +391,7 @@ module Couchbase
                     location.end_offset = loc[:end_offset]
                     location.array_positions = loc[:array_positions]
                   end
-                end
+                end,
               )
             end
             row.instance_variable_set(:@fields, r[:fields])

data/lib/couchbase/collection.rb

@@ -626,7 +626,7 @@ module Couchbase
         core_scan_result: @backend.document_scan_create(
           @bucket_name, @scope_name, @name, scan_type.to_backend, options.to_backend
         ),
-        transcoder: options.transcoder
+        transcoder: options.transcoder,
       )
     end
 

data/lib/couchbase/collection_options.rb

@@ -381,7 +381,7 @@ module Couchbase
             yield ScanResult.new(
               id: resp[:id],
               id_only: resp[:id_only],
-              transcoder: @transcoder
+              transcoder: @transcoder,
             )
           else
             yield ScanResult.new(
@@ -391,7 +391,7 @@ module Couchbase
               expiry: resp[:expiry],
               encoded: resp[:encoded],
               flags: resp[:flags],
-              transcoder: @transcoder
+              transcoder: @transcoder,
             )
           end
         end

data/lib/couchbase/management/analytics_index_manager.rb

@@ -846,7 +846,7 @@ module Couchbase
               entry[:access_key_id],
               nil,
               entry[:region],
-              service_endpoint: entry[:service_endpoint]
+              service_endpoint: entry[:service_endpoint],
             )
           when :couchbase
             CouchbaseRemoteAnalyticsLink.new(
@@ -857,8 +857,8 @@ module Couchbase
               encryption: EncryptionSettings.new(
                 level: entry[:encryption_level],
                 certificate: entry[:certificate],
-                client_certificate: entry[:client_certificate]
-              )
+                client_certificate: entry[:client_certificate],
+              ),
             )
           when :azureblob
             AzureBlobExternalAnalyticsLink.new(
@@ -866,7 +866,7 @@ module Couchbase
               entry[:dataverse],
               account_name: entry[:account_name],
               blob_endpoint: entry[:blob_endpoint],
-              endpoint_suffix: entry[:endpoint_suffix]
+              endpoint_suffix: entry[:endpoint_suffix],
             )
           end
         end

data/lib/couchbase/management/bucket_manager.rb

@@ -206,7 +206,6 @@ module Couchbase
       def create_bucket(settings, options = Options::Bucket::CreateBucket.new)
         @backend.bucket_create(
           {
-
             name: settings.name,
             flush_enabled: settings.flush_enabled,
             ram_quota_mb: settings.ram_quota_mb,
@@ -222,6 +221,7 @@ module Couchbase
             history_retention_collection_default: settings.history_retention_collection_default,
             history_retention_duration: settings.history_retention_duration,
             history_retention_bytes: settings.history_retention_bytes,
+            num_vbuckets: settings.num_vbuckets,
           }, options.to_backend
         )
       end
@@ -252,6 +252,7 @@ module Couchbase
             history_retention_collection_default: settings.history_retention_collection_default,
             history_retention_bytes: settings.history_retention_bytes,
             history_retention_duration: settings.history_retention_duration,
+            num_vbuckets: settings.num_vbuckets,
           }, options.to_backend
         )
       end
@@ -342,9 +343,11 @@ module Couchbase
           bucket.minimum_durability_level = entry[:minimum_durability_level]
           bucket.compression_mode = entry[:compression_mode]
           bucket.instance_variable_set(:@healthy, entry[:nodes].all? { |node| node[:status] == "healthy" })
+          bucket.storage_backend = entry[:storage_backend]
           bucket.history_retention_collection_default = entry[:history_retention_collection_default]
           bucket.history_retention_bytes = entry[:history_retention_bytes]
           bucket.history_retention_duration = entry[:history_retention_duration]
+          bucket.num_vbuckets = entry[:num_vbuckets]
         end
       end
     end
@@ -405,7 +408,7 @@ module Couchbase
       # @return [nil, :none, :majority, :majority_and_persist_to_active, :persist_to_majority] the minimum durability level
       attr_accessor :minimum_durability_level
 
-      # @return [Boolean, nil] whether to enable history retention on collections  by default
+      # @return [Boolean, nil] whether to enable history retention on collections by default
       attr_accessor :history_retention_collection_default
 
       # @return [Integer, nil] the maximum size, in bytes, of the change history that is written to disk for all
@@ -416,6 +419,9 @@ module Couchbase
       # collections in this bucket
       attr_accessor :history_retention_duration
 
+      # @return [Integer, nil] the number of vBuckets the bucket should have. If not set, the server default will be used
+      attr_accessor :num_vbuckets
+
       # @api private
       # @return [Boolean] false if status of the bucket is not healthy
       def healthy?